PageRenderTime 92ms CodeModel.GetById 18ms app.highlight 61ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/net/ethernet/toshiba/spider_net.c

http://github.com/mirrors/linux
C | 2536 lines | 1534 code | 347 blank | 655 comment | 217 complexity | c7a54bf7689ad572b30378f10f09287f MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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 <net/checksum.h>
  39
  40#include "spider_net.h"
  41
  42MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com> and Jens Osterkamp " \
  43	      "<Jens.Osterkamp@de.ibm.com>");
  44MODULE_DESCRIPTION("Spider Southbridge Gigabit Ethernet driver");
  45MODULE_LICENSE("GPL");
  46MODULE_VERSION(VERSION);
  47MODULE_FIRMWARE(SPIDER_NET_FIRMWARE_NAME);
  48
  49static int rx_descriptors = SPIDER_NET_RX_DESCRIPTORS_DEFAULT;
  50static int tx_descriptors = SPIDER_NET_TX_DESCRIPTORS_DEFAULT;
  51
  52module_param(rx_descriptors, int, 0444);
  53module_param(tx_descriptors, int, 0444);
  54
  55MODULE_PARM_DESC(rx_descriptors, "number of descriptors used " \
  56		 "in rx chains");
  57MODULE_PARM_DESC(tx_descriptors, "number of descriptors used " \
  58		 "in tx chain");
  59
  60char spider_net_driver_name[] = "spidernet";
  61
  62static const struct pci_device_id spider_net_pci_tbl[] = {
  63	{ PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET,
  64	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
  65	{ 0, }
  66};
  67
  68MODULE_DEVICE_TABLE(pci, spider_net_pci_tbl);
  69
  70/**
  71 * spider_net_read_reg - reads an SMMIO register of a card
  72 * @card: device structure
  73 * @reg: register to read from
  74 *
  75 * returns the content of the specified SMMIO register.
  76 */
  77static inline u32
  78spider_net_read_reg(struct spider_net_card *card, u32 reg)
  79{
  80	/* We use the powerpc specific variants instead of readl_be() because
  81	 * we know spidernet is not a real PCI device and we can thus avoid the
  82	 * performance hit caused by the PCI workarounds.
  83	 */
  84	return in_be32(card->regs + reg);
  85}
  86
  87/**
  88 * spider_net_write_reg - writes to an SMMIO register of a card
  89 * @card: device structure
  90 * @reg: register to write to
  91 * @value: value to write into the specified SMMIO register
  92 */
  93static inline void
  94spider_net_write_reg(struct spider_net_card *card, u32 reg, u32 value)
  95{
  96	/* We use the powerpc specific variants instead of writel_be() because
  97	 * we know spidernet is not a real PCI device and we can thus avoid the
  98	 * performance hit caused by the PCI workarounds.
  99	 */
 100	out_be32(card->regs + reg, value);
 101}
 102
 103/**
 104 * spider_net_write_phy - write to phy register
 105 * @netdev: adapter to be written to
 106 * @mii_id: id of MII
 107 * @reg: PHY register
 108 * @val: value to be written to phy register
 109 *
 110 * spider_net_write_phy_register writes to an arbitrary PHY
 111 * register via the spider GPCWOPCMD register. We assume the queue does
 112 * not run full (not more than 15 commands outstanding).
 113 **/
 114static void
 115spider_net_write_phy(struct net_device *netdev, int mii_id,
 116		     int reg, int val)
 117{
 118	struct spider_net_card *card = netdev_priv(netdev);
 119	u32 writevalue;
 120
 121	writevalue = ((u32)mii_id << 21) |
 122		((u32)reg << 16) | ((u32)val);
 123
 124	spider_net_write_reg(card, SPIDER_NET_GPCWOPCMD, writevalue);
 125}
 126
 127/**
 128 * spider_net_read_phy - read from phy register
 129 * @netdev: network device to be read from
 130 * @mii_id: id of MII
 131 * @reg: PHY register
 132 *
 133 * Returns value read from PHY register
 134 *
 135 * spider_net_write_phy reads from an arbitrary PHY
 136 * register via the spider GPCROPCMD register
 137 **/
 138static int
 139spider_net_read_phy(struct net_device *netdev, int mii_id, int reg)
 140{
 141	struct spider_net_card *card = netdev_priv(netdev);
 142	u32 readvalue;
 143
 144	readvalue = ((u32)mii_id << 21) | ((u32)reg << 16);
 145	spider_net_write_reg(card, SPIDER_NET_GPCROPCMD, readvalue);
 146
 147	/* we don't use semaphores to wait for an SPIDER_NET_GPROPCMPINT
 148	 * interrupt, as we poll for the completion of the read operation
 149	 * in spider_net_read_phy. Should take about 50 us */
 150	do {
 151		readvalue = spider_net_read_reg(card, SPIDER_NET_GPCROPCMD);
 152	} while (readvalue & SPIDER_NET_GPREXEC);
 153
 154	readvalue &= SPIDER_NET_GPRDAT_MASK;
 155
 156	return readvalue;
 157}
 158
 159/**
 160 * spider_net_setup_aneg - initial auto-negotiation setup
 161 * @card: device structure
 162 **/
 163static void
 164spider_net_setup_aneg(struct spider_net_card *card)
 165{
 166	struct mii_phy *phy = &card->phy;
 167	u32 advertise = 0;
 168	u16 bmsr, estat;
 169
 170	bmsr  = spider_net_read_phy(card->netdev, phy->mii_id, MII_BMSR);
 171	estat = spider_net_read_phy(card->netdev, phy->mii_id, MII_ESTATUS);
 172
 173	if (bmsr & BMSR_10HALF)
 174		advertise |= ADVERTISED_10baseT_Half;
 175	if (bmsr & BMSR_10FULL)
 176		advertise |= ADVERTISED_10baseT_Full;
 177	if (bmsr & BMSR_100HALF)
 178		advertise |= ADVERTISED_100baseT_Half;
 179	if (bmsr & BMSR_100FULL)
 180		advertise |= ADVERTISED_100baseT_Full;
 181
 182	if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_TFULL))
 183		advertise |= SUPPORTED_1000baseT_Full;
 184	if ((bmsr & BMSR_ESTATEN) && (estat & ESTATUS_1000_THALF))
 185		advertise |= SUPPORTED_1000baseT_Half;
 186
 187	sungem_phy_probe(phy, phy->mii_id);
 188	phy->def->ops->setup_aneg(phy, advertise);
 189
 190}
 191
 192/**
 193 * spider_net_rx_irq_off - switch off rx irq on this spider card
 194 * @card: device structure
 195 *
 196 * switches off rx irq by masking them out in the GHIINTnMSK register
 197 */
 198static void
 199spider_net_rx_irq_off(struct spider_net_card *card)
 200{
 201	u32 regvalue;
 202
 203	regvalue = SPIDER_NET_INT0_MASK_VALUE & (~SPIDER_NET_RXINT);
 204	spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue);
 205}
 206
 207/**
 208 * spider_net_rx_irq_on - switch on rx irq on this spider card
 209 * @card: device structure
 210 *
 211 * switches on rx irq by enabling them in the GHIINTnMSK register
 212 */
 213static void
 214spider_net_rx_irq_on(struct spider_net_card *card)
 215{
 216	u32 regvalue;
 217
 218	regvalue = SPIDER_NET_INT0_MASK_VALUE | SPIDER_NET_RXINT;
 219	spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, regvalue);
 220}
 221
 222/**
 223 * spider_net_set_promisc - sets the unicast address or the promiscuous mode
 224 * @card: card structure
 225 *
 226 * spider_net_set_promisc sets the unicast destination address filter and
 227 * thus either allows for non-promisc mode or promisc mode
 228 */
 229static void
 230spider_net_set_promisc(struct spider_net_card *card)
 231{
 232	u32 macu, macl;
 233	struct net_device *netdev = card->netdev;
 234
 235	if (netdev->flags & IFF_PROMISC) {
 236		/* clear destination entry 0 */
 237		spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, 0);
 238		spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, 0);
 239		spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
 240				     SPIDER_NET_PROMISC_VALUE);
 241	} else {
 242		macu = netdev->dev_addr[0];
 243		macu <<= 8;
 244		macu |= netdev->dev_addr[1];
 245		memcpy(&macl, &netdev->dev_addr[2], sizeof(macl));
 246
 247		macu |= SPIDER_NET_UA_DESCR_VALUE;
 248		spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR, macu);
 249		spider_net_write_reg(card, SPIDER_NET_GMRUAFILnR + 0x04, macl);
 250		spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R,
 251				     SPIDER_NET_NONPROMISC_VALUE);
 252	}
 253}
 254
 255/**
 256 * spider_net_get_descr_status -- returns the status of a descriptor
 257 * @descr: descriptor to look at
 258 *
 259 * returns the status as in the dmac_cmd_status field of the descriptor
 260 */
 261static inline int
 262spider_net_get_descr_status(struct spider_net_hw_descr *hwdescr)
 263{
 264	return hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_IND_PROC_MASK;
 265}
 266
 267/**
 268 * spider_net_free_chain - free descriptor chain
 269 * @card: card structure
 270 * @chain: address of chain
 271 *
 272 */
 273static void
 274spider_net_free_chain(struct spider_net_card *card,
 275		      struct spider_net_descr_chain *chain)
 276{
 277	struct spider_net_descr *descr;
 278
 279	descr = chain->ring;
 280	do {
 281		descr->bus_addr = 0;
 282		descr->hwdescr->next_descr_addr = 0;
 283		descr = descr->next;
 284	} while (descr != chain->ring);
 285
 286	dma_free_coherent(&card->pdev->dev, chain->num_desc,
 287	    chain->hwring, chain->dma_addr);
 288}
 289
 290/**
 291 * spider_net_init_chain - alloc and link descriptor chain
 292 * @card: card structure
 293 * @chain: address of chain
 294 *
 295 * We manage a circular list that mirrors the hardware structure,
 296 * except that the hardware uses bus addresses.
 297 *
 298 * Returns 0 on success, <0 on failure
 299 */
 300static int
 301spider_net_init_chain(struct spider_net_card *card,
 302		       struct spider_net_descr_chain *chain)
 303{
 304	int i;
 305	struct spider_net_descr *descr;
 306	struct spider_net_hw_descr *hwdescr;
 307	dma_addr_t buf;
 308	size_t alloc_size;
 309
 310	alloc_size = chain->num_desc * sizeof(struct spider_net_hw_descr);
 311
 312	chain->hwring = dma_alloc_coherent(&card->pdev->dev, alloc_size,
 313					   &chain->dma_addr, GFP_KERNEL);
 314	if (!chain->hwring)
 315		return -ENOMEM;
 316
 317	memset(chain->ring, 0, chain->num_desc * sizeof(struct spider_net_descr));
 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 */
 350static void
 351spider_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			pci_unmap_single(card->pdev, descr->hwdescr->buf_addr,
 359					 SPIDER_NET_MAX_FRAME,
 360					 PCI_DMA_BIDIRECTIONAL);
 361			dev_kfree_skb(descr->skb);
 362			descr->skb = NULL;
 363		}
 364		descr = descr->next;
 365	} while (descr != card->rx_chain.head);
 366}
 367
 368/**
 369 * spider_net_prepare_rx_descr - Reinitialize RX descriptor
 370 * @card: card structure
 371 * @descr: descriptor to re-init
 372 *
 373 * Return 0 on success, <0 on failure.
 374 *
 375 * Allocates a new rx skb, iommu-maps it and attaches it to the
 376 * descriptor. Mark the descriptor as activated, ready-to-use.
 377 */
 378static int
 379spider_net_prepare_rx_descr(struct spider_net_card *card,
 380			    struct spider_net_descr *descr)
 381{
 382	struct spider_net_hw_descr *hwdescr = descr->hwdescr;
 383	dma_addr_t buf;
 384	int offset;
 385	int bufsize;
 386
 387	/* we need to round up the buffer size to a multiple of 128 */
 388	bufsize = (SPIDER_NET_MAX_FRAME + SPIDER_NET_RXBUF_ALIGN - 1) &
 389		(~(SPIDER_NET_RXBUF_ALIGN - 1));
 390
 391	/* and we need to have it 128 byte aligned, therefore we allocate a
 392	 * bit more */
 393	/* allocate an skb */
 394	descr->skb = netdev_alloc_skb(card->netdev,
 395				      bufsize + SPIDER_NET_RXBUF_ALIGN - 1);
 396	if (!descr->skb) {
 397		if (netif_msg_rx_err(card) && net_ratelimit())
 398			dev_err(&card->netdev->dev,
 399			        "Not enough memory to allocate rx buffer\n");
 400		card->spider_stats.alloc_rx_skb_error++;
 401		return -ENOMEM;
 402	}
 403	hwdescr->buf_size = bufsize;
 404	hwdescr->result_size = 0;
 405	hwdescr->valid_size = 0;
 406	hwdescr->data_status = 0;
 407	hwdescr->data_error = 0;
 408
 409	offset = ((unsigned long)descr->skb->data) &
 410		(SPIDER_NET_RXBUF_ALIGN - 1);
 411	if (offset)
 412		skb_reserve(descr->skb, SPIDER_NET_RXBUF_ALIGN - offset);
 413	/* iommu-map the skb */
 414	buf = pci_map_single(card->pdev, descr->skb->data,
 415			SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE);
 416	if (pci_dma_mapping_error(card->pdev, buf)) {
 417		dev_kfree_skb_any(descr->skb);
 418		descr->skb = NULL;
 419		if (netif_msg_rx_err(card) && net_ratelimit())
 420			dev_err(&card->netdev->dev, "Could not iommu-map rx buffer\n");
 421		card->spider_stats.rx_iommu_map_error++;
 422		hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
 423	} else {
 424		hwdescr->buf_addr = buf;
 425		wmb();
 426		hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_CARDOWNED |
 427					 SPIDER_NET_DMAC_NOINTR_COMPLETE;
 428	}
 429
 430	return 0;
 431}
 432
 433/**
 434 * spider_net_enable_rxchtails - sets RX dmac chain tail addresses
 435 * @card: card structure
 436 *
 437 * spider_net_enable_rxchtails sets the RX DMAC chain tail addresses in the
 438 * chip by writing to the appropriate register. DMA is enabled in
 439 * spider_net_enable_rxdmac.
 440 */
 441static inline void
 442spider_net_enable_rxchtails(struct spider_net_card *card)
 443{
 444	/* assume chain is aligned correctly */
 445	spider_net_write_reg(card, SPIDER_NET_GDADCHA ,
 446			     card->rx_chain.tail->bus_addr);
 447}
 448
 449/**
 450 * spider_net_enable_rxdmac - enables a receive DMA controller
 451 * @card: card structure
 452 *
 453 * spider_net_enable_rxdmac enables the DMA controller by setting RX_DMA_EN
 454 * in the GDADMACCNTR register
 455 */
 456static inline void
 457spider_net_enable_rxdmac(struct spider_net_card *card)
 458{
 459	wmb();
 460	spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
 461			     SPIDER_NET_DMA_RX_VALUE);
 462}
 463
 464/**
 465 * spider_net_disable_rxdmac - disables the receive DMA controller
 466 * @card: card structure
 467 *
 468 * spider_net_disable_rxdmac terminates processing on the DMA controller
 469 * by turing off the DMA controller, with the force-end flag set.
 470 */
 471static inline void
 472spider_net_disable_rxdmac(struct spider_net_card *card)
 473{
 474	spider_net_write_reg(card, SPIDER_NET_GDADMACCNTR,
 475			     SPIDER_NET_DMA_RX_FEND_VALUE);
 476}
 477
 478/**
 479 * spider_net_refill_rx_chain - refills descriptors/skbs in the rx chains
 480 * @card: card structure
 481 *
 482 * refills descriptors in the rx chain: allocates skbs and iommu-maps them.
 483 */
 484static void
 485spider_net_refill_rx_chain(struct spider_net_card *card)
 486{
 487	struct spider_net_descr_chain *chain = &card->rx_chain;
 488	unsigned long flags;
 489
 490	/* one context doing the refill (and a second context seeing that
 491	 * and omitting it) is ok. If called by NAPI, we'll be called again
 492	 * as spider_net_decode_one_descr is called several times. If some
 493	 * interrupt calls us, the NAPI is about to clean up anyway. */
 494	if (!spin_trylock_irqsave(&chain->lock, flags))
 495		return;
 496
 497	while (spider_net_get_descr_status(chain->head->hwdescr) ==
 498			SPIDER_NET_DESCR_NOT_IN_USE) {
 499		if (spider_net_prepare_rx_descr(card, chain->head))
 500			break;
 501		chain->head = chain->head->next;
 502	}
 503
 504	spin_unlock_irqrestore(&chain->lock, flags);
 505}
 506
 507/**
 508 * spider_net_alloc_rx_skbs - Allocates rx skbs in rx descriptor chains
 509 * @card: card structure
 510 *
 511 * Returns 0 on success, <0 on failure.
 512 */
 513static int
 514spider_net_alloc_rx_skbs(struct spider_net_card *card)
 515{
 516	struct spider_net_descr_chain *chain = &card->rx_chain;
 517	struct spider_net_descr *start = chain->tail;
 518	struct spider_net_descr *descr = start;
 519
 520	/* Link up the hardware chain pointers */
 521	do {
 522		descr->prev->hwdescr->next_descr_addr = descr->bus_addr;
 523		descr = descr->next;
 524	} while (descr != start);
 525
 526	/* Put at least one buffer into the chain. if this fails,
 527	 * we've got a problem. If not, spider_net_refill_rx_chain
 528	 * will do the rest at the end of this function. */
 529	if (spider_net_prepare_rx_descr(card, chain->head))
 530		goto error;
 531	else
 532		chain->head = chain->head->next;
 533
 534	/* This will allocate the rest of the rx buffers;
 535	 * if not, it's business as usual later on. */
 536	spider_net_refill_rx_chain(card);
 537	spider_net_enable_rxdmac(card);
 538	return 0;
 539
 540error:
 541	spider_net_free_rx_chain_contents(card);
 542	return -ENOMEM;
 543}
 544
 545/**
 546 * spider_net_get_multicast_hash - generates hash for multicast filter table
 547 * @addr: multicast address
 548 *
 549 * returns the hash value.
 550 *
 551 * spider_net_get_multicast_hash calculates a hash value for a given multicast
 552 * address, that is used to set the multicast filter tables
 553 */
 554static u8
 555spider_net_get_multicast_hash(struct net_device *netdev, __u8 *addr)
 556{
 557	u32 crc;
 558	u8 hash;
 559	char addr_for_crc[ETH_ALEN] = { 0, };
 560	int i, bit;
 561
 562	for (i = 0; i < ETH_ALEN * 8; i++) {
 563		bit = (addr[i / 8] >> (i % 8)) & 1;
 564		addr_for_crc[ETH_ALEN - 1 - i / 8] += bit << (7 - (i % 8));
 565	}
 566
 567	crc = crc32_be(~0, addr_for_crc, netdev->addr_len);
 568
 569	hash = (crc >> 27);
 570	hash <<= 3;
 571	hash |= crc & 7;
 572	hash &= 0xff;
 573
 574	return hash;
 575}
 576
 577/**
 578 * spider_net_set_multi - sets multicast addresses and promisc flags
 579 * @netdev: interface device structure
 580 *
 581 * spider_net_set_multi configures multicast addresses as needed for the
 582 * netdev interface. It also sets up multicast, allmulti and promisc
 583 * flags appropriately
 584 */
 585static void
 586spider_net_set_multi(struct net_device *netdev)
 587{
 588	struct netdev_hw_addr *ha;
 589	u8 hash;
 590	int i;
 591	u32 reg;
 592	struct spider_net_card *card = netdev_priv(netdev);
 593	DECLARE_BITMAP(bitmask, SPIDER_NET_MULTICAST_HASHES) = {};
 594
 595	spider_net_set_promisc(card);
 596
 597	if (netdev->flags & IFF_ALLMULTI) {
 598		for (i = 0; i < SPIDER_NET_MULTICAST_HASHES; i++) {
 599			set_bit(i, bitmask);
 600		}
 601		goto write_hash;
 602	}
 603
 604	/* well, we know, what the broadcast hash value is: it's xfd
 605	hash = spider_net_get_multicast_hash(netdev, netdev->broadcast); */
 606	set_bit(0xfd, bitmask);
 607
 608	netdev_for_each_mc_addr(ha, netdev) {
 609		hash = spider_net_get_multicast_hash(netdev, ha->addr);
 610		set_bit(hash, bitmask);
 611	}
 612
 613write_hash:
 614	for (i = 0; i < SPIDER_NET_MULTICAST_HASHES / 4; i++) {
 615		reg = 0;
 616		if (test_bit(i * 4, bitmask))
 617			reg += 0x08;
 618		reg <<= 8;
 619		if (test_bit(i * 4 + 1, bitmask))
 620			reg += 0x08;
 621		reg <<= 8;
 622		if (test_bit(i * 4 + 2, bitmask))
 623			reg += 0x08;
 624		reg <<= 8;
 625		if (test_bit(i * 4 + 3, bitmask))
 626			reg += 0x08;
 627
 628		spider_net_write_reg(card, SPIDER_NET_GMRMHFILnR + i * 4, reg);
 629	}
 630}
 631
 632/**
 633 * spider_net_prepare_tx_descr - fill tx descriptor with skb data
 634 * @card: card structure
 635 * @skb: packet to use
 636 *
 637 * returns 0 on success, <0 on failure.
 638 *
 639 * fills out the descriptor structure with skb data and len. Copies data,
 640 * if needed (32bit DMA!)
 641 */
 642static int
 643spider_net_prepare_tx_descr(struct spider_net_card *card,
 644			    struct sk_buff *skb)
 645{
 646	struct spider_net_descr_chain *chain = &card->tx_chain;
 647	struct spider_net_descr *descr;
 648	struct spider_net_hw_descr *hwdescr;
 649	dma_addr_t buf;
 650	unsigned long flags;
 651
 652	buf = pci_map_single(card->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
 653	if (pci_dma_mapping_error(card->pdev, buf)) {
 654		if (netif_msg_tx_err(card) && net_ratelimit())
 655			dev_err(&card->netdev->dev, "could not iommu-map packet (%p, %i). "
 656				  "Dropping packet\n", skb->data, skb->len);
 657		card->spider_stats.tx_iommu_map_error++;
 658		return -ENOMEM;
 659	}
 660
 661	spin_lock_irqsave(&chain->lock, flags);
 662	descr = card->tx_chain.head;
 663	if (descr->next == chain->tail->prev) {
 664		spin_unlock_irqrestore(&chain->lock, flags);
 665		pci_unmap_single(card->pdev, buf, skb->len, PCI_DMA_TODEVICE);
 666		return -ENOMEM;
 667	}
 668	hwdescr = descr->hwdescr;
 669	chain->head = descr->next;
 670
 671	descr->skb = skb;
 672	hwdescr->buf_addr = buf;
 673	hwdescr->buf_size = skb->len;
 674	hwdescr->next_descr_addr = 0;
 675	hwdescr->data_status = 0;
 676
 677	hwdescr->dmac_cmd_status =
 678			SPIDER_NET_DESCR_CARDOWNED | SPIDER_NET_DMAC_TXFRMTL;
 679	spin_unlock_irqrestore(&chain->lock, flags);
 680
 681	if (skb->ip_summed == CHECKSUM_PARTIAL)
 682		switch (ip_hdr(skb)->protocol) {
 683		case IPPROTO_TCP:
 684			hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_TCP;
 685			break;
 686		case IPPROTO_UDP:
 687			hwdescr->dmac_cmd_status |= SPIDER_NET_DMAC_UDP;
 688			break;
 689		}
 690
 691	/* Chain the bus address, so that the DMA engine finds this descr. */
 692	wmb();
 693	descr->prev->hwdescr->next_descr_addr = descr->bus_addr;
 694
 695	netif_trans_update(card->netdev); /* set netdev watchdog timer */
 696	return 0;
 697}
 698
 699static int
 700spider_net_set_low_watermark(struct spider_net_card *card)
 701{
 702	struct spider_net_descr *descr = card->tx_chain.tail;
 703	struct spider_net_hw_descr *hwdescr;
 704	unsigned long flags;
 705	int status;
 706	int cnt=0;
 707	int i;
 708
 709	/* Measure the length of the queue. Measurement does not
 710	 * need to be precise -- does not need a lock. */
 711	while (descr != card->tx_chain.head) {
 712		status = descr->hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_NOT_IN_USE;
 713		if (status == SPIDER_NET_DESCR_NOT_IN_USE)
 714			break;
 715		descr = descr->next;
 716		cnt++;
 717	}
 718
 719	/* If TX queue is short, don't even bother with interrupts */
 720	if (cnt < card->tx_chain.num_desc/4)
 721		return cnt;
 722
 723	/* Set low-watermark 3/4th's of the way into the queue. */
 724	descr = card->tx_chain.tail;
 725	cnt = (cnt*3)/4;
 726	for (i=0;i<cnt; i++)
 727		descr = descr->next;
 728
 729	/* Set the new watermark, clear the old watermark */
 730	spin_lock_irqsave(&card->tx_chain.lock, flags);
 731	descr->hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_TXDESFLG;
 732	if (card->low_watermark && card->low_watermark != descr) {
 733		hwdescr = card->low_watermark->hwdescr;
 734		hwdescr->dmac_cmd_status =
 735		     hwdescr->dmac_cmd_status & ~SPIDER_NET_DESCR_TXDESFLG;
 736	}
 737	card->low_watermark = descr;
 738	spin_unlock_irqrestore(&card->tx_chain.lock, flags);
 739	return cnt;
 740}
 741
 742/**
 743 * spider_net_release_tx_chain - processes sent tx descriptors
 744 * @card: adapter structure
 745 * @brutal: if set, don't care about whether descriptor seems to be in use
 746 *
 747 * returns 0 if the tx ring is empty, otherwise 1.
 748 *
 749 * spider_net_release_tx_chain releases the tx descriptors that spider has
 750 * finished with (if non-brutal) or simply release tx descriptors (if brutal).
 751 * If some other context is calling this function, we return 1 so that we're
 752 * scheduled again (if we were scheduled) and will not lose initiative.
 753 */
 754static int
 755spider_net_release_tx_chain(struct spider_net_card *card, int brutal)
 756{
 757	struct net_device *dev = card->netdev;
 758	struct spider_net_descr_chain *chain = &card->tx_chain;
 759	struct spider_net_descr *descr;
 760	struct spider_net_hw_descr *hwdescr;
 761	struct sk_buff *skb;
 762	u32 buf_addr;
 763	unsigned long flags;
 764	int status;
 765
 766	while (1) {
 767		spin_lock_irqsave(&chain->lock, flags);
 768		if (chain->tail == chain->head) {
 769			spin_unlock_irqrestore(&chain->lock, flags);
 770			return 0;
 771		}
 772		descr = chain->tail;
 773		hwdescr = descr->hwdescr;
 774
 775		status = spider_net_get_descr_status(hwdescr);
 776		switch (status) {
 777		case SPIDER_NET_DESCR_COMPLETE:
 778			dev->stats.tx_packets++;
 779			dev->stats.tx_bytes += descr->skb->len;
 780			break;
 781
 782		case SPIDER_NET_DESCR_CARDOWNED:
 783			if (!brutal) {
 784				spin_unlock_irqrestore(&chain->lock, flags);
 785				return 1;
 786			}
 787
 788			/* fallthrough, if we release the descriptors
 789			 * brutally (then we don't care about
 790			 * SPIDER_NET_DESCR_CARDOWNED) */
 791			/* Fall through */
 792
 793		case SPIDER_NET_DESCR_RESPONSE_ERROR:
 794		case SPIDER_NET_DESCR_PROTECTION_ERROR:
 795		case SPIDER_NET_DESCR_FORCE_END:
 796			if (netif_msg_tx_err(card))
 797				dev_err(&card->netdev->dev, "forcing end of tx descriptor "
 798				       "with status x%02x\n", status);
 799			dev->stats.tx_errors++;
 800			break;
 801
 802		default:
 803			dev->stats.tx_dropped++;
 804			if (!brutal) {
 805				spin_unlock_irqrestore(&chain->lock, flags);
 806				return 1;
 807			}
 808		}
 809
 810		chain->tail = descr->next;
 811		hwdescr->dmac_cmd_status |= SPIDER_NET_DESCR_NOT_IN_USE;
 812		skb = descr->skb;
 813		descr->skb = NULL;
 814		buf_addr = hwdescr->buf_addr;
 815		spin_unlock_irqrestore(&chain->lock, flags);
 816
 817		/* unmap the skb */
 818		if (skb) {
 819			pci_unmap_single(card->pdev, buf_addr, skb->len,
 820					PCI_DMA_TODEVICE);
 821			dev_consume_skb_any(skb);
 822		}
 823	}
 824	return 0;
 825}
 826
 827/**
 828 * spider_net_kick_tx_dma - enables TX DMA processing
 829 * @card: card structure
 830 *
 831 * This routine will start the transmit DMA running if
 832 * it is not already running. This routine ned only be
 833 * called when queueing a new packet to an empty tx queue.
 834 * Writes the current tx chain head as start address
 835 * of the tx descriptor chain and enables the transmission
 836 * DMA engine.
 837 */
 838static inline void
 839spider_net_kick_tx_dma(struct spider_net_card *card)
 840{
 841	struct spider_net_descr *descr;
 842
 843	if (spider_net_read_reg(card, SPIDER_NET_GDTDMACCNTR) &
 844			SPIDER_NET_TX_DMA_EN)
 845		goto out;
 846
 847	descr = card->tx_chain.tail;
 848	for (;;) {
 849		if (spider_net_get_descr_status(descr->hwdescr) ==
 850				SPIDER_NET_DESCR_CARDOWNED) {
 851			spider_net_write_reg(card, SPIDER_NET_GDTDCHA,
 852					descr->bus_addr);
 853			spider_net_write_reg(card, SPIDER_NET_GDTDMACCNTR,
 854					SPIDER_NET_DMA_TX_VALUE);
 855			break;
 856		}
 857		if (descr == card->tx_chain.head)
 858			break;
 859		descr = descr->next;
 860	}
 861
 862out:
 863	mod_timer(&card->tx_timer, jiffies + SPIDER_NET_TX_TIMER);
 864}
 865
 866/**
 867 * spider_net_xmit - transmits a frame over the device
 868 * @skb: packet to send out
 869 * @netdev: interface device structure
 870 *
 871 * returns NETDEV_TX_OK on success, NETDEV_TX_BUSY on failure
 872 */
 873static netdev_tx_t
 874spider_net_xmit(struct sk_buff *skb, struct net_device *netdev)
 875{
 876	int cnt;
 877	struct spider_net_card *card = netdev_priv(netdev);
 878
 879	spider_net_release_tx_chain(card, 0);
 880
 881	if (spider_net_prepare_tx_descr(card, skb) != 0) {
 882		netdev->stats.tx_dropped++;
 883		netif_stop_queue(netdev);
 884		return NETDEV_TX_BUSY;
 885	}
 886
 887	cnt = spider_net_set_low_watermark(card);
 888	if (cnt < 5)
 889		spider_net_kick_tx_dma(card);
 890	return NETDEV_TX_OK;
 891}
 892
 893/**
 894 * spider_net_cleanup_tx_ring - cleans up the TX ring
 895 * @card: card structure
 896 *
 897 * spider_net_cleanup_tx_ring is called by either the tx_timer
 898 * or from the NAPI polling routine.
 899 * This routine releases resources associted with transmitted
 900 * packets, including updating the queue tail pointer.
 901 */
 902static void
 903spider_net_cleanup_tx_ring(struct timer_list *t)
 904{
 905	struct spider_net_card *card = from_timer(card, t, tx_timer);
 906	if ((spider_net_release_tx_chain(card, 0) != 0) &&
 907	    (card->netdev->flags & IFF_UP)) {
 908		spider_net_kick_tx_dma(card);
 909		netif_wake_queue(card->netdev);
 910	}
 911}
 912
 913/**
 914 * spider_net_do_ioctl - called for device ioctls
 915 * @netdev: interface device structure
 916 * @ifr: request parameter structure for ioctl
 917 * @cmd: command code for ioctl
 918 *
 919 * returns 0 on success, <0 on failure. Currently, we have no special ioctls.
 920 * -EOPNOTSUPP is returned, if an unknown ioctl was requested
 921 */
 922static int
 923spider_net_do_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 924{
 925	switch (cmd) {
 926	default:
 927		return -EOPNOTSUPP;
 928	}
 929}
 930
 931/**
 932 * spider_net_pass_skb_up - takes an skb from a descriptor and passes it on
 933 * @descr: descriptor to process
 934 * @card: card structure
 935 *
 936 * Fills out skb structure and passes the data to the stack.
 937 * The descriptor state is not changed.
 938 */
 939static void
 940spider_net_pass_skb_up(struct spider_net_descr *descr,
 941		       struct spider_net_card *card)
 942{
 943	struct spider_net_hw_descr *hwdescr = descr->hwdescr;
 944	struct sk_buff *skb = descr->skb;
 945	struct net_device *netdev = card->netdev;
 946	u32 data_status = hwdescr->data_status;
 947	u32 data_error = hwdescr->data_error;
 948
 949	skb_put(skb, hwdescr->valid_size);
 950
 951	/* the card seems to add 2 bytes of junk in front
 952	 * of the ethernet frame */
 953#define SPIDER_MISALIGN		2
 954	skb_pull(skb, SPIDER_MISALIGN);
 955	skb->protocol = eth_type_trans(skb, netdev);
 956
 957	/* checksum offload */
 958	skb_checksum_none_assert(skb);
 959	if (netdev->features & NETIF_F_RXCSUM) {
 960		if ( ( (data_status & SPIDER_NET_DATA_STATUS_CKSUM_MASK) ==
 961		       SPIDER_NET_DATA_STATUS_CKSUM_MASK) &&
 962		     !(data_error & SPIDER_NET_DATA_ERR_CKSUM_MASK))
 963			skb->ip_summed = CHECKSUM_UNNECESSARY;
 964	}
 965
 966	if (data_status & SPIDER_NET_VLAN_PACKET) {
 967		/* further enhancements: HW-accel VLAN */
 968	}
 969
 970	/* update netdevice statistics */
 971	netdev->stats.rx_packets++;
 972	netdev->stats.rx_bytes += skb->len;
 973
 974	/* pass skb up to stack */
 975	netif_receive_skb(skb);
 976}
 977
 978static void show_rx_chain(struct spider_net_card *card)
 979{
 980	struct spider_net_descr_chain *chain = &card->rx_chain;
 981	struct spider_net_descr *start= chain->tail;
 982	struct spider_net_descr *descr= start;
 983	struct spider_net_hw_descr *hwd = start->hwdescr;
 984	struct device *dev = &card->netdev->dev;
 985	u32 curr_desc, next_desc;
 986	int status;
 987
 988	int tot = 0;
 989	int cnt = 0;
 990	int off = start - chain->ring;
 991	int cstat = hwd->dmac_cmd_status;
 992
 993	dev_info(dev, "Total number of descrs=%d\n",
 994		chain->num_desc);
 995	dev_info(dev, "Chain tail located at descr=%d, status=0x%x\n",
 996		off, cstat);
 997
 998	curr_desc = spider_net_read_reg(card, SPIDER_NET_GDACTDPA);
 999	next_desc = spider_net_read_reg(card, SPIDER_NET_GDACNEXTDA);
1000
1001	status = cstat;
1002	do
1003	{
1004		hwd = descr->hwdescr;
1005		off = descr - chain->ring;
1006		status = hwd->dmac_cmd_status;
1007
1008		if (descr == chain->head)
1009			dev_info(dev, "Chain head is at %d, head status=0x%x\n",
1010			         off, status);
1011
1012		if (curr_desc == descr->bus_addr)
1013			dev_info(dev, "HW curr desc (GDACTDPA) is at %d, status=0x%x\n",
1014			         off, status);
1015
1016		if (next_desc == descr->bus_addr)
1017			dev_info(dev, "HW next desc (GDACNEXTDA) is at %d, status=0x%x\n",
1018			         off, status);
1019
1020		if (hwd->next_descr_addr == 0)
1021			dev_info(dev, "chain is cut at %d\n", off);
1022
1023		if (cstat != status) {
1024			int from = (chain->num_desc + off - cnt) % chain->num_desc;
1025			int to = (chain->num_desc + off - 1) % chain->num_desc;
1026			dev_info(dev, "Have %d (from %d to %d) descrs "
1027			         "with stat=0x%08x\n", cnt, from, to, cstat);
1028			cstat = status;
1029			cnt = 0;
1030		}
1031
1032		cnt ++;
1033		tot ++;
1034		descr = descr->next;
1035	} while (descr != start);
1036
1037	dev_info(dev, "Last %d descrs with stat=0x%08x "
1038	         "for a total of %d descrs\n", cnt, cstat, tot);
1039
1040#ifdef DEBUG
1041	/* Now dump the whole ring */
1042	descr = start;
1043	do
1044	{
1045		struct spider_net_hw_descr *hwd = descr->hwdescr;
1046		status = spider_net_get_descr_status(hwd);
1047		cnt = descr - chain->ring;
1048		dev_info(dev, "Descr %d stat=0x%08x skb=%p\n",
1049		         cnt, status, descr->skb);
1050		dev_info(dev, "bus addr=%08x buf addr=%08x sz=%d\n",
1051		         descr->bus_addr, hwd->buf_addr, hwd->buf_size);
1052		dev_info(dev, "next=%08x result sz=%d valid sz=%d\n",
1053		         hwd->next_descr_addr, hwd->result_size,
1054		         hwd->valid_size);
1055		dev_info(dev, "dmac=%08x data stat=%08x data err=%08x\n",
1056		         hwd->dmac_cmd_status, hwd->data_status,
1057		         hwd->data_error);
1058		dev_info(dev, "\n");
1059
1060		descr = descr->next;
1061	} while (descr != start);
1062#endif
1063
1064}
1065
1066/**
1067 * spider_net_resync_head_ptr - Advance head ptr past empty descrs
1068 *
1069 * If the driver fails to keep up and empty the queue, then the
1070 * hardware wil run out of room to put incoming packets. This
1071 * will cause the hardware to skip descrs that are full (instead
1072 * of halting/retrying). Thus, once the driver runs, it wil need
1073 * to "catch up" to where the hardware chain pointer is at.
1074 */
1075static void spider_net_resync_head_ptr(struct spider_net_card *card)
1076{
1077	unsigned long flags;
1078	struct spider_net_descr_chain *chain = &card->rx_chain;
1079	struct spider_net_descr *descr;
1080	int i, status;
1081
1082	/* Advance head pointer past any empty descrs */
1083	descr = chain->head;
1084	status = spider_net_get_descr_status(descr->hwdescr);
1085
1086	if (status == SPIDER_NET_DESCR_NOT_IN_USE)
1087		return;
1088
1089	spin_lock_irqsave(&chain->lock, flags);
1090
1091	descr = chain->head;
1092	status = spider_net_get_descr_status(descr->hwdescr);
1093	for (i=0; i<chain->num_desc; i++) {
1094		if (status != SPIDER_NET_DESCR_CARDOWNED) break;
1095		descr = descr->next;
1096		status = spider_net_get_descr_status(descr->hwdescr);
1097	}
1098	chain->head = descr;
1099
1100	spin_unlock_irqrestore(&chain->lock, flags);
1101}
1102
1103static int spider_net_resync_tail_ptr(struct spider_net_card *card)
1104{
1105	struct spider_net_descr_chain *chain = &card->rx_chain;
1106	struct spider_net_descr *descr;
1107	int i, status;
1108
1109	/* Advance tail pointer past any empty and reaped descrs */
1110	descr = chain->tail;
1111	status = spider_net_get_descr_status(descr->hwdescr);
1112
1113	for (i=0; i<chain->num_desc; i++) {
1114		if ((status != SPIDER_NET_DESCR_CARDOWNED) &&
1115		    (status != SPIDER_NET_DESCR_NOT_IN_USE)) break;
1116		descr = descr->next;
1117		status = spider_net_get_descr_status(descr->hwdescr);
1118	}
1119	chain->tail = descr;
1120
1121	if ((i == chain->num_desc) || (i == 0))
1122		return 1;
1123	return 0;
1124}
1125
1126/**
1127 * spider_net_decode_one_descr - processes an RX descriptor
1128 * @card: card structure
1129 *
1130 * Returns 1 if a packet has been sent to the stack, otherwise 0.
1131 *
1132 * Processes an RX descriptor by iommu-unmapping the data buffer
1133 * and passing the packet up to the stack. This function is called
1134 * in softirq context, e.g. either bottom half from interrupt or
1135 * NAPI polling context.
1136 */
1137static int
1138spider_net_decode_one_descr(struct spider_net_card *card)
1139{
1140	struct net_device *dev = card->netdev;
1141	struct spider_net_descr_chain *chain = &card->rx_chain;
1142	struct spider_net_descr *descr = chain->tail;
1143	struct spider_net_hw_descr *hwdescr = descr->hwdescr;
1144	u32 hw_buf_addr;
1145	int status;
1146
1147	status = spider_net_get_descr_status(hwdescr);
1148
1149	/* Nothing in the descriptor, or ring must be empty */
1150	if ((status == SPIDER_NET_DESCR_CARDOWNED) ||
1151	    (status == SPIDER_NET_DESCR_NOT_IN_USE))
1152		return 0;
1153
1154	/* descriptor definitively used -- move on tail */
1155	chain->tail = descr->next;
1156
1157	/* unmap descriptor */
1158	hw_buf_addr = hwdescr->buf_addr;
1159	hwdescr->buf_addr = 0xffffffff;
1160	pci_unmap_single(card->pdev, hw_buf_addr,
1161			SPIDER_NET_MAX_FRAME, PCI_DMA_FROMDEVICE);
1162
1163	if ( (status == SPIDER_NET_DESCR_RESPONSE_ERROR) ||
1164	     (status == SPIDER_NET_DESCR_PROTECTION_ERROR) ||
1165	     (status == SPIDER_NET_DESCR_FORCE_END) ) {
1166		if (netif_msg_rx_err(card))
1167			dev_err(&dev->dev,
1168			       "dropping RX descriptor with state %d\n", status);
1169		dev->stats.rx_dropped++;
1170		goto bad_desc;
1171	}
1172
1173	if ( (status != SPIDER_NET_DESCR_COMPLETE) &&
1174	     (status != SPIDER_NET_DESCR_FRAME_END) ) {
1175		if (netif_msg_rx_err(card))
1176			dev_err(&card->netdev->dev,
1177			       "RX descriptor with unknown state %d\n", status);
1178		card->spider_stats.rx_desc_unk_state++;
1179		goto bad_desc;
1180	}
1181
1182	/* The cases we'll throw away the packet immediately */
1183	if (hwdescr->data_error & SPIDER_NET_DESTROY_RX_FLAGS) {
1184		if (netif_msg_rx_err(card))
1185			dev_err(&card->netdev->dev,
1186			       "error in received descriptor found, "
1187			       "data_status=x%08x, data_error=x%08x\n",
1188			       hwdescr->data_status, hwdescr->data_error);
1189		goto bad_desc;
1190	}
1191
1192	if (hwdescr->dmac_cmd_status & SPIDER_NET_DESCR_BAD_STATUS) {
1193		dev_err(&card->netdev->dev, "bad status, cmd_status=x%08x\n",
1194			       hwdescr->dmac_cmd_status);
1195		pr_err("buf_addr=x%08x\n", hw_buf_addr);
1196		pr_err("buf_size=x%08x\n", hwdescr->buf_size);
1197		pr_err("next_descr_addr=x%08x\n", hwdescr->next_descr_addr);
1198		pr_err("result_size=x%08x\n", hwdescr->result_size);
1199		pr_err("valid_size=x%08x\n", hwdescr->valid_size);
1200		pr_err("data_status=x%08x\n", hwdescr->data_status);
1201		pr_err("data_error=x%08x\n", hwdescr->data_error);
1202		pr_err("which=%ld\n", descr - card->rx_chain.ring);
1203
1204		card->spider_stats.rx_desc_error++;
1205		goto bad_desc;
1206	}
1207
1208	/* Ok, we've got a packet in descr */
1209	spider_net_pass_skb_up(descr, card);
1210	descr->skb = NULL;
1211	hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
1212	return 1;
1213
1214bad_desc:
1215	if (netif_msg_rx_err(card))
1216		show_rx_chain(card);
1217	dev_kfree_skb_irq(descr->skb);
1218	descr->skb = NULL;
1219	hwdescr->dmac_cmd_status = SPIDER_NET_DESCR_NOT_IN_USE;
1220	return 0;
1221}
1222
1223/**
1224 * spider_net_poll - NAPI poll function called by the stack to return packets
1225 * @netdev: interface device structure
1226 * @budget: number of packets we can pass to the stack at most
1227 *
1228 * returns 0 if no more packets available to the driver/stack. Returns 1,
1229 * if the quota is exceeded, but the driver has still packets.
1230 *
1231 * spider_net_poll returns all packets from the rx descriptors to the stack
1232 * (using netif_receive_skb). If all/enough packets are up, the driver
1233 * reenables interrupts and returns 0. If not, 1 is returned.
1234 */
1235static int spider_net_poll(struct napi_struct *napi, int budget)
1236{
1237	struct spider_net_card *card = container_of(napi, struct spider_net_card, napi);
1238	int packets_done = 0;
1239
1240	while (packets_done < budget) {
1241		if (!spider_net_decode_one_descr(card))
1242			break;
1243
1244		packets_done++;
1245	}
1246
1247	if ((packets_done == 0) && (card->num_rx_ints != 0)) {
1248		if (!spider_net_resync_tail_ptr(card))
1249			packets_done = budget;
1250		spider_net_resync_head_ptr(card);
1251	}
1252	card->num_rx_ints = 0;
1253
1254	spider_net_refill_rx_chain(card);
1255	spider_net_enable_rxdmac(card);
1256
1257	spider_net_cleanup_tx_ring(&card->tx_timer);
1258
1259	/* if all packets are in the stack, enable interrupts and return 0 */
1260	/* if not, return 1 */
1261	if (packets_done < budget) {
1262		napi_complete_done(napi, packets_done);
1263		spider_net_rx_irq_on(card);
1264		card->ignore_rx_ramfull = 0;
1265	}
1266
1267	return packets_done;
1268}
1269
1270/**
1271 * spider_net_set_mac - sets the MAC of an interface
1272 * @netdev: interface device structure
1273 * @ptr: pointer to new MAC address
1274 *
1275 * Returns 0 on success, <0 on failure. Currently, we don't support this
1276 * and will always return EOPNOTSUPP.
1277 */
1278static int
1279spider_net_set_mac(struct net_device *netdev, void *p)
1280{
1281	struct spider_net_card *card = netdev_priv(netdev);
1282	u32 macl, macu, regvalue;
1283	struct sockaddr *addr = p;
1284
1285	if (!is_valid_ether_addr(addr->sa_data))
1286		return -EADDRNOTAVAIL;
1287
1288	memcpy(netdev->dev_addr, addr->sa_data, ETH_ALEN);
1289
1290	/* switch off GMACTPE and GMACRPE */
1291	regvalue = spider_net_read_reg(card, SPIDER_NET_GMACOPEMD);
1292	regvalue &= ~((1 << 5) | (1 << 6));
1293	spider_net_write_reg(card, SPIDER_NET_GMACOPEMD, regvalue);
1294
1295	/* write mac */
1296	macu = (netdev->dev_addr[0]<<24) + (netdev->dev_addr[1]<<16) +
1297		(netdev->dev_addr[2]<<8) + (netdev->dev_addr[3]);
1298	macl = (netdev->dev_addr[4]<<8) + (netdev->dev_addr[5]);
1299	spider_net_write_reg(card, SPIDER_NET_GMACUNIMACU, macu);
1300	spider_net_write_reg(card, SPIDER_NET_GMACUNIMACL, macl);
1301
1302	/* switch GMACTPE and GMACRPE back on */
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	spider_net_set_promisc(card);
1308
1309	return 0;
1310}
1311
1312/**
1313 * spider_net_link_reset
1314 * @netdev: net device structure
1315 *
1316 * This is called when the PHY_LINK signal is asserted. For the blade this is
1317 * not connected so we should never get here.
1318 *
1319 */
1320static void
1321spider_net_link_reset(struct net_device *netdev)
1322{
1323
1324	struct spider_net_card *card = netdev_priv(netdev);
1325
1326	del_timer_sync(&card->aneg_timer);
1327
1328	/* clear interrupt, block further interrupts */
1329	spider_net_write_reg(card, SPIDER_NET_GMACST,
1330			     spider_net_read_reg(card, SPIDER_NET_GMACST));
1331	spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0);
1332
1333	/* reset phy and setup aneg */
1334	card->aneg_count = 0;
1335	card->medium = BCM54XX_COPPER;
1336	spider_net_setup_aneg(card);
1337	mod_timer(&card->aneg_timer, jiffies + SPIDER_NET_ANEG_TIMER);
1338
1339}
1340
1341/**
1342 * spider_net_handle_error_irq - handles errors raised by an interrupt
1343 * @card: card structure
1344 * @status_reg: interrupt status register 0 (GHIINT0STS)
1345 *
1346 * spider_net_handle_error_irq treats or ignores all error conditions
1347 * found when an interrupt is presented
1348 */
1349static void
1350spider_net_handle_error_irq(struct spider_net_card *card, u32 status_reg,
1351			    u32 error_reg1, u32 error_reg2)
1352{
1353	u32 i;
1354	int show_error = 1;
1355
1356	/* check GHIINT0STS ************************************/
1357	if (status_reg)
1358		for (i = 0; i < 32; i++)
1359			if (status_reg & (1<<i))
1360				switch (i)
1361	{
1362	/* let error_reg1 and error_reg2 evaluation decide, what to do
1363	case SPIDER_NET_PHYINT:
1364	case SPIDER_NET_GMAC2INT:
1365	case SPIDER_NET_GMAC1INT:
1366	case SPIDER_NET_GFIFOINT:
1367	case SPIDER_NET_DMACINT:
1368	case SPIDER_NET_GSYSINT:
1369		break; */
1370
1371	case SPIDER_NET_GIPSINT:
1372		show_error = 0;
1373		break;
1374
1375	case SPIDER_NET_GPWOPCMPINT:
1376		/* PHY write operation completed */
1377		show_error = 0;
1378		break;
1379	case SPIDER_NET_GPROPCMPINT:
1380		/* PHY read operation completed */
1381		/* we don't use semaphores, as we poll for the completion
1382		 * of the read operation in spider_net_read_phy. Should take
1383		 * about 50 us */
1384		show_error = 0;
1385		break;
1386	case SPIDER_NET_GPWFFINT:
1387		/* PHY command queue full */
1388		if (netif_msg_intr(card))
1389			dev_err(&card->netdev->dev, "PHY write queue full\n");
1390		show_error = 0;
1391		break;
1392
1393	/* case SPIDER_NET_GRMDADRINT: not used. print a message */
1394	/* case SPIDER_NET_GRMARPINT: not used. print a message */
1395	/* case SPIDER_NET_GRMMPINT: not used. print a message */
1396
1397	case SPIDER_NET_GDTDEN0INT:
1398		/* someone has set TX_DMA_EN to 0 */
1399		show_error = 0;
1400		break;
1401
1402	case SPIDER_NET_GDDDEN0INT: /* fallthrough */
1403	case SPIDER_NET_GDCDEN0INT: /* fallthrough */
1404	case SPIDER_NET_GDBDEN0INT: /* fallthrough */
1405	case SPIDER_NET_GDADEN0INT:
1406		/* someone has set RX_DMA_EN to 0 */
1407		show_error = 0;
1408		break;
1409
1410	/* RX interrupts */
1411	case SPIDER_NET_GDDFDCINT:
1412	case SPIDER_NET_GDCFDCINT:
1413	case SPIDER_NET_GDBFDCINT:
1414	case SPIDER_NET_GDAFDCINT:
1415	/* case SPIDER_NET_GDNMINT: not used. print a message */
1416	/* case SPIDER_NET_GCNMINT: not used. print a message */
1417	/* case SPIDER_NET_GBNMINT: not used. print a message */
1418	/* case SPIDER_NET_GANMINT: not used. print a message */
1419	/* case SPIDER_NET_GRFNMINT: not used. print a message */
1420		show_error = 0;
1421		break;
1422
1423	/* TX interrupts */
1424	case SPIDER_NET_GDTFDCINT:
1425		show_error = 0;
1426		break;
1427	case SPIDER_NET_GTTEDINT:
1428		show_error = 0;
1429		break;
1430	case SPIDER_NET_GDTDCEINT:
1431		/* chain end. If a descriptor should be sent, kick off
1432		 * tx dma
1433		if (card->tx_chain.tail != card->tx_chain.head)
1434			spider_net_kick_tx_dma(card);
1435		*/
1436		show_error = 0;
1437		break;
1438
1439	/* case SPIDER_NET_G1TMCNTINT: not used. print a message */
1440	/* case SPIDER_NET_GFREECNTINT: not used. print a message */
1441	}
1442
1443	/* check GHIINT1STS ************************************/
1444	if (error_reg1)
1445		for (i = 0; i < 32; i++)
1446			if (error_reg1 & (1<<i))
1447				switch (i)
1448	{
1449	case SPIDER_NET_GTMFLLINT:
1450		/* TX RAM full may happen on a usual case.
1451		 * Logging is not needed. */
1452		show_error = 0;
1453		break;
1454	case SPIDER_NET_GRFDFLLINT: /* fallthrough */
1455	case SPIDER_NET_GRFCFLLINT: /* fallthrough */
1456	case SPIDER_NET_GRFBFLLINT: /* fallthrough */
1457	case SPIDER_NET_GRFAFLLINT: /* fallthrough */
1458	case SPIDER_NET_GRMFLLINT:
1459		/* Could happen when rx chain is full */
1460		if (card->ignore_rx_ramfull == 0) {
1461			card->ignore_rx_ramfull = 1;
1462			spider_net_resync_head_ptr(card);
1463			spider_net_refill_rx_chain(card);
1464			spider_net_enable_rxdmac(card);
1465			card->num_rx_ints ++;
1466			napi_schedule(&card->napi);
1467		}
1468		show_error = 0;
1469		break;
1470
1471	/* case SPIDER_NET_GTMSHTINT: problem, print a message */
1472	case SPIDER_NET_GDTINVDINT:
1473		/* allrighty. tx from previous descr ok */
1474		show_error = 0;
1475		break;
1476
1477	/* chain end */
1478	case SPIDER_NET_GDDDCEINT: /* fallthrough */
1479	case SPIDER_NET_GDCDCEINT: /* fallthrough */
1480	case SPIDER_NET_GDBDCEINT: /* fallthrough */
1481	case SPIDER_NET_GDADCEINT:
1482		spider_net_resync_head_ptr(card);
1483		spider_net_refill_rx_chain(card);
1484		spider_net_enable_rxdmac(card);
1485		card->num_rx_ints ++;
1486		napi_schedule(&card->napi);
1487		show_error = 0;
1488		break;
1489
1490	/* invalid descriptor */
1491	case SPIDER_NET_GDDINVDINT: /* fallthrough */
1492	case SPIDER_NET_GDCINVDINT: /* fallthrough */
1493	case SPIDER_NET_GDBINVDINT: /* fallthrough */
1494	case SPIDER_NET_GDAINVDINT:
1495		/* Could happen when rx chain is full */
1496		spider_net_resync_head_ptr(card);
1497		spider_net_refill_rx_chain(card);
1498		spider_net_enable_rxdmac(card);
1499		card->num_rx_ints ++;
1500		napi_schedule(&card->napi);
1501		show_error = 0;
1502		break;
1503
1504	/* case SPIDER_NET_GDTRSERINT: problem, print a message */
1505	/* case SPIDER_NET_GDDRSERINT: problem, print a message */
1506	/* case SPIDER_NET_GDCRSERINT: problem, print a message */
1507	/* case SPIDER_NET_GDBRSERINT: problem, print a message */
1508	/* case SPIDER_NET_GDARSERINT: problem, print a message */
1509	/* case SPIDER_NET_GDSERINT: problem, print a message */
1510	/* case SPIDER_NET_GDTPTERINT: problem, print a message */
1511	/* case SPIDER_NET_GDDPTERINT: problem, print a message */
1512	/* case SPIDER_NET_GDCPTERINT: problem, print a message */
1513	/* case SPIDER_NET_GDBPTERINT: problem, print a message */
1514	/* case SPIDER_NET_GDAPTERINT: problem, print a message */
1515	default:
1516		show_error = 1;
1517		break;
1518	}
1519
1520	/* check GHIINT2STS ************************************/
1521	if (error_reg2)
1522		for (i = 0; i < 32; i++)
1523			if (error_reg2 & (1<<i))
1524				switch (i)
1525	{
1526	/* there is nothing we can (want  to) do at this time. Log a
1527	 * message, we can switch on and off the specific values later on
1528	case SPIDER_NET_GPROPERINT:
1529	case SPIDER_NET_GMCTCRSNGINT:
1530	case SPIDER_NET_GMCTLCOLINT:
1531	case SPIDER_NET_GMCTTMOTINT:
1532	case SPIDER_NET_GMCRCAERINT:
1533	case SPIDER_NET_GMCRCALERINT:
1534	case SPIDER_NET_GMCRALNERINT:
1535	case SPIDER_NET_GMCROVRINT:
1536	case SPIDER_NET_GMCRRNTINT:
1537	case SPIDER_NET_GMCRRXERINT:
1538	case SPIDER_NET_GTITCSERINT:
1539	case SPIDER_NET_GTIFMTERINT:
1540	case SPIDER_NET_GTIPKTRVKINT:
1541	case SPIDER_NET_GTISPINGINT:
1542	case SPIDER_NET_GTISADNGINT:
1543	case SPIDER_NET_GTISPDNGINT:
1544	case SPIDER_NET_GRIFMTERINT:
1545	case SPIDER_NET_GRIPKTRVKINT:
1546	case SPIDER_NET_GRISPINGINT:
1547	case SPIDER_NET_GRISADNGINT:
1548	case SPIDER_NET_GRISPDNGINT:
1549		break;
1550	*/
1551		default:
1552			break;
1553	}
1554
1555	if ((show_error) && (netif_msg_intr(card)) && net_ratelimit())
1556		dev_err(&card->netdev->dev, "Error interrupt, GHIINT0STS = 0x%08x, "
1557		       "GHIINT1STS = 0x%08x, GHIINT2STS = 0x%08x\n",
1558		       status_reg, error_reg1, error_reg2);
1559
1560	/* clear interrupt sources */
1561	spider_net_write_reg(card, SPIDER_NET_GHIINT1STS, error_reg1);
1562	spider_net_write_reg(card, SPIDER_NET_GHIINT2STS, error_reg2);
1563}
1564
1565/**
1566 * spider_net_interrupt - interrupt handler for spider_net
1567 * @irq: interrupt number
1568 * @ptr: pointer to net_device
1569 *
1570 * returns IRQ_HANDLED, if interrupt was for driver, or IRQ_NONE, if no
1571 * interrupt found raised by card.
1572 *
1573 * This is the interrupt handler, that turns off
1574 * interrupts for this device and makes the stack poll the driver
1575 */
1576static irqreturn_t
1577spider_net_interrupt(int irq, void *ptr)
1578{
1579	struct net_device *netdev = ptr;
1580	struct spider_net_card *card = netdev_priv(netdev);
1581	u32 status_reg, error_reg1, error_reg2;
1582
1583	status_reg = spider_net_read_reg(card, SPIDER_NET_GHIINT0STS);
1584	error_reg1 = spider_net_read_reg(card, SPIDER_NET_GHIINT1STS);
1585	error_reg2 = spider_net_read_reg(card, SPIDER_NET_GHIINT2STS);
1586
1587	if (!(status_reg & SPIDER_NET_INT0_MASK_VALUE) &&
1588	    !(error_reg1 & SPIDER_NET_INT1_MASK_VALUE) &&
1589	    !(error_reg2 & SPIDER_NET_INT2_MASK_VALUE))
1590		return IRQ_NONE;
1591
1592	if (status_reg & SPIDER_NET_RXINT ) {
1593		spider_net_rx_irq_off(card);
1594		napi_schedule(&card->napi);
1595		card->num_rx_ints ++;
1596	}
1597	if (status_reg & SPIDER_NET_TXINT)
1598		napi_schedule(&card->napi);
1599
1600	if (status_reg & SPIDER_NET_LINKINT)
1601		spider_net_link_reset(netdev);
1602
1603	if (status_reg & SPIDER_NET_ERRINT )
1604		spider_net_handle_error_irq(card, status_reg,
1605					    error_reg1, error_reg2);
1606
1607	/* clear interrupt sources */
1608	spider_net_write_reg(card, SPIDER_NET_GHIINT0STS, status_reg);
1609
1610	return IRQ_HANDLED;
1611}
1612
1613#ifdef CONFIG_NET_POLL_CONTROLLER
1614/**
1615 * spider_net_poll_controller - artificial interrupt for netconsole etc.
1616 * @netdev: interface device structure
1617 *
1618 * see Documentation/networking/netconsole.txt
1619 */
1620static void
1621spider_net_poll_controller(struct net_device *netdev)
1622{
1623	disable_irq(netdev->irq);
1624	spider_net_interrupt(netdev->irq, netdev);
1625	enable_irq(netdev->irq);
1626}
1627#endif /* CONFIG_NET_POLL_CONTROLLER */
1628
1629/**
1630 * spider_net_enable_interrupts - enable interrupts
1631 * @card: card structure
1632 *
1633 * spider_net_enable_interrupt enables several interrupts
1634 */
1635static void
1636spider_net_enable_interrupts(struct spider_net_card *card)
1637{
1638	spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK,
1639			     SPIDER_NET_INT0_MASK_VALUE);
1640	spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK,
1641			     SPIDER_NET_INT1_MASK_VALUE);
1642	spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK,
1643			     SPIDER_NET_INT2_MASK_VALUE);
1644}
1645
1646/**
1647 * spider_net_disable_interrupts - disable interrupts
1648 * @card: card structure
1649 *
1650 * spider_net_disable_interrupts disables all the interrupts
1651 */
1652static void
1653spider_net_disable_interrupts(struct spider_net_card *card)
1654{
1655	spider_net_write_reg(card, SPIDER_NET_GHIINT0MSK, 0);
1656	spider_net_write_reg(card, SPIDER_NET_GHIINT1MSK, 0);
1657	spider_net_write_reg(card, SPIDER_NET_GHIINT2MSK, 0);
1658	spider_net_write_reg(card, SPIDER_NET_GMACINTEN, 0);
1659}
1660
1661/**
1662 * spider_net_init_card - initializes the card
1663 * @card: card structure
1664 *
1665 * spider_net_init_card initializes the card so that other registers can
1666 * be used
1667 */
1668static void
1669spider_net_init_card(struct spider_net_card *card)
1670{
1671	spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
1672			     SPIDER_NET_CKRCTRL_STOP_VALUE);
1673
1674	spider_net_write_reg(card, SPIDER_NET_CKRCTRL,
1675			     SPIDER_NET_CKRCTRL_RUN_VALUE);
1676
1677	/* trigger ETOMOD signal */
1678	spider_net_write_reg(card, SPIDER_NET_GMACOPEMD,
1679		spider_net_read_reg(card, SPIDER_NET_GMACOPEMD) | 0x4);
1680
1681	spider_net_disable_interrupts(card);
1682}
1683
1684/**
1685 * spider_net_enable_card - enables the card by setting all kinds of regs
1686 * @card: card structure
1687 *
1688 * spider_net_enable_card sets a lot of SMMIO registers to enable the device
1689 */
1690static void
1691spider_net_enable_card(struct spider_net_card *card)
1692{
1693	int i;
1694	/* the following array consists of (register),(value) pairs
1695	 * that are set in this function. A register of 0 ends the list */
1696	u32 regs[][2] = {
1697		{ SPIDER_NET_GRESUMINTNUM, 0 },
1698		{ SPIDER_NET_GREINTNUM, 0 },
1699
1700		/* set interrupt frame number registers */
1701		/* clear the single DMA engine registers first */
1702		{ SPIDER_NET_GFAFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1703		{ SPIDER_NET_GFBFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1704		{ SPIDER_NET_GFCFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1705		{ SPIDER_NET_GFDFRMNUM, SPIDER_NET_GFXFRAMES_VALUE },
1706		/* then set, what we really need */
1707		{ SPIDER_NET_GFFRMNUM, SPIDER_NET_FRAMENUM_VALUE },
1708
1709		/* timer counter registers and stuff */
1710		{ SPIDER_NET_GFREECNNUM, 0 },
1711		{ SPIDER_NET_GONETIMENUM, 0 },
1712		{ SPIDER_NET_GTOUTFRMNUM, 0 },
1713
1714		/* RX mode setting */
1715		{ SPIDER_NET_GRXMDSET, SPIDER_NET_RXMODE_VALUE },
1716		/* TX mode setting */
1717		{ SPIDER_NET_GTXMDSET, SPIDER_NET_TXMODE_VALUE },
1718		/* IPSEC mode setting */
1719		{ SPIDER_NET_GIPSECINIT, SPIDER_NET_IPSECINIT_VALUE },
1720
1721		{ SPIDER_NET_GFTRESTRT, SPIDER_NET_RESTART_VALUE },
1722
1723		{ SPIDER_NET_GMRWOLCTRL, 0 },
1724		{ SPIDER_NET_GTESTMD, 0x10000000 },
1725		{ SPIDER_NET_GTTQMSK, 0x00400040 },
1726
1727		{ SPIDER_NET_GMACINTEN, 0 },
1728
1729		/* flow control stuff */
1730		{ SPIDER_NET_GMACAPAUSE, SPIDER_NET_MACAPAUSE_VALUE },
1731		{ SPIDER_NET_GMACTXPAUSE, SPIDER_NET_TXPAUSE_VALUE },
1732
1733		{ SPIDER_NET_GMACBSTLMT, SPIDER_NET_BURSTLMT_VALUE },
1734		{ 0, 0}
1735	};
1736
1737	i = 0;
1738	while (regs[i][0]) {
1739		spider_net_write_reg(card, regs[i][0], regs[i][1]);
1740		i++;
1741	}
1742
1743	/* clear unicast filter table entries 1 to 14 */
1744	for (i = 1; i <= 14; i++) {
1745		spider_net_write_reg(card,
1746				     SPIDER_NET_GMRUAFILnR + i * 8,
1747				     0x00080000);
1748		spider_net_write_reg(card,
1749				     SPIDER_NET_GMRUAFILnR + i * 8 + 4,
1750				     0x00000000);
1751	}
1752
1753	spider_net_write_reg(card, SPIDER_NET_GMRUA0FIL15R, 0x08080000);
1754
1755	spider_net_write_reg(card, SPIDER_NET_ECMODE, SPIDER_NET_ECMODE_VALUE);
1756
1757	/* set chain tail address fo…

Large files files are truncated, but you can click here to view the full file