drivers/net/sungem.c

   1 /* $Id: sungem.c,v 1.1.1.1 2005/04/11 02:50:29 jack Exp $
   2  * sungem.c: Sun GEM ethernet driver.
   3  *
   4  * Copyright (C) 2000, 2001, 2002 David S. Miller (davem@redhat.com)
   5  *
   6  * Support for Apple GMAC and assorted PHYs by
   7  * Benjamin Herrenscmidt (benh@kernel.crashing.org)
   8  *
   9  * TODO:
  10  *  - Get rid of all those nasty mdelay's and replace them
  11  * with schedule_timeout.
  12  *  - Implement WOL
  13  */
  14
  15 #include <linux/config.h>
  16
  17 #include <linux/module.h>
  18
  19 #include <linux/kernel.h>
  20 #include <linux/sched.h>
  21 #include <linux/types.h>
  22 #include <linux/fcntl.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/ptrace.h>
  25 #include <linux/ioport.h>
  26 #include <linux/in.h>
  27 #include <linux/slab.h>
  28 #include <linux/string.h>
  29 #include <linux/delay.h>
  30 #include <linux/init.h>
  31 #include <linux/errno.h>
  32 #include <linux/pci.h>
  33 #include <linux/netdevice.h>
  34 #include <linux/etherdevice.h>
  35 #include <linux/skbuff.h>
  36 #include <linux/mii.h>
  37 #include <linux/ethtool.h>
  38 #include <linux/crc32.h>
  39 #include <linux/random.h>
  40
  41 #include <asm/system.h>
  42 #include <asm/bitops.h>
  43 #include <asm/io.h>
  44 #include <asm/byteorder.h>
  45 #include <asm/uaccess.h>
  46 #include <asm/irq.h>
  47
  48 #ifdef __sparc__
  49 #include <asm/idprom.h>
  50 #include <asm/openprom.h>
  51 #include <asm/oplib.h>
  52 #include <asm/pbm.h>
  53 #endif
  54
  55 #ifdef CONFIG_ALL_PPC
  56 #include <asm/pci-bridge.h>
  57 #include <asm/prom.h>
  58 #include <asm/machdep.h>
  59 #include <asm/pmac_feature.h>
  60 #endif
  61
  62 #include "sungem_phy.h"
  63 #include "sungem.h"
  64
  65 #define DEFAULT_MSG     (NETIF_MSG_DRV          | \
  66                          NETIF_MSG_PROBE        | \
  67                          NETIF_MSG_LINK)
  68
  69 #define DRV_NAME        "sungem"
  70 #define DRV_VERSION     "0.97"
  71 #define DRV_RELDATE     "3/20/02"
  72 #define DRV_AUTHOR      "David S. Miller (davem@redhat.com)"
  73
  74 static char version[] __devinitdata =
  75         DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " " DRV_AUTHOR "\n";
  76
  77 MODULE_AUTHOR(DRV_AUTHOR);
  78 MODULE_DESCRIPTION("Sun GEM Gbit ethernet driver");
  79 MODULE_LICENSE("GPL");
  80
  81 MODULE_PARM(gem_debug, "i");
  82 MODULE_PARM_DESC(gem_debug, "bitmapped message enable number");
  83 MODULE_PARM(link_mode, "i");
  84 MODULE_PARM_DESC(forced_speed, "force link speed (10,100,1000)");
  85 MODULE_PARM_DESC(forced_duplex, "force link duplex (0: half, 1: full)");
  86
  87 int gem_debug = -1;
  88 static int forced_speed = -1;
  89 static int forced_duplex = -1;
  90
  91 #define GEM_MODULE_NAME "gem"
  92 #define PFX GEM_MODULE_NAME ": "
  93
  94 static struct pci_device_id gem_pci_tbl[] __devinitdata = {
  95         { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_GEM,
  96           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
  97
  98         /* These models only differ from the original GEM in
  99          * that their tx/rx fifos are of a different size and
 100          * they only support 10/100 speeds. -DaveM
 101          *
 102          * Apple's GMAC does support gigabit on machines with
 103          * the BCM54xx PHYs. -BenH
 104          */
 105         { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_RIO_GEM,
 106           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 107         { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC,
 108           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 109         { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMACP,
 110           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 111         { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC2,
 112           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 113         {0, }
 114 };
 115
 116 MODULE_DEVICE_TABLE(pci, gem_pci_tbl);
 117
 118 static u16 __phy_read(struct gem *gp, int phy_addr, int reg)
 119 {
 120         u32 cmd;
 121         int limit = 10000;
 122
 123         cmd  = (1 << 30);
 124         cmd |= (2 << 28);
 125         cmd |= (phy_addr << 23) & MIF_FRAME_PHYAD;
 126         cmd |= (reg << 18) & MIF_FRAME_REGAD;
 127         cmd |= (MIF_FRAME_TAMSB);
 128         writel(cmd, gp->regs + MIF_FRAME);
 129
 130         while (limit--) {
 131                 cmd = readl(gp->regs + MIF_FRAME);
 132                 if (cmd & MIF_FRAME_TALSB)
 133                         break;
 134
 135                 udelay(10);
 136         }
 137
 138         if (!limit)
 139                 cmd = 0xffff;
 140
 141         return cmd & MIF_FRAME_DATA;
 142 }
 143
 144 static inline int _phy_read(struct net_device *dev, int mii_id, int reg)
 145 {
 146         struct gem *gp = dev->priv;
 147         return __phy_read(gp, mii_id, reg);
 148 }
 149
 150 static inline u16 phy_read(struct gem *gp, int reg)
 151 {
 152         return __phy_read(gp, gp->mii_phy_addr, reg);
 153 }
 154
 155 static void __phy_write(struct gem *gp, int phy_addr, int reg, u16 val)
 156 {
 157         u32 cmd;
 158         int limit = 10000;
 159
 160         cmd  = (1 << 30);
 161         cmd |= (1 << 28);
 162         cmd |= (phy_addr << 23) & MIF_FRAME_PHYAD;
 163         cmd |= (reg << 18) & MIF_FRAME_REGAD;
 164         cmd |= (MIF_FRAME_TAMSB);
 165         cmd |= (val & MIF_FRAME_DATA);
 166         writel(cmd, gp->regs + MIF_FRAME);
 167
 168         while (limit--) {
 169                 cmd = readl(gp->regs + MIF_FRAME);
 170                 if (cmd & MIF_FRAME_TALSB)
 171                         break;
 172
 173                 udelay(10);
 174         }
 175 }
 176
 177 static inline void _phy_write(struct net_device *dev, int mii_id, int reg, int val)
 178 {
 179         struct gem *gp = dev->priv;
 180         __phy_write(gp, mii_id, reg, val & 0xffff);
 181 }
 182
 183 static inline void phy_write(struct gem *gp, int reg, u16 val)
 184 {
 185         __phy_write(gp, gp->mii_phy_addr, reg, val);
 186 }
 187
 188 static void gem_handle_mif_event(struct gem *gp, u32 reg_val, u32 changed_bits)
 189 {
 190         if (netif_msg_intr(gp))
 191                 printk(KERN_DEBUG "%s: mif interrupt\n", gp->dev->name);
 192 }
 193
 194 static int gem_pcs_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 195 {
 196         u32 pcs_istat = readl(gp->regs + PCS_ISTAT);
 197         u32 pcs_miistat;
 198
 199         if (netif_msg_intr(gp))
 200                 printk(KERN_DEBUG "%s: pcs interrupt, pcs_istat: 0x%x\n",
 201                         gp->dev->name, pcs_istat);
 202
 203         if (!(pcs_istat & PCS_ISTAT_LSC)) {
 204                 printk(KERN_ERR "%s: PCS irq but no link status change???\n",
 205                        dev->name);
 206                 return 0;
 207         }
 208
 209         /* The link status bit latches on zero, so you must
 210          * read it twice in such a case to see a transition
 211          * to the link being up.
 212          */
 213         pcs_miistat = readl(gp->regs + PCS_MIISTAT);
 214         if (!(pcs_miistat & PCS_MIISTAT_LS))
 215                 pcs_miistat |=
 216                         (readl(gp->regs + PCS_MIISTAT) &
 217                          PCS_MIISTAT_LS);
 218
 219         if (pcs_miistat & PCS_MIISTAT_ANC) {
 220                 /* The remote-fault indication is only valid
 221                  * when autoneg has completed.
 222                  */
 223                 if (pcs_miistat & PCS_MIISTAT_RF)
 224                         printk(KERN_INFO "%s: PCS AutoNEG complete, "
 225                                "RemoteFault\n", dev->name);
 226                 else
 227                         printk(KERN_INFO "%s: PCS AutoNEG complete.\n",
 228                                dev->name);
 229         }
 230
 231         if (pcs_miistat & PCS_MIISTAT_LS) {
 232                 printk(KERN_INFO "%s: PCS link is now up.\n",
 233                        dev->name);
 234                 netif_carrier_on(gp->dev);
 235         } else {
 236                 printk(KERN_INFO "%s: PCS link is now down.\n",
 237                        dev->name);
 238                 netif_carrier_off(gp->dev);
 239                 /* If this happens and the link timer is not running,
 240                  * reset so we re-negotiate.
 241                  */
 242                 if (!timer_pending(&gp->link_timer))
 243                         return 1;
 244         }
 245
 246         return 0;
 247 }
 248
 249 static int gem_txmac_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 250 {
 251         u32 txmac_stat = readl(gp->regs + MAC_TXSTAT);
 252
 253         if (netif_msg_intr(gp))
 254                 printk(KERN_DEBUG "%s: txmac interrupt, txmac_stat: 0x%x\n",
 255                         gp->dev->name, txmac_stat);
 256
 257         /* Defer timer expiration is quite normal,
 258          * don't even log the event.
 259          */
 260         if ((txmac_stat & MAC_TXSTAT_DTE) &&
 261             !(txmac_stat & ~MAC_TXSTAT_DTE))
 262                 return 0;
 263
 264         if (txmac_stat & MAC_TXSTAT_URUN) {
 265                 printk(KERN_ERR "%s: TX MAC xmit underrun.\n",
 266                        dev->name);
 267                 gp->net_stats.tx_fifo_errors++;
 268         }
 269
 270         if (txmac_stat & MAC_TXSTAT_MPE) {
 271                 printk(KERN_ERR "%s: TX MAC max packet size error.\n",
 272                        dev->name);
 273                 gp->net_stats.tx_errors++;
 274         }
 275
 276         /* The rest are all cases of one of the 16-bit TX
 277          * counters expiring.
 278          */
 279         if (txmac_stat & MAC_TXSTAT_NCE)
 280                 gp->net_stats.collisions += 0x10000;
 281
 282         if (txmac_stat & MAC_TXSTAT_ECE) {
 283                 gp->net_stats.tx_aborted_errors += 0x10000;
 284                 gp->net_stats.collisions += 0x10000;
 285         }
 286
 287         if (txmac_stat & MAC_TXSTAT_LCE) {
 288                 gp->net_stats.tx_aborted_errors += 0x10000;
 289                 gp->net_stats.collisions += 0x10000;
 290         }
 291
 292         /* We do not keep track of MAC_TXSTAT_FCE and
 293          * MAC_TXSTAT_PCE events.
 294          */
 295         return 0;
 296 }
 297
 298 /* When we get a RX fifo overflow, the RX unit in GEM is probably hung
 299  * so we do the following.
 300  *
 301  * If any part of the reset goes wrong, we return 1 and that causes the
 302  * whole chip to be reset.
 303  */
 304 static int gem_rxmac_reset(struct gem *gp)
 305 {
 306         struct net_device *dev = gp->dev;
 307         int limit, i;
 308         u64 desc_dma;
 309         u32 val;
 310
 311         /* First, reset MAC RX. */
 312         writel(gp->mac_rx_cfg & ~MAC_RXCFG_ENAB,
 313                gp->regs + MAC_RXCFG);
 314         for (limit = 0; limit < 5000; limit++) {
 315                 if (!(readl(gp->regs + MAC_RXCFG) & MAC_RXCFG_ENAB))
 316                         break;
 317                 udelay(10);
 318         }
 319         if (limit == 5000) {
 320                 printk(KERN_ERR "%s: RX MAC will not disable, resetting whole "
 321                        "chip.\n", dev->name);
 322                 return 1;
 323         }
 324
 325         /* Second, disable RX DMA. */
 326         writel(0, gp->regs + RXDMA_CFG);
 327         for (limit = 0; limit < 5000; limit++) {
 328                 if (!(readl(gp->regs + RXDMA_CFG) & RXDMA_CFG_ENABLE))
 329                         break;
 330                 udelay(10);
 331         }
 332         if (limit == 5000) {
 333                 printk(KERN_ERR "%s: RX DMA will not disable, resetting whole "
 334                        "chip.\n", dev->name);
 335                 return 1;
 336         }
 337
 338         udelay(5000);
 339
 340         /* Execute RX reset command. */
 341         writel(gp->swrst_base | GREG_SWRST_RXRST,
 342                gp->regs + GREG_SWRST);
 343         for (limit = 0; limit < 5000; limit++) {
 344                 if (!(readl(gp->regs + GREG_SWRST) & GREG_SWRST_RXRST))
 345                         break;
 346                 udelay(10);
 347         }
 348         if (limit == 5000) {
 349                 printk(KERN_ERR "%s: RX reset command will not execute, resetting "
 350                        "whole chip.\n", dev->name);
 351                 return 1;
 352         }
 353
 354         /* Refresh the RX ring. */
 355         for (i = 0; i < RX_RING_SIZE; i++) {
 356                 struct gem_rxd *rxd = &gp->init_block->rxd[i];
 357
 358                 if (gp->rx_skbs[i] == NULL) {
 359                         printk(KERN_ERR "%s: Parts of RX ring empty, resetting "
 360                                "whole chip.\n", dev->name);
 361                         return 1;
 362                 }
 363
 364                 rxd->status_word = cpu_to_le64(RXDCTRL_FRESH(gp));
 365         }
 366         gp->rx_new = gp->rx_old = 0;
 367
 368         /* Now we must reprogram the rest of RX unit. */
 369         desc_dma = (u64) gp->gblock_dvma;
 370         desc_dma += (INIT_BLOCK_TX_RING_SIZE * sizeof(struct gem_txd));
 371         writel(desc_dma >> 32, gp->regs + RXDMA_DBHI);
 372         writel(desc_dma & 0xffffffff, gp->regs + RXDMA_DBLOW);
 373         writel(RX_RING_SIZE - 4, gp->regs + RXDMA_KICK);
 374         val = (RXDMA_CFG_BASE | (RX_OFFSET << 10) |
 375                ((14 / 2) << 13) | RXDMA_CFG_FTHRESH_128);
 376         writel(val, gp->regs + RXDMA_CFG);
 377         if (readl(gp->regs + GREG_BIFCFG) & GREG_BIFCFG_M66EN)
 378                 writel(((5 & RXDMA_BLANK_IPKTS) |
 379                         ((8 << 12) & RXDMA_BLANK_ITIME)),
 380                        gp->regs + RXDMA_BLANK);
 381         else
 382                 writel(((5 & RXDMA_BLANK_IPKTS) |
 383                         ((4 << 12) & RXDMA_BLANK_ITIME)),
 384                        gp->regs + RXDMA_BLANK);
 385         val  = (((gp->rx_pause_off / 64) << 0) & RXDMA_PTHRESH_OFF);
 386         val |= (((gp->rx_pause_on / 64) << 12) & RXDMA_PTHRESH_ON);
 387         writel(val, gp->regs + RXDMA_PTHRESH);
 388         val = readl(gp->regs + RXDMA_CFG);
 389         writel(val | RXDMA_CFG_ENABLE, gp->regs + RXDMA_CFG);
 390         writel(MAC_RXSTAT_RCV, gp->regs + MAC_RXMASK);
 391         val = readl(gp->regs + MAC_RXCFG);
 392         writel(val | MAC_RXCFG_ENAB, gp->regs + MAC_RXCFG);
 393
 394         return 0;
 395 }
 396
 397 static int gem_rxmac_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 398 {
 399         u32 rxmac_stat = readl(gp->regs + MAC_RXSTAT);
 400         int ret = 0;
 401
 402         if (netif_msg_intr(gp))
 403                 printk(KERN_DEBUG "%s: rxmac interrupt, rxmac_stat: 0x%x\n",
 404                         gp->dev->name, rxmac_stat);
 405
 406         if (rxmac_stat & MAC_RXSTAT_OFLW) {
 407                 gp->net_stats.rx_over_errors++;
 408                 gp->net_stats.rx_fifo_errors++;
 409
 410                 ret = gem_rxmac_reset(gp);
 411         }
 412
 413         if (rxmac_stat & MAC_RXSTAT_ACE)
 414                 gp->net_stats.rx_frame_errors += 0x10000;
 415
 416         if (rxmac_stat & MAC_RXSTAT_CCE)
 417                 gp->net_stats.rx_crc_errors += 0x10000;
 418
 419         if (rxmac_stat & MAC_RXSTAT_LCE)
 420                 gp->net_stats.rx_length_errors += 0x10000;
 421
 422         /* We do not track MAC_RXSTAT_FCE and MAC_RXSTAT_VCE
 423          * events.
 424          */
 425         return ret;
 426 }
 427
 428 static int gem_mac_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 429 {
 430         u32 mac_cstat = readl(gp->regs + MAC_CSTAT);
 431
 432         if (netif_msg_intr(gp))
 433                 printk(KERN_DEBUG "%s: mac interrupt, mac_cstat: 0x%x\n",
 434                         gp->dev->name, mac_cstat);
 435
 436         /* This interrupt is just for pause frame and pause
 437          * tracking.  It is useful for diagnostics and debug
 438          * but probably by default we will mask these events.
 439          */
 440         if (mac_cstat & MAC_CSTAT_PS)
 441                 gp->pause_entered++;
 442
 443         if (mac_cstat & MAC_CSTAT_PRCV)
 444                 gp->pause_last_time_recvd = (mac_cstat >> 16);
 445
 446         return 0;
 447 }
 448
 449 static int gem_mif_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 450 {
 451         u32 mif_status = readl(gp->regs + MIF_STATUS);
 452         u32 reg_val, changed_bits;
 453
 454         reg_val = (mif_status & MIF_STATUS_DATA) >> 16;
 455         changed_bits = (mif_status & MIF_STATUS_STAT);
 456
 457         gem_handle_mif_event(gp, reg_val, changed_bits);
 458
 459         return 0;
 460 }
 461
 462 static int gem_pci_interrupt(struct net_device *dev, struct gem *gp, u32 gem_status)
 463 {
 464         u32 pci_estat = readl(gp->regs + GREG_PCIESTAT);
 465
 466         if (gp->pdev->vendor == PCI_VENDOR_ID_SUN &&
 467             gp->pdev->device == PCI_DEVICE_ID_SUN_GEM) {
 468                 printk(KERN_ERR "%s: PCI error [%04x] ",
 469                        dev->name, pci_estat);
 470
 471                 if (pci_estat & GREG_PCIESTAT_BADACK)
 472                         printk("<No ACK64# during ABS64 cycle> ");
 473                 if (pci_estat & GREG_PCIESTAT_DTRTO)
 474                         printk("<Delayed transaction timeout> ");
 475                 if (pci_estat & GREG_PCIESTAT_OTHER)
 476                         printk("<other>");
 477                 printk("\n");
 478         } else {
 479                 pci_estat |= GREG_PCIESTAT_OTHER;
 480                 printk(KERN_ERR "%s: PCI error\n", dev->name);
 481         }
 482
 483         if (pci_estat & GREG_PCIESTAT_OTHER) {
 484                 u16 pci_cfg_stat;
 485
 486                 /* Interrogate PCI config space for the
 487                  * true cause.
 488                  */
 489                 pci_read_config_word(gp->pdev, PCI_STATUS,
 490                                      &pci_cfg_stat);
 491                 printk(KERN_ERR "%s: Read PCI cfg space status [%04x]\n",
 492                        dev->name, pci_cfg_stat);
 493                 if (pci_cfg_stat & PCI_STATUS_PARITY)
 494                         printk(KERN_ERR "%s: PCI parity error detected.\n",
 495                                dev->name);
 496                 if (pci_cfg_stat & PCI_STATUS_SIG_TARGET_ABORT)
 497                         printk(KERN_ERR "%s: PCI target abort.\n",
 498                                dev->name);
 499                 if (pci_cfg_stat & PCI_STATUS_REC_TARGET_ABORT)
 500                         printk(KERN_ERR "%s: PCI master acks target abort.\n",
 501                                dev->name);
 502                 if (pci_cfg_stat & PCI_STATUS_REC_MASTER_ABORT)
 503                         printk(KERN_ERR "%s: PCI master abort.\n",
 504                                dev->name);
 505                 if (pci_cfg_stat & PCI_STATUS_SIG_SYSTEM_ERROR)
 506                         printk(KERN_ERR "%s: PCI system error SERR#.\n",
 507                                dev->name);
 508                 if (pci_cfg_stat & PCI_STATUS_DETECTED_PARITY)
 509                         printk(KERN_ERR "%s: PCI parity error.\n",
 510                                dev->name);
 511
 512                 /* Write the error bits back to clear them. */
 513                 pci_cfg_stat &= (PCI_STATUS_PARITY |
 514                                  PCI_STATUS_SIG_TARGET_ABORT |
 515                                  PCI_STATUS_REC_TARGET_ABORT |
 516                                  PCI_STATUS_REC_MASTER_ABORT |
 517                                  PCI_STATUS_SIG_SYSTEM_ERROR |
 518                                  PCI_STATUS_DETECTED_PARITY);
 519                 pci_write_config_word(gp->pdev,
 520                                       PCI_STATUS, pci_cfg_stat);
 521         }
 522
 523         /* For all PCI errors, we should reset the chip. */
 524         return 1;
 525 }
 526
 527 /* All non-normal interrupt conditions get serviced here.
 528  * Returns non-zero if we should just exit the interrupt
 529  * handler right now (ie. if we reset the card which invalidates
 530  * all of the other original irq status bits).
 531  */
 532 static int gem_abnormal_irq(struct net_device *dev, struct gem *gp, u32 gem_status)
 533 {
 534         if (gem_status & GREG_STAT_RXNOBUF) {
 535                 /* Frame arrived, no free RX buffers available. */
 536                 if (netif_msg_rx_err(gp))
 537                         printk(KERN_DEBUG "%s: no buffer for rx frame\n",
 538                                 gp->dev->name);
 539                 gp->net_stats.rx_dropped++;
 540         }
 541
 542         if (gem_status & GREG_STAT_RXTAGERR) {
 543                 /* corrupt RX tag framing */
 544                 if (netif_msg_rx_err(gp))
 545                         printk(KERN_DEBUG "%s: corrupt rx tag framing\n",
 546                                 gp->dev->name);
 547                 gp->net_stats.rx_errors++;
 548
 549                 goto do_reset;
 550         }
 551
 552         if (gem_status & GREG_STAT_PCS) {
 553                 if (gem_pcs_interrupt(dev, gp, gem_status))
 554                         goto do_reset;
 555         }
 556
 557         if (gem_status & GREG_STAT_TXMAC) {
 558                 if (gem_txmac_interrupt(dev, gp, gem_status))
 559                         goto do_reset;
 560         }
 561
 562         if (gem_status & GREG_STAT_RXMAC) {
 563                 if (gem_rxmac_interrupt(dev, gp, gem_status))
 564                         goto do_reset;
 565         }
 566
 567         if (gem_status & GREG_STAT_MAC) {
 568                 if (gem_mac_interrupt(dev, gp, gem_status))
 569                         goto do_reset;
 570         }
 571
 572         if (gem_status & GREG_STAT_MIF) {
 573                 if (gem_mif_interrupt(dev, gp, gem_status))
 574                         goto do_reset;
 575         }
 576
 577         if (gem_status & GREG_STAT_PCIERR) {
 578                 if (gem_pci_interrupt(dev, gp, gem_status))
 579                         goto do_reset;
 580         }
 581
 582         return 0;
 583
 584 do_reset:
 585         gp->reset_task_pending = 2;
 586         schedule_task(&gp->reset_task);
 587
 588         return 1;
 589 }
 590
 591 static __inline__ void gem_tx(struct net_device *dev, struct gem *gp, u32 gem_status)
 592 {
 593         int entry, limit;
 594
 595         if (netif_msg_intr(gp))
 596                 printk(KERN_DEBUG "%s: tx interrupt, gem_status: 0x%x\n",
 597                         gp->dev->name, gem_status);
 598
 599         entry = gp->tx_old;
 600         limit = ((gem_status & GREG_STAT_TXNR) >> GREG_STAT_TXNR_SHIFT);
 601         while (entry != limit) {
 602                 struct sk_buff *skb;
 603                 struct gem_txd *txd;
 604                 dma_addr_t dma_addr;
 605                 u32 dma_len;
 606                 int frag;
 607
 608                 if (netif_msg_tx_done(gp))
 609                         printk(KERN_DEBUG "%s: tx done, slot %d\n",
 610                                 gp->dev->name, entry);
 611                 skb = gp->tx_skbs[entry];
 612                 if (skb_shinfo(skb)->nr_frags) {
 613                         int last = entry + skb_shinfo(skb)->nr_frags;
 614                         int walk = entry;
 615                         int incomplete = 0;
 616
 617                         last &= (TX_RING_SIZE - 1);
 618                         for (;;) {
 619                                 walk = NEXT_TX(walk);
 620                                 if (walk == limit)
 621                                         incomplete = 1;
 622                                 if (walk == last)
 623                                         break;
 624                         }
 625                         if (incomplete)
 626                                 break;
 627                 }
 628                 gp->tx_skbs[entry] = NULL;
 629                 gp->net_stats.tx_bytes += skb->len;
 630
 631                 for (frag = 0; frag <= skb_shinfo(skb)->nr_frags; frag++) {
 632                         txd = &gp->init_block->txd[entry];
 633
 634                         dma_addr = le64_to_cpu(txd->buffer);
 635                         dma_len = le64_to_cpu(txd->control_word) & TXDCTRL_BUFSZ;
 636
 637                         pci_unmap_page(gp->pdev, dma_addr, dma_len, PCI_DMA_TODEVICE);
 638                         entry = NEXT_TX(entry);
 639                 }
 640
 641                 gp->net_stats.tx_packets++;
 642                 dev_kfree_skb_irq(skb);
 643         }
 644         gp->tx_old = entry;
 645
 646         if (netif_queue_stopped(dev) &&
 647             TX_BUFFS_AVAIL(gp) > (MAX_SKB_FRAGS + 1))
 648                 netif_wake_queue(dev);
 649 }
 650
 651 static __inline__ void gem_post_rxds(struct gem *gp, int limit)
 652 {
 653         int cluster_start, curr, count, kick;
 654
 655         cluster_start = curr = (gp->rx_new & ~(4 - 1));
 656         count = 0;
 657         kick = -1;
 658         while (curr != limit) {
 659                 curr = NEXT_RX(curr);
 660                 if (++count == 4) {
 661                         struct gem_rxd *rxd =
 662                                 &gp->init_block->rxd[cluster_start];
 663                         for (;;) {
 664                                 rxd->status_word = cpu_to_le64(RXDCTRL_FRESH(gp));
 665                                 rxd++;
 666                                 cluster_start = NEXT_RX(cluster_start);
 667                                 if (cluster_start == curr)
 668                                         break;
 669                         }
 670                         kick = curr;
 671                         count = 0;
 672                 }
 673         }
 674         if (kick >= 0)
 675                 writel(kick, gp->regs + RXDMA_KICK);
 676 }
 677
 678 static void gem_rx(struct gem *gp)
 679 {
 680         int entry, drops;
 681
 682         if (netif_msg_intr(gp))
 683                 printk(KERN_DEBUG "%s: rx interrupt, done: %d, rx_new: %d\n",
 684                         gp->dev->name, readl(gp->regs + RXDMA_DONE), gp->rx_new);
 685
 686         entry = gp->rx_new;
 687         drops = 0;
 688         for (;;) {
 689                 struct gem_rxd *rxd = &gp->init_block->rxd[entry];
 690                 struct sk_buff *skb;
 691                 u64 status = cpu_to_le64(rxd->status_word);
 692                 dma_addr_t dma_addr;
 693                 int len;
 694
 695                 if ((status & RXDCTRL_OWN) != 0)
 696                         break;
 697
 698                 skb = gp->rx_skbs[entry];
 699
 700                 len = (status & RXDCTRL_BUFSZ) >> 16;
 701                 if ((len < ETH_ZLEN) || (status & RXDCTRL_BAD)) {
 702                         gp->net_stats.rx_errors++;
 703                         if (len < ETH_ZLEN)
 704                                 gp->net_stats.rx_length_errors++;
 705                         if (len & RXDCTRL_BAD)
 706                                 gp->net_stats.rx_crc_errors++;
 707
 708                         /* We'll just return it to GEM. */
 709                 drop_it:
 710                         gp->net_stats.rx_dropped++;
 711                         goto next;
 712                 }
 713
 714                 dma_addr = cpu_to_le64(rxd->buffer);
 715                 if (len > RX_COPY_THRESHOLD) {
 716                         struct sk_buff *new_skb;
 717
 718                         new_skb = gem_alloc_skb(RX_BUF_ALLOC_SIZE(gp), GFP_ATOMIC);
 719                         if (new_skb == NULL) {
 720                                 drops++;
 721                                 goto drop_it;
 722                         }
 723                         pci_unmap_page(gp->pdev, dma_addr,
 724                                        RX_BUF_ALLOC_SIZE(gp),
 725                                        PCI_DMA_FROMDEVICE);
 726                         gp->rx_skbs[entry] = new_skb;
 727                         new_skb->dev = gp->dev;
 728                         skb_put(new_skb, (ETH_FRAME_LEN + RX_OFFSET));
 729                         rxd->buffer = cpu_to_le64(pci_map_page(gp->pdev,
 730                                                                virt_to_page(new_skb->data),
 731                                                                ((unsigned long) new_skb->data &
 732                                                                 ~PAGE_MASK),
 733                                                                RX_BUF_ALLOC_SIZE(gp),
 734                                                                PCI_DMA_FROMDEVICE));
 735                         skb_reserve(new_skb, RX_OFFSET);
 736
 737                         /* Trim the original skb for the netif. */
 738                         skb_trim(skb, len);
 739                 } else {
 740                         struct sk_buff *copy_skb = dev_alloc_skb(len + 2);
 741
 742                         if (copy_skb == NULL) {
 743                                 drops++;
 744                                 goto drop_it;
 745                         }
 746
 747                         copy_skb->dev = gp->dev;
 748                         skb_reserve(copy_skb, 2);
 749                         skb_put(copy_skb, len);
 750                         pci_dma_sync_single(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
 751                         memcpy(copy_skb->data, skb->data, len);
 752
 753                         /* We'll reuse the original ring buffer. */
 754                         skb = copy_skb;
 755                 }
 756
 757                 skb->csum = ntohs((status & RXDCTRL_TCPCSUM) ^ 0xffff);
 758                 skb->ip_summed = CHECKSUM_HW;
 759                 skb->protocol = eth_type_trans(skb, gp->dev);
 760                 netif_rx(skb);
 761
 762                 gp->net_stats.rx_packets++;
 763                 gp->net_stats.rx_bytes += len;
 764                 gp->dev->last_rx = jiffies;
 765
 766         next:
 767                 entry = NEXT_RX(entry);
 768         }
 769
 770         gem_post_rxds(gp, entry);
 771
 772         gp->rx_new = entry;
 773
 774         if (drops)
 775                 printk(KERN_INFO "%s: Memory squeeze, deferring packet.\n",
 776                        gp->dev->name);
 777 }
 778
 779 static void gem_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 780 {
 781         struct net_device *dev = dev_id;
 782         struct gem *gp = dev->priv;
 783         u32 gem_status = readl(gp->regs + GREG_STAT);
 784
 785         spin_lock(&gp->lock);
 786
 787         if (gem_status & GREG_STAT_ABNORMAL) {
 788                 if (gem_abnormal_irq(dev, gp, gem_status))
 789                         goto out;
 790         }
 791         if (gem_status & (GREG_STAT_TXALL | GREG_STAT_TXINTME))
 792                 gem_tx(dev, gp, gem_status);
 793         if (gem_status & GREG_STAT_RXDONE)
 794                 gem_rx(gp);
 795
 796 out:
 797         spin_unlock(&gp->lock);
 798 }
 799
 800 static void gem_tx_timeout(struct net_device *dev)
 801 {
 802         struct gem *gp = dev->priv;
 803
 804         printk(KERN_ERR "%s: transmit timed out, resetting\n", dev->name);
 805         if (!gp->hw_running) {
 806                 printk("%s: hrm.. hw not running !\n", dev->name);
 807                 return;
 808         }
 809         printk(KERN_ERR "%s: TX_STATE[%08x:%08x:%08x]\n",
 810                dev->name,
 811                readl(gp->regs + TXDMA_CFG),
 812                readl(gp->regs + MAC_TXSTAT),
 813                readl(gp->regs + MAC_TXCFG));
 814         printk(KERN_ERR "%s: RX_STATE[%08x:%08x:%08x]\n",
 815                dev->name,
 816                readl(gp->regs + RXDMA_CFG),
 817                readl(gp->regs + MAC_RXSTAT),
 818                readl(gp->regs + MAC_RXCFG));
 819
 820         spin_lock_irq(&gp->lock);
 821
 822         gp->reset_task_pending = 2;
 823         schedule_task(&gp->reset_task);
 824
 825         spin_unlock_irq(&gp->lock);
 826 }
 827
 828 static __inline__ int gem_intme(int entry)
 829 {
 830         /* Algorithm: IRQ every 1/2 of descriptors. */
 831         if (!(entry & ((TX_RING_SIZE>>1)-1)))
 832                 return 1;
 833
 834         return 0;
 835 }
 836
 837 static int gem_start_xmit(struct sk_buff *skb, struct net_device *dev)
 838 {
 839         struct gem *gp = dev->priv;
 840         int entry;
 841         u64 ctrl;
 842
 843         ctrl = 0;
 844         if (skb->ip_summed == CHECKSUM_HW) {
 845                 u64 csum_start_off, csum_stuff_off;
 846
 847                 csum_start_off = (u64) (skb->h.raw - skb->data);
 848                 csum_stuff_off = (u64) ((skb->h.raw + skb->csum) - skb->data);
 849
 850                 ctrl = (TXDCTRL_CENAB |
 851                         (csum_start_off << 15) |
 852                         (csum_stuff_off << 21));
 853         }
 854
 855         spin_lock_irq(&gp->lock);
 856
 857         /* This is a hard error, log it. */
 858         if (TX_BUFFS_AVAIL(gp) <= (skb_shinfo(skb)->nr_frags + 1)) {
 859                 netif_stop_queue(dev);
 860                 spin_unlock_irq(&gp->lock);
 861                 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
 862                        dev->name);
 863                 return 1;
 864         }
 865
 866         entry = gp->tx_new;
 867         gp->tx_skbs[entry] = skb;
 868
 869         if (skb_shinfo(skb)->nr_frags == 0) {
 870                 struct gem_txd *txd = &gp->init_block->txd[entry];
 871                 dma_addr_t mapping;
 872                 u32 len;
 873
 874                 len = skb->len;
 875                 mapping = pci_map_page(gp->pdev,
 876                                        virt_to_page(skb->data),
 877                                        ((unsigned long) skb->data &
 878                                         ~PAGE_MASK),
 879                                        len, PCI_DMA_TODEVICE);
 880                 ctrl |= TXDCTRL_SOF | TXDCTRL_EOF | len;
 881                 if (gem_intme(entry))
 882                         ctrl |= TXDCTRL_INTME;
 883                 txd->buffer = cpu_to_le64(mapping);
 884                 txd->control_word = cpu_to_le64(ctrl);
 885                 entry = NEXT_TX(entry);
 886         } else {
 887                 struct gem_txd *txd;
 888                 u32 first_len;
 889                 u64 intme;
 890                 dma_addr_t first_mapping;
 891                 int frag, first_entry = entry;
 892
 893                 intme = 0;
 894                 if (gem_intme(entry))
 895                         intme |= TXDCTRL_INTME;
 896
 897                 /* We must give this initial chunk to the device last.
 898                  * Otherwise we could race with the device.
 899                  */
 900                 first_len = skb->len - skb->data_len;
 901                 first_mapping = pci_map_page(gp->pdev, virt_to_page(skb->data),
 902                                              ((unsigned long) skb->data & ~PAGE_MASK),
 903                                              first_len, PCI_DMA_TODEVICE);
 904                 entry = NEXT_TX(entry);
 905
 906                 for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
 907                         skb_frag_t *this_frag = &skb_shinfo(skb)->frags[frag];
 908                         u32 len;
 909                         dma_addr_t mapping;
 910                         u64 this_ctrl;
 911
 912                         len = this_frag->size;
 913                         mapping = pci_map_page(gp->pdev,
 914                                                this_frag->page,
 915                                                this_frag->page_offset,
 916                                                len, PCI_DMA_TODEVICE);
 917                         this_ctrl = ctrl;
 918                         if (frag == skb_shinfo(skb)->nr_frags - 1)
 919                                 this_ctrl |= TXDCTRL_EOF;
 920
 921                         txd = &gp->init_block->txd[entry];
 922                         txd->buffer = cpu_to_le64(mapping);
 923                         txd->control_word = cpu_to_le64(this_ctrl | len);
 924
 925                         if (gem_intme(entry))
 926                                 intme |= TXDCTRL_INTME;
 927
 928                         entry = NEXT_TX(entry);
 929                 }
 930                 txd = &gp->init_block->txd[first_entry];
 931                 txd->buffer = cpu_to_le64(first_mapping);
 932                 txd->control_word =
 933                         cpu_to_le64(ctrl | TXDCTRL_SOF | intme | first_len);
 934         }
 935
 936         gp->tx_new = entry;
 937         if (TX_BUFFS_AVAIL(gp) <= (MAX_SKB_FRAGS + 1))
 938                 netif_stop_queue(dev);
 939
 940         if (netif_msg_tx_queued(gp))
 941                 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
 942                        dev->name, entry, skb->len);
 943         writel(gp->tx_new, gp->regs + TXDMA_KICK);
 944         spin_unlock_irq(&gp->lock);
 945
 946         dev->trans_start = jiffies;
 947
 948         return 0;
 949 }
 950
 951 /* Jumbo-grams don't seem to work :-( */
 952 #define GEM_MIN_MTU     68
 953 #if 1
 954 #define GEM_MAX_MTU     1500
 955 #else
 956 #define GEM_MAX_MTU     9000
 957 #endif
 958
 959 static int gem_change_mtu(struct net_device *dev, int new_mtu)
 960 {
 961         struct gem *gp = dev->priv;
 962
 963         if (new_mtu < GEM_MIN_MTU || new_mtu > GEM_MAX_MTU)
 964                 return -EINVAL;
 965
 966         if (!netif_running(dev) || !netif_device_present(dev)) {
 967                 /* We'll just catch it later when the
 968                  * device is up'd or resumed.
 969                  */
 970                 dev->mtu = new_mtu;
 971                 return 0;
 972         }
 973
 974         spin_lock_irq(&gp->lock);
 975         dev->mtu = new_mtu;
 976         gp->reset_task_pending = 1;
 977         schedule_task(&gp->reset_task);
 978         spin_unlock_irq(&gp->lock);
 979
 980         flush_scheduled_tasks();
 981
 982         return 0;
 983 }
 984
 985 #define STOP_TRIES 32
 986
 987 /* Must be invoked under gp->lock. */
 988 static void gem_stop(struct gem *gp)
 989 {
 990         int limit;
 991         u32 val;
 992
 993         /* Make sure we won't get any more interrupts */
 994         writel(0xffffffff, gp->regs + GREG_IMASK);
 995
 996         /* Reset the chip */
 997         writel(gp->swrst_base | GREG_SWRST_TXRST | GREG_SWRST_RXRST,
 998                gp->regs + GREG_SWRST);
 999
1000         limit = STOP_TRIES;
1001
1002         do {
1003                 udelay(20);
1004                 val = readl(gp->regs + GREG_SWRST);
1005                 if (limit-- <= 0)
1006                         break;
1007         } while (val & (GREG_SWRST_TXRST | GREG_SWRST_RXRST));
1008
1009         if (limit <= 0)
1010                 printk(KERN_ERR "gem: SW reset is ghetto.\n");
1011 }
1012
1013 /* Must be invoked under gp->lock. */
1014 static void gem_start_dma(struct gem *gp)
1015 {
1016         unsigned long val;
1017
1018         /* We are ready to rock, turn everything on. */
1019         val = readl(gp->regs + TXDMA_CFG);
1020         writel(val | TXDMA_CFG_ENABLE, gp->regs + TXDMA_CFG);
1021         val = readl(gp->regs + RXDMA_CFG);
1022         writel(val | RXDMA_CFG_ENABLE, gp->regs + RXDMA_CFG);
1023         val = readl(gp->regs + MAC_TXCFG);
1024         writel(val | MAC_TXCFG_ENAB, gp->regs + MAC_TXCFG);
1025         val = readl(gp->regs + MAC_RXCFG);
1026         writel(val | MAC_RXCFG_ENAB, gp->regs + MAC_RXCFG);
1027
1028         (void) readl(gp->regs + MAC_RXCFG);
1029         udelay(100);
1030
1031         writel(GREG_STAT_TXDONE, gp->regs + GREG_IMASK);
1032
1033         writel(RX_RING_SIZE - 4, gp->regs + RXDMA_KICK);
1034
1035 }
1036
1037
1038 /* Must be invoked under gp->lock. */
1039 // XXX dbl check what that function should do when called on PCS PHY
1040 static void gem_begin_auto_negotiation(struct gem *gp, struct ethtool_cmd *ep)
1041 {
1042         u32 advertise;
1043         int autoneg;
1044         int forced_speed;
1045         int forced_duplex;
1046
1047         /* Default advertise */
1048         advertise = ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full |
1049                     ADVERTISED_100baseT_Half | ADVERTISED_100baseT_Full;
1050         if (gp->gigabit_capable)
1051                 advertise |= ADVERTISED_1000baseT_Half | ADVERTISED_1000baseT_Full;
1052         autoneg = gp->want_autoneg;
1053         forced_speed = gp->phy_mii.speed;
1054         forced_duplex = gp->phy_mii.duplex;
1055
1056         /* Setup link parameters */
1057         if (!ep)
1058                 goto start_aneg;
1059         if (ep->autoneg == AUTONEG_ENABLE) {
1060                 advertise = ep->advertising;
1061                 autoneg = 1;
1062         } else {
1063                 autoneg = 0;
1064                 forced_speed = ep->speed;
1065                 forced_duplex = ep->duplex;
1066         }
1067
1068 start_aneg:
1069         if (!gp->hw_running) {
1070                 gp->phy_mii.autoneg = gp->want_autoneg = autoneg;
1071                 gp->phy_mii.speed = forced_speed;
1072                 gp->phy_mii.duplex = forced_duplex;
1073                 return;
1074         }
1075
1076         /* Configure PHY & start aneg */
1077         gp->want_autoneg = autoneg;
1078         if (autoneg) {
1079                 if (found_mii_phy(gp))
1080                         gp->phy_mii.def->ops->setup_aneg(&gp->phy_mii, advertise);
1081                 gp->lstate = link_aneg;
1082         } else {
1083                 if (found_mii_phy(gp))
1084                         gp->phy_mii.def->ops->setup_forced(&gp->phy_mii, forced_speed,
1085                                 forced_duplex);
1086                 gp->lstate = link_force_ok;
1087         }
1088
1089         gp->timer_ticks = 0;
1090         mod_timer(&gp->link_timer, jiffies + ((12 * HZ) / 10));
1091 }
1092
1093 /* A link-up condition has occurred, initialize and enable the
1094  * rest of the chip.
1095  *
1096  * Must be invoked under gp->lock.
1097  */
1098 static int gem_set_link_modes(struct gem *gp)
1099 {
1100         u32 val;
1101         int full_duplex, speed, pause;
1102
1103         full_duplex = 0;
1104         speed = SPEED_10;
1105         pause = 0;
1106
1107         if (found_mii_phy(gp)) {
1108                 if (gp->phy_mii.def->ops->read_link(&gp->phy_mii))
1109                         return 1;
1110                 full_duplex = (gp->phy_mii.duplex == DUPLEX_FULL);
1111                 speed = gp->phy_mii.speed;
1112                 pause = gp->phy_mii.pause;
1113         } else if (gp->phy_type == phy_serialink ||
1114                    gp->phy_type == phy_serdes) {
1115                 u32 pcs_lpa = readl(gp->regs + PCS_MIILP);
1116
1117                 if (pcs_lpa & PCS_MIIADV_FD)
1118                         full_duplex = 1;
1119                 speed = SPEED_1000;
1120         }
1121
1122         if (netif_msg_link(gp))
1123                 printk(KERN_INFO "%s: Link is up at %d Mbps, %s-duplex.\n",
1124                         gp->dev->name, speed, (full_duplex ? "full" : "half"));
1125
1126         val = (MAC_TXCFG_EIPG0 | MAC_TXCFG_NGU);
1127         if (full_duplex) {
1128                 val |= (MAC_TXCFG_ICS | MAC_TXCFG_ICOLL);
1129         } else {
1130                 /* MAC_TXCFG_NBO must be zero. */
1131         }
1132         writel(val, gp->regs + MAC_TXCFG);
1133
1134         val = (MAC_XIFCFG_OE | MAC_XIFCFG_LLED);
1135         if (!full_duplex &&
1136             (gp->phy_type == phy_mii_mdio0 ||
1137              gp->phy_type == phy_mii_mdio1)) {
1138                 val |= MAC_XIFCFG_DISE;
1139         } else if (full_duplex) {
1140                 val |= MAC_XIFCFG_FLED;
1141         }
1142
1143         if (speed == SPEED_1000)
1144                 val |= (MAC_XIFCFG_GMII);
1145
1146         writel(val, gp->regs + MAC_XIFCFG);
1147
1148         /* If gigabit and half-duplex, enable carrier extension
1149          * mode.  Else, disable it.
1150          */
1151         if (speed == SPEED_1000 && !full_duplex) {
1152                 val = readl(gp->regs + MAC_TXCFG);
1153                 writel(val | MAC_TXCFG_TCE, gp->regs + MAC_TXCFG);
1154
1155                 val = readl(gp->regs + MAC_RXCFG);
1156                 writel(val | MAC_RXCFG_RCE, gp->regs + MAC_RXCFG);
1157         } else {
1158                 val = readl(gp->regs + MAC_TXCFG);
1159                 writel(val & ~MAC_TXCFG_TCE, gp->regs + MAC_TXCFG);
1160
1161                 val = readl(gp->regs + MAC_RXCFG);
1162                 writel(val & ~MAC_RXCFG_RCE, gp->regs + MAC_RXCFG);
1163         }
1164
1165         if (gp->phy_type == phy_serialink ||
1166             gp->phy_type == phy_serdes) {
1167                 u32 pcs_lpa = readl(gp->regs + PCS_MIILP);
1168
1169                 if (pcs_lpa & (PCS_MIIADV_SP | PCS_MIIADV_AP))
1170                         pause = 1;
1171         }
1172
1173         if (netif_msg_link(gp)) {
1174                 if (pause) {
1175                         printk(KERN_INFO "%s: Pause is enabled "
1176                                "(rxfifo: %d off: %d on: %d)\n",
1177                                gp->dev->name,
1178                                gp->rx_fifo_sz,
1179                                gp->rx_pause_off,
1180                                gp->rx_pause_on);
1181                 } else {
1182                         printk(KERN_INFO "%s: Pause is disabled\n",
1183                                gp->dev->name);
1184                 }
1185         }
1186
1187         if (!full_duplex)
1188                 writel(512, gp->regs + MAC_STIME);
1189         else
1190                 writel(64, gp->regs + MAC_STIME);
1191         val = readl(gp->regs + MAC_MCCFG);
1192         if (pause)
1193                 val |= (MAC_MCCFG_SPE | MAC_MCCFG_RPE);
1194         else
1195                 val &= ~(MAC_MCCFG_SPE | MAC_MCCFG_RPE);
1196         writel(val, gp->regs + MAC_MCCFG);
1197
1198         gem_start_dma(gp);
1199
1200         return 0;
1201 }
1202
1203 /* Must be invoked under gp->lock. */
1204 static int gem_mdio_link_not_up(struct gem *gp)
1205 {
1206         if (gp->lstate == link_force_ret) {
1207                 if (netif_msg_link(gp))
1208                         printk(KERN_INFO "%s: Autoneg failed again, keeping"
1209                                 " forced mode\n", gp->dev->name);
1210                 gp->phy_mii.def->ops->setup_forced(&gp->phy_mii,
1211                         gp->last_forced_speed, DUPLEX_HALF);
1212                 gp->timer_ticks = 5;
1213                 gp->lstate = link_force_ok;
1214         } else if (gp->lstate == link_aneg) {
1215                 if (netif_msg_link(gp))
1216                         printk(KERN_INFO "%s: switching to forced 100bt\n",
1217                                 gp->dev->name);
1218                 /* Try forced modes. */
1219                 gp->phy_mii.def->ops->setup_forced(&gp->phy_mii, SPEED_100,
1220                         DUPLEX_HALF);
1221                 gp->timer_ticks = 5;
1222                 gp->lstate = link_force_try;
1223         } else {
1224                 /* Downgrade from 100 to 10 Mbps if necessary.
1225                  * If already at 10Mbps, warn user about the
1226                  * situation every 10 ticks.
1227                  */
1228                 if (gp->phy_mii.speed == SPEED_100) {
1229                         gp->phy_mii.def->ops->setup_forced(&gp->phy_mii, SPEED_10,
1230                                 DUPLEX_HALF);
1231                         gp->timer_ticks = 5;
1232                         if (netif_msg_link(gp))
1233                                 printk(KERN_INFO "%s: switching to forced 10bt\n",
1234                                         gp->dev->name);
1235                 } else
1236                         return 1;
1237         }
1238         return 0;
1239 }
1240
1241 static void gem_init_rings(struct gem *);
1242 static void gem_init_hw(struct gem *, int);
1243
1244 static void gem_reset_task(void *data)
1245 {
1246         struct gem *gp = (struct gem *) data;
1247
1248         /* The link went down, we reset the ring, but keep
1249          * DMA stopped. Todo: Use this function for reset
1250          * on error as well.
1251          */
1252
1253         spin_lock_irq(&gp->lock);
1254
1255         if (gp->hw_running && gp->opened) {
1256                 /* Make sure we don't get interrupts or tx packets */
1257                 netif_stop_queue(gp->dev);
1258
1259                 writel(0xffffffff, gp->regs + GREG_IMASK);
1260
1261                 /* Reset the chip & rings */
1262                 gem_stop(gp);
1263                 gem_init_rings(gp);
1264
1265                 gem_init_hw(gp,
1266                             (gp->reset_task_pending == 2));
1267
1268                 netif_wake_queue(gp->dev);
1269         }
1270         gp->reset_task_pending = 0;
1271
1272         spin_unlock_irq(&gp->lock);
1273 }
1274
1275 static void gem_link_timer(unsigned long data)
1276 {
1277         struct gem *gp = (struct gem *) data;
1278         int restart_aneg = 0;
1279
1280         if (!gp->hw_running)
1281                 return;
1282
1283         spin_lock_irq(&gp->lock);
1284
1285         /* If the link of task is still pending, we just
1286          * reschedule the link timer
1287          */
1288         if (gp->reset_task_pending)
1289                 goto restart;
1290
1291         if (gp->phy_type == phy_serialink ||
1292             gp->phy_type == phy_serdes) {
1293                 u32 val = readl(gp->regs + PCS_MIISTAT);
1294
1295                 if (!(val & PCS_MIISTAT_LS))
1296                         val = readl(gp->regs + PCS_MIISTAT);
1297
1298                 if ((val & PCS_MIISTAT_LS) != 0) {
1299                         gp->lstate = link_up;
1300                         netif_carrier_on(gp->dev);
1301                         if (gp->opened)
1302                                 (void)gem_set_link_modes(gp);
1303                 }
1304                 goto restart;
1305         }
1306         if (found_mii_phy(gp) && gp->phy_mii.def->ops->poll_link(&gp->phy_mii)) {
1307                 /* Ok, here we got a link. If we had it due to a forced
1308                  * fallback, and we were configured for autoneg, we do
1309                  * retry a short autoneg pass. If you know your hub is
1310                  * broken, use ethtool ;)
1311                  */
1312                 if (gp->lstate == link_force_try && gp->want_autoneg) {
1313                         gp->lstate = link_force_ret;
1314                         gp->last_forced_speed = gp->phy_mii.speed;
1315                         gp->timer_ticks = 5;
1316                         if (netif_msg_link(gp))
1317                                 printk(KERN_INFO "%s: Got link after fallback, retrying"
1318                                         " autoneg once...\n", gp->dev->name);
1319                         gp->phy_mii.def->ops->setup_aneg(&gp->phy_mii, gp->phy_mii.advertising);
1320                 } else if (gp->lstate != link_up) {
1321                         gp->lstate = link_up;
1322                         netif_carrier_on(gp->dev);
1323                         if (gp->opened && gem_set_link_modes(gp))
1324                                 restart_aneg = 1;
1325                 }
1326         } else {
1327                 /* If the link was previously up, we restart the
1328                  * whole process
1329                  */
1330                 if (gp->lstate == link_up) {
1331                         gp->lstate = link_down;
1332                         if (netif_msg_link(gp))
1333                                 printk(KERN_INFO "%s: Link down\n",
1334                                         gp->dev->name);
1335                         netif_carrier_off(gp->dev);
1336                         gp->reset_task_pending = 2;
1337                         schedule_task(&gp->reset_task);
1338                         restart_aneg = 1;
1339                 } else if (++gp->timer_ticks > 10) {
1340                         if (found_mii_phy(gp))
1341                                 restart_aneg = gem_mdio_link_not_up(gp);
1342                         else
1343                                 restart_aneg = 1;
1344                 }
1345         }
1346         if (restart_aneg) {
1347                 gem_begin_auto_negotiation(gp, NULL);
1348                 goto out_unlock;
1349         }
1350 restart:
1351         mod_timer(&gp->link_timer, jiffies + ((12 * HZ) / 10));
1352 out_unlock:
1353         spin_unlock_irq(&gp->lock);
1354 }
1355
1356 /* Must be invoked under gp->lock. */
1357 static void gem_clean_rings(struct gem *gp)
1358 {
1359         struct gem_init_block *gb = gp->init_block;
1360         struct sk_buff *skb;
1361         int i;
1362         dma_addr_t dma_addr;
1363
1364         for (i = 0; i < RX_RING_SIZE; i++) {
1365                 struct gem_rxd *rxd;
1366
1367                 rxd = &gb->rxd[i];
1368                 if (gp->rx_skbs[i] != NULL) {
1369                         skb = gp->rx_skbs[i];
1370                         dma_addr = le64_to_cpu(rxd->buffer);
1371                         pci_unmap_page(gp->pdev, dma_addr,
1372                                        RX_BUF_ALLOC_SIZE(gp),
1373                                        PCI_DMA_FROMDEVICE);
1374                         dev_kfree_skb_any(skb);
1375                         gp->rx_skbs[i] = NULL;
1376                 }
1377                 rxd->status_word = 0;
1378                 rxd->buffer = 0;
1379         }
1380
1381         for (i = 0; i < TX_RING_SIZE; i++) {
1382                 if (gp->tx_skbs[i] != NULL) {
1383                         struct gem_txd *txd;
1384                         int frag;
1385
1386                         skb = gp->tx_skbs[i];
1387                         gp->tx_skbs[i] = NULL;
1388
1389                         for (frag = 0; frag <= skb_shinfo(skb)->nr_frags; frag++) {
1390                                 int ent = i & (TX_RING_SIZE - 1);
1391
1392                                 txd = &gb->txd[ent];
1393                                 dma_addr = le64_to_cpu(txd->buffer);
1394                                 pci_unmap_page(gp->pdev, dma_addr,
1395                                                le64_to_cpu(txd->control_word) &
1396                                                TXDCTRL_BUFSZ, PCI_DMA_TODEVICE);
1397
1398                                 if (frag != skb_shinfo(skb)->nr_frags)
1399                                         i++;
1400                         }
1401                         dev_kfree_skb_any(skb);
1402                 }
1403         }
1404 }
1405
1406 /* Must be invoked under gp->lock. */
1407 static void gem_init_rings(struct gem *gp)
1408 {
1409         struct gem_init_block *gb = gp->init_block;
1410         struct net_device *dev = gp->dev;
1411         int i;
1412         dma_addr_t dma_addr;
1413
1414         gp->rx_new = gp->rx_old = gp->tx_new = gp->tx_old = 0;
1415
1416         gem_clean_rings(gp);
1417
1418         for (i = 0; i < RX_RING_SIZE; i++) {
1419                 struct sk_buff *skb;
1420                 struct gem_rxd *rxd = &gb->rxd[i];
1421
1422                 skb = gem_alloc_skb(RX_BUF_ALLOC_SIZE(gp), GFP_ATOMIC);
1423                 if (!skb) {
1424                         rxd->buffer = 0;
1425                         rxd->status_word = 0;
1426                         continue;
1427                 }
1428
1429                 gp->rx_skbs[i] = skb;
1430                 skb->dev = dev;
1431                 skb_put(skb, (ETH_FRAME_LEN + RX_OFFSET));
1432                 dma_addr = pci_map_page(gp->pdev,
1433                                         virt_to_page(skb->data),
1434                                         ((unsigned long) skb->data &
1435                                          ~PAGE_MASK),
1436                                         RX_BUF_ALLOC_SIZE(gp),
1437                                         PCI_DMA_FROMDEVICE);
1438                 rxd->buffer = cpu_to_le64(dma_addr);
1439                 rxd->status_word = cpu_to_le64(RXDCTRL_FRESH(gp));
1440                 skb_reserve(skb, RX_OFFSET);
1441         }
1442
1443         for (i = 0; i < TX_RING_SIZE; i++) {
1444                 struct gem_txd *txd = &gb->txd[i];
1445
1446                 txd->control_word = 0;
1447                 txd->buffer = 0;
1448         }
1449 }
1450
1451 /* Must be invoked under gp->lock. */
1452 static void gem_init_phy(struct gem *gp)
1453 {
1454         u32 mifcfg;
1455
1456         /* Revert MIF CFG setting done on stop_phy */
1457         mifcfg = readl(gp->regs + MIF_CFG);
1458         mifcfg &= ~MIF_CFG_BBMODE;
1459         writel(mifcfg, gp->regs + MIF_CFG);
1460
1461 #ifdef CONFIG_ALL_PPC
1462         if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE) {
1463                 int i, j;
1464
1465                 /* Those delay sucks, the HW seem to love them though, I'll
1466                  * serisouly consider breaking some locks here to be able
1467                  * to schedule instead
1468                  */
1469                 pmac_call_feature(PMAC_FTR_GMAC_PHY_RESET, gp->of_node, 0, 0);
1470                 mdelay(10);
1471                 for (j = 0; j < 3; j++) {
1472                         /* Some PHYs used by apple have problem getting back to us,
1473                          * we _know_ it's actually at addr 0, that's a hack, but
1474                          * it helps to do that reset now. I suspect some motherboards
1475                          * don't wire the PHY reset line properly, thus the PHY doesn't
1476                          * come back with the above pmac_call_feature.
1477                          */
1478                         gp->mii_phy_addr = 0;
1479                         phy_write(gp, MII_BMCR, BMCR_RESET);
1480                         /* We should probably break some locks here and schedule... */
1481                         mdelay(10);
1482                         for (i = 0; i < 32; i++) {
1483                                 gp->mii_phy_addr = i;
1484                                 if (phy_read(gp, MII_BMCR) != 0xffff)
1485                                         break;
1486                         }
1487                         if (i == 32) {
1488                                 printk(KERN_WARNING "%s: GMAC PHY not responding !\n",
1489                                        gp->dev->name);
1490                                 gp->mii_phy_addr = 0;
1491                         } else
1492                                 break;
1493                 }
1494         }
1495 #endif /* CONFIG_ALL_PPC */
1496
1497         if (gp->pdev->vendor == PCI_VENDOR_ID_SUN &&
1498             gp->pdev->device == PCI_DEVICE_ID_SUN_GEM) {
1499                 u32 val;
1500
1501                 /* Init datapath mode register. */
1502                 if (gp->phy_type == phy_mii_mdio0 ||
1503                     gp->phy_type == phy_mii_mdio1) {
1504                         val = PCS_DMODE_MGM;
1505                 } else if (gp->phy_type == phy_serialink) {
1506                         val = PCS_DMODE_SM | PCS_DMODE_GMOE;
1507                 } else {
1508                         val = PCS_DMODE_ESM;
1509                 }
1510
1511                 writel(val, gp->regs + PCS_DMODE);
1512         }
1513
1514         if (gp->phy_type == phy_mii_mdio0 ||
1515             gp->phy_type == phy_mii_mdio1) {
1516                 // XXX check for errors
1517                 mii_phy_probe(&gp->phy_mii, gp->mii_phy_addr);
1518
1519                 gp->gigabit_capable = gp->phy_mii.def && (gp->phy_mii.def->features &
1520                         (SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full)) != 0;
1521                 /* Init PHY */
1522                 if (gp->phy_mii.def && gp->phy_mii.def->ops->init)
1523                         gp->phy_mii.def->ops->init(&gp->phy_mii);
1524         } else {
1525                 u32 val;
1526                 int limit;
1527
1528                 /* Reset PCS unit. */
1529                 val = readl(gp->regs + PCS_MIICTRL);
1530                 val |= PCS_MIICTRL_RST;
1531                 writeb(val, gp->regs + PCS_MIICTRL);
1532
1533                 limit = 32;
1534                 while (readl(gp->regs + PCS_MIICTRL) & PCS_MIICTRL_RST) {
1535                         udelay(100);
1536                         if (limit-- <= 0)
1537                                 break;
1538                 }
1539                 if (limit <= 0)
1540                         printk(KERN_WARNING "%s: PCS reset bit would not clear.\n",
1541                                gp->dev->name);
1542
1543                 /* Make sure PCS is disabled while changing advertisement
1544                  * configuration.
1545                  */
1546                 val = readl(gp->regs + PCS_CFG);
1547                 val &= ~(PCS_CFG_ENABLE | PCS_CFG_TO);
1548                 writel(val, gp->regs + PCS_CFG);
1549
1550                 /* Advertise all capabilities except assymetric
1551                  * pause.
1552                  */
1553                 val = readl(gp->regs + PCS_MIIADV);
1554                 val |= (PCS_MIIADV_FD | PCS_MIIADV_HD |
1555                         PCS_MIIADV_SP | PCS_MIIADV_AP);
1556                 writel(val, gp->regs + PCS_MIIADV);
1557
1558                 /* Enable and restart auto-negotiation, disable wrapback/loopback,
1559                  * and re-enable PCS.
1560                  */
1561                 val = readl(gp->regs + PCS_MIICTRL);
1562                 val |= (PCS_MIICTRL_RAN | PCS_MIICTRL_ANE);
1563                 val &= ~PCS_MIICTRL_WB;
1564                 writel(val, gp->regs + PCS_MIICTRL);
1565
1566                 val = readl(gp->regs + PCS_CFG);
1567                 val |= PCS_CFG_ENABLE;
1568                 writel(val, gp->regs + PCS_CFG);
1569
1570                 /* Make sure serialink loopback is off.  The meaning
1571                  * of this bit is logically inverted based upon whether
1572                  * you are in Serialink or SERDES mode.
1573                  */
1574                 val = readl(gp->regs + PCS_SCTRL);
1575                 if (gp->phy_type == phy_serialink)
1576                         val &= ~PCS_SCTRL_LOOP;
1577                 else
1578                         val |= PCS_SCTRL_LOOP;
1579                 writel(val, gp->regs + PCS_SCTRL);
1580                 gp->gigabit_capable = 1;
1581         }
1582 }
1583
1584 /* Must be invoked under gp->lock. */
1585 static void gem_init_dma(struct gem *gp)
1586 {
1587         u64 desc_dma = (u64) gp->gblock_dvma;
1588         u32 val;
1589
1590         val = (TXDMA_CFG_BASE | (0x7ff << 10) | TXDMA_CFG_PMODE);
1591         writel(val, gp->regs + TXDMA_CFG);
1592
1593         writel(desc_dma >> 32, gp->regs + TXDMA_DBHI);
1594         writel(desc_dma & 0xffffffff, gp->regs + TXDMA_DBLOW);
1595         desc_dma += (INIT_BLOCK_TX_RING_SIZE * sizeof(struct gem_txd));
1596
1597         writel(0, gp->regs + TXDMA_KICK);
1598
1599         val = (RXDMA_CFG_BASE | (RX_OFFSET << 10) |
1600                ((14 / 2) << 13) | RXDMA_CFG_FTHRESH_128);
1601         writel(val, gp->regs + RXDMA_CFG);
1602
1603         writel(desc_dma >> 32, gp->regs + RXDMA_DBHI);
1604         writel(desc_dma & 0xffffffff, gp->regs + RXDMA_DBLOW);
1605
1606         writel(RX_RING_SIZE - 4, gp->regs + RXDMA_KICK);
1607
1608         val  = (((gp->rx_pause_off / 64) << 0) & RXDMA_PTHRESH_OFF);
1609         val |= (((gp->rx_pause_on / 64) << 12) & RXDMA_PTHRESH_ON);
1610         writel(val, gp->regs + RXDMA_PTHRESH);
1611
1612         if (readl(gp->regs + GREG_BIFCFG) & GREG_BIFCFG_M66EN)
1613                 writel(((5 & RXDMA_BLANK_IPKTS) |
1614                         ((8 << 12) & RXDMA_BLANK_ITIME)),
1615                        gp->regs + RXDMA_BLANK);
1616         else
1617                 writel(((5 & RXDMA_BLANK_IPKTS) |
1618                         ((4 << 12) & RXDMA_BLANK_ITIME)),
1619                        gp->regs + RXDMA_BLANK);
1620 }
1621
1622 /* Must be invoked under gp->lock. */
1623 static u32
1624 gem_setup_multicast(struct gem *gp)
1625 {
1626         u32 rxcfg = 0;
1627         int i;
1628
1629         if ((gp->dev->flags & IFF_ALLMULTI) ||
1630             (gp->dev->mc_count > 256)) {
1631                 for (i=0; i<16; i++)
1632                         writel(0xffff, gp->regs + MAC_HASH0 + (i << 2));
1633                 rxcfg |= MAC_RXCFG_HFE;
1634         } else if (gp->dev->flags & IFF_PROMISC) {
1635                 rxcfg |= MAC_RXCFG_PROM;
1636         } else {
1637                 u16 hash_table[16];
1638                 u32 crc;
1639                 struct dev_mc_list *dmi = gp->dev->mc_list;
1640                 int i;
1641
1642                 for (i = 0; i < 16; i++)
1643                         hash_table[i] = 0;
1644
1645                 for (i = 0; i < gp->dev->mc_count; i++) {
1646                         char *addrs = dmi->dmi_addr;
1647
1648                         dmi = dmi->next;
1649
1650                         if (!(*addrs & 1))
1651                                 continue;
1652
1653                         crc = ether_crc_le(6, addrs);
1654                         crc >>= 24;
1655                         hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf));
1656                 }
1657                 for (i=0; i<16; i++)
1658                         writel(hash_table[i], gp->regs + MAC_HASH0 + (i << 2));
1659                 rxcfg |= MAC_RXCFG_HFE;
1660         }
1661
1662         return rxcfg;
1663 }
1664
1665 /* Must be invoked under gp->lock. */
1666 static void gem_init_mac(struct gem *gp)
1667 {
1668         unsigned char *e = &gp->dev->dev_addr[0];
1669
1670         writel(0x1bf0, gp->regs + MAC_SNDPAUSE);
1671
1672         writel(0x00, gp->regs + MAC_IPG0);
1673         writel(0x08, gp->regs + MAC_IPG1);
1674         writel(0x04, gp->regs + MAC_IPG2);
1675         writel(0x40, gp->regs + MAC_STIME);
1676         writel(0x40, gp->regs + MAC_MINFSZ);
1677
1678         /* Ethernet payload + header + FCS + optional VLAN tag. */
1679         writel(0x20000000 | (gp->dev->mtu + ETH_HLEN + 4 + 4), gp->regs + MAC_MAXFSZ);
1680
1681         writel(0x07, gp->regs + MAC_PASIZE);
1682         writel(0x04, gp->regs + MAC_JAMSIZE);
1683         writel(0x10, gp->regs + MAC_ATTLIM);
1684         writel(0x8808, gp->regs + MAC_MCTYPE);
1685
1686         writel((e[5] | (e[4] << 8)) & 0x3ff, gp->regs + MAC_RANDSEED);
1687
1688         writel((e[4] << 8) | e[5], gp->regs + MAC_ADDR0);
1689         writel((e[2] << 8) | e[3], gp->regs + MAC_ADDR1);
1690         writel((e[0] << 8) | e[1], gp->regs + MAC_ADDR2);
1691
1692         writel(0, gp->regs + MAC_ADDR3);
1693         writel(0, gp->regs + MAC_ADDR4);
1694         writel(0, gp->regs + MAC_ADDR5);
1695
1696         writel(0x0001, gp->regs + MAC_ADDR6);
1697         writel(0xc200, gp->regs + MAC_ADDR7);
1698         writel(0x0180, gp->regs + MAC_ADDR8);
1699
1700         writel(0, gp->regs + MAC_AFILT0);
1701         writel(0, gp->regs + MAC_AFILT1);
1702         writel(0, gp->regs + MAC_AFILT2);
1703         writel(0, gp->regs + MAC_AF21MSK);
1704         writel(0, gp->regs + MAC_AF0MSK);
1705
1706         gp->mac_rx_cfg = gem_setup_multicast(gp);
1707
1708         writel(0, gp->regs + MAC_NCOLL);
1709         writel(0, gp->regs + MAC_FASUCC);
1710         writel(0, gp->regs + MAC_ECOLL);
1711         writel(0, gp->regs + MAC_LCOLL);
1712         writel(0, gp->regs + MAC_DTIMER);
1713         writel(0, gp->regs + MAC_PATMPS);
1714         writel(0, gp->regs + MAC_RFCTR);
1715         writel(0, gp->regs + MAC_LERR);
1716         writel(0, gp->regs + MAC_AERR);
1717         writel(0, gp->regs + MAC_FCSERR);
1718         writel(0, gp->regs + MAC_RXCVERR);
1719
1720         /* Clear RX/TX/MAC/XIF config, we will set these up and enable
1721          * them once a link is established.
1722          */
1723         writel(0, gp->regs + MAC_TXCFG);
1724         writel(gp->mac_rx_cfg, gp->regs + MAC_RXCFG);
1725         writel(0, gp->regs + MAC_MCCFG);
1726         writel(0, gp->regs + MAC_XIFCFG);
1727
1728         /* Setup MAC interrupts.  We want to get all of the interesting
1729          * counter expiration events, but we do not want to hear about
1730          * normal rx/tx as the DMA engine tells us that.
1731          */
1732         writel(MAC_TXSTAT_XMIT, gp->regs + MAC_TXMASK);
1733         writel(MAC_RXSTAT_RCV, gp->regs + MAC_RXMASK);
1734
1735         /* Don't enable even the PAUSE interrupts for now, we
1736          * make no use of those events other than to record them.
1737          */
1738         writel(0xffffffff, gp->regs + MAC_MCMASK);
1739 }
1740
1741 /* Must be invoked under gp->lock. */
1742 static void gem_init_pause_thresholds(struct gem *gp)
1743 {
1744         /* Calculate pause thresholds.  Setting the OFF threshold to the
1745          * full RX fifo size effectively disables PAUSE generation which
1746          * is what we do for 10/100 only GEMs which have FIFOs too small
1747          * to make real gains from PAUSE.
1748          */
1749         if (gp->rx_fifo_sz <= (2 * 1024)) {
1750                 gp->rx_pause_off = gp->rx_pause_on = gp->rx_fifo_sz;
1751         } else {
1752                 int max_frame = (gp->dev->mtu + ETH_HLEN + 4 + 4 + 64) & ~63;
1753                 int off = (gp->rx_fifo_sz - (max_frame * 2));
1754                 int on = off - max_frame;
1755
1756                 gp->rx_pause_off = off;
1757                 gp->rx_pause_on = on;
1758         }
1759
1760         {
1761                 u32 cfg;
1762
1763                 cfg  = 0;
1764 #if !defined(CONFIG_SPARC64) && !defined(CONFIG_ALPHA)
1765                 cfg |= GREG_CFG_IBURST;
1766 #endif
1767                 cfg |= ((31 << 1) & GREG_CFG_TXDMALIM);
1768                 cfg |= ((31 << 6) & GREG_CFG_RXDMALIM);
1769                 writel(cfg, gp->regs + GREG_CFG);
1770         }
1771 }
1772
1773 static int gem_check_invariants(struct gem *gp)
1774 {
1775         struct pci_dev *pdev = gp->pdev;
1776         u32 mif_cfg;
1777
1778         /* On Apple's sungem, we can't rely on registers as the chip
1779          * was been powered down by the firmware. The PHY is looked
1780          * up later on.
1781          */
1782         if (pdev->vendor == PCI_VENDOR_ID_APPLE) {
1783                 gp->phy_type = phy_mii_mdio0;
1784                 gp->tx_fifo_sz = readl(gp->regs + TXDMA_FSZ) * 64;
1785                 gp->rx_fifo_sz = readl(gp->regs + RXDMA_FSZ) * 64;
1786                 gp->swrst_base = 0;
1787                 return 0;
1788         }
1789
1790         mif_cfg = readl(gp->regs + MIF_CFG);
1791
1792         if (pdev->vendor == PCI_VENDOR_ID_SUN &&
1793             pdev->device == PCI_DEVICE_ID_SUN_RIO_GEM) {
1794                 /* One of the MII PHYs _must_ be present
1795                  * as this chip has no gigabit PHY.
1796                  */
1797                 if ((mif_cfg & (MIF_CFG_MDI0 | MIF_CFG_MDI1)) == 0) {
1798                         printk(KERN_ERR PFX "RIO GEM lacks MII phy, mif_cfg[%08x]\n",
1799                                mif_cfg);
1800                         return -1;
1801                 }
1802         }
1803
1804         /* Determine initial PHY interface type guess.  MDIO1 is the
1805          * external PHY and thus takes precedence over MDIO0.
1806          */
1807
1808         if (mif_cfg & MIF_CFG_MDI1) {
1809                 gp->phy_type = phy_mii_mdio1;
1810                 mif_cfg |= MIF_CFG_PSELECT;
1811                 writel(mif_cfg, gp->regs + MIF_CFG);
1812         } else if (mif_cfg & MIF_CFG_MDI0) {
1813                 gp->phy_type = phy_mii_mdio0;
1814                 mif_cfg &= ~MIF_CFG_PSELECT;
1815                 writel(mif_cfg, gp->regs + MIF_CFG);
1816         } else {
1817                 gp->phy_type = phy_serialink;
1818         }
1819         if (gp->phy_type == phy_mii_mdio1 ||
1820             gp->phy_type == phy_mii_mdio0) {
1821                 int i;
1822
1823                 for (i = 0; i < 32; i++) {
1824                         gp->mii_phy_addr = i;
1825                         if (phy_read(gp, MII_BMCR) != 0xffff)
1826                                 break;
1827                 }
1828                 if (i == 32) {
1829                         if (pdev->device != PCI_DEVICE_ID_SUN_GEM) {
1830                                 printk(KERN_ERR PFX "RIO MII phy will not respond.\n");
1831                                 return -1;
1832                         }
1833                         gp->phy_type = phy_serdes;
1834                 }
1835         }
1836
1837         /* Fetch the FIFO configurations now too. */
1838         gp->tx_fifo_sz = readl(gp->regs + TXDMA_FSZ) * 64;
1839         gp->rx_fifo_sz = readl(gp->regs + RXDMA_FSZ) * 64;
1840
1841         if (pdev->vendor == PCI_VENDOR_ID_SUN) {
1842                 if (pdev->device == PCI_DEVICE_ID_SUN_GEM) {
1843                         if (gp->tx_fifo_sz != (9 * 1024) ||
1844                             gp->rx_fifo_sz != (20 * 1024)) {
1845                                 printk(KERN_ERR PFX "GEM has bogus fifo sizes tx(%d) rx(%d)\n",
1846                                        gp->tx_fifo_sz, gp->rx_fifo_sz);
1847                                 return -1;
1848                         }
1849                         gp->swrst_base = 0;
1850                 } else {
1851                         if (gp->tx_fifo_sz != (2 * 1024) ||
1852                             gp->rx_fifo_sz != (2 * 1024)) {
1853                                 printk(KERN_ERR PFX "RIO GEM has bogus fifo sizes tx(%d) rx(%d)\n",
1854                                        gp->tx_fifo_sz, gp->rx_fifo_sz);
1855                                 return -1;
1856                         }
1857                         gp->swrst_base = (64 / 4) << GREG_SWRST_CACHE_SHIFT;
1858                 }
1859         }
1860
1861         return 0;
1862 }
1863
1864 /* Must be invoked under gp->lock. */
1865 static void gem_init_hw(struct gem *gp, int restart_link)
1866 {
1867         /* On Apple's gmac, I initialize the PHY only after
1868          * setting up the chip. It appears the gigabit PHYs
1869          * don't quite like beeing talked to on the GII when
1870          * the chip is not running, I suspect it might not
1871          * be clocked at that point. --BenH
1872          */
1873         if (restart_link)
1874                 gem_init_phy(gp);
1875         gem_init_pause_thresholds(gp);
1876         gem_init_dma(gp);
1877         gem_init_mac(gp);
1878
1879         if (restart_link) {
1880                 /* Default aneg parameters */
1881                 gp->timer_ticks = 0;
1882                 gp->lstate = link_down;
1883                 netif_carrier_off(gp->dev);
1884
1885                 /* Can I advertise gigabit here ? I'd need BCM PHY docs... */
1886                 gem_begin_auto_negotiation(gp, NULL);
1887         } else {
1888                 if (gp->lstate == link_up) {
1889                         netif_carrier_on(gp->dev);
1890                         gem_set_link_modes(gp);
1891                 }
1892         }
1893 }
1894
1895 #ifdef CONFIG_ALL_PPC
1896 /* Enable the chip's clock and make sure it's config space is
1897  * setup properly. There appear to be no need to restore the
1898  * base addresses.
1899  */
1900 static void gem_apple_powerup(struct gem *gp)
1901 {
1902         u16 cmd;
1903         u32 mif_cfg;
1904
1905         pmac_call_feature(PMAC_FTR_GMAC_ENABLE, gp->of_node, 0, 1);
1906
1907         current->state = TASK_UNINTERRUPTIBLE;
1908         schedule_timeout((21 * HZ) / 1000);
1909
1910         pci_read_config_word(gp->pdev, PCI_COMMAND, &cmd);
1911         cmd |= PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE;
1912         pci_write_config_word(gp->pdev, PCI_COMMAND, cmd);
1913         pci_write_config_byte(gp->pdev, PCI_LATENCY_TIMER, 6);
1914         pci_write_config_byte(gp->pdev, PCI_CACHE_LINE_SIZE, 8);
1915
1916         mdelay(1);
1917
1918         mif_cfg = readl(gp->regs + MIF_CFG);
1919         mif_cfg &= ~(MIF_CFG_PSELECT|MIF_CFG_POLL|MIF_CFG_BBMODE|MIF_CFG_MDI1);
1920         mif_cfg |= MIF_CFG_MDI0;
1921         writel(mif_cfg, gp->regs + MIF_CFG);
1922         writel(PCS_DMODE_MGM, gp->regs + PCS_DMODE);
1923         writel(MAC_XIFCFG_OE, gp->regs + MAC_XIFCFG);
1924
1925         mdelay(1);
1926 }
1927
1928 /* Turn off the chip's clock */
1929 static void gem_apple_powerdown(struct gem *gp)
1930 {
1931         pmac_call_feature(PMAC_FTR_GMAC_ENABLE, gp->of_node, 0, 0);
1932 }
1933
1934 #endif /* CONFIG_ALL_PPC */
1935
1936 /* Must be invoked under gp->lock. */
1937 static void gem_stop_phy(struct gem *gp)
1938 {
1939         u32 mifcfg;
1940
1941         /* Make sure we aren't polling PHY status change. We
1942          * don't currently use that feature though
1943          */
1944         mifcfg = readl(gp->regs + MIF_CFG);
1945         mifcfg &= ~MIF_CFG_POLL;
1946         writel(mifcfg, gp->regs + MIF_CFG);
1947
1948         if (gp->wake_on_lan) {
1949                 /* Setup wake-on-lan */
1950         } else
1951                 writel(0, gp->regs + MAC_RXCFG);
1952         writel(0, gp->regs + MAC_TXCFG);
1953         writel(0, gp->regs + MAC_XIFCFG);
1954         writel(0, gp->regs + TXDMA_CFG);
1955         writel(0, gp->regs + RXDMA_CFG);
1956
1957         if (!gp->wake_on_lan) {
1958                 gem_stop(gp);
1959                 writel(MAC_TXRST_CMD, gp->regs + MAC_TXRST);
1960                 writel(MAC_RXRST_CMD, gp->regs + MAC_RXRST);
1961         }
1962
1963         if (found_mii_phy(gp) && gp->phy_mii.def->ops->suspend)
1964                 gp->phy_mii.def->ops->suspend(&gp->phy_mii, 0 /* wake on lan options */);
1965
1966         if (!gp->wake_on_lan) {
1967                 /* According to Apple, we must set the MDIO pins to this begnign
1968                  * state or we may 1) eat more current, 2) damage some PHYs
1969                  */
1970                 writel(mifcfg | MIF_CFG_BBMODE, gp->regs + MIF_CFG);
1971                 writel(0, gp->regs + MIF_BBCLK);
1972                 writel(0, gp->regs + MIF_BBDATA);
1973                 writel(0, gp->regs + MIF_BBOENAB);
1974                 writel(MAC_XIFCFG_GMII | MAC_XIFCFG_LBCK, gp->regs + MAC_XIFCFG);
1975                 (void) readl(gp->regs + MAC_XIFCFG);
1976         }
1977 }
1978
1979 /* Shut down the chip, must be called with pm_sem held.  */
1980 static void gem_shutdown(struct gem *gp)
1981 {
1982         /* Make us not-running to avoid timers respawning */
1983         gp->hw_running = 0;
1984
1985         /* Stop the link timer */
1986         del_timer_sync(&gp->link_timer);
1987
1988         /* Stop the reset task */
1989         while (gp->reset_task_pending)
1990                 schedule();
1991
1992         /* Actually stop the chip */
1993         spin_lock_irq(&gp->lock);
1994         if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE) {
1995                 gem_stop_phy(gp);
1996
1997                 spin_unlock_irq(&gp->lock);
1998
1999 #ifdef CONFIG_ALL_PPC
2000                 /* Power down the chip */
2001                 gem_apple_powerdown(gp);
2002 #endif /* CONFIG_ALL_PPC */
2003         } else {
2004                 gem_stop(gp);
2005
2006                 spin_unlock_irq(&gp->lock);
2007         }
2008 }
2009
2010 static void gem_pm_task(void *data)
2011 {
2012         struct gem *gp = (struct gem *) data;
2013
2014         /* We assume if we can't lock the pm_sem, then open() was
2015          * called again (or suspend()), and we can safely ignore
2016          * the PM request
2017          */
2018         if (down_trylock(&gp->pm_sem))
2019                 return;
2020
2021         /* Driver was re-opened or already shut down */
2022         if (gp->opened || !gp->hw_running) {
2023                 up(&gp->pm_sem);
2024                 return;
2025         }
2026
2027         gem_shutdown(gp);
2028
2029         up(&gp->pm_sem);
2030 }
2031
2032 static void gem_pm_timer(unsigned long data)
2033 {
2034         struct gem *gp = (struct gem *) data;
2035
2036         schedule_task(&gp->pm_task);
2037 }
2038
2039 static int gem_open(struct net_device *dev)
2040 {
2041         struct gem *gp = dev->priv;
2042         int hw_was_up;
2043
2044         down(&gp->pm_sem);
2045
2046         hw_was_up = gp->hw_running;
2047
2048         /* Stop the PM timer/task */
2049         del_timer(&gp->pm_timer);
2050         flush_scheduled_tasks();
2051
2052         /* The power-management semaphore protects the hw_running
2053          * etc. state so it is safe to do this bit without gp->lock
2054          */
2055         if (!gp->hw_running) {
2056 #ifdef CONFIG_ALL_PPC
2057                 /* First, we need to bring up the chip */
2058                 if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE) {
2059                         gem_apple_powerup(gp);
2060                         gem_check_invariants(gp);
2061                 }
2062 #endif /* CONFIG_ALL_PPC */
2063
2064                 /* Reset the chip */
2065                 spin_lock_irq(&gp->lock);
2066                 gem_stop(gp);
2067                 spin_unlock_irq(&gp->lock);
2068
2069                 gp->hw_running = 1;
2070         }
2071
2072         spin_lock_irq(&gp->lock);
2073
2074         /* We can now request the interrupt as we know it's masked
2075          * on the controller
2076          */
2077         if (request_irq(gp->pdev->irq, gem_interrupt,
2078                         SA_SHIRQ, dev->name, (void *)dev)) {
2079                 spin_unlock_irq(&gp->lock);
2080
2081                 printk(KERN_ERR "%s: failed to request irq !\n", gp->dev->name);
2082
2083 #ifdef CONFIG_ALL_PPC
2084                 if (!hw_was_up && gp->pdev->vendor == PCI_VENDOR_ID_APPLE)
2085                         gem_apple_powerdown(gp);
2086 #endif /* CONFIG_ALL_PPC */
2087                 /* Fire the PM timer that will shut us down in about 10 seconds */
2088                 gp->pm_timer.expires = jiffies + 10*HZ;
2089                 add_timer(&gp->pm_timer);
2090                 up(&gp->pm_sem);
2091
2092                 return -EAGAIN;
2093         }
2094
2095         /* Allocate & setup ring buffers */
2096         gem_init_rings(gp);
2097
2098         /* Init & setup chip hardware */
2099         gem_init_hw(gp, !hw_was_up);
2100
2101         gp->opened = 1;
2102
2103         spin_unlock_irq(&gp->lock);
2104
2105         up(&gp->pm_sem);
2106
2107         return 0;
2108 }
2109
2110 static int gem_close(struct net_device *dev)
2111 {
2112         struct gem *gp = dev->priv;
2113
2114         /* Make sure we don't get distracted by suspend/resume */
2115         down(&gp->pm_sem);
2116
2117         /* Stop traffic, mark us closed */
2118         spin_lock_irq(&gp->lock);
2119
2120         gp->opened = 0;
2121         writel(0xffffffff, gp->regs + GREG_IMASK);
2122         netif_stop_queue(dev);
2123
2124         /* Stop chip */
2125         gem_stop(gp);
2126
2127         /* Get rid of rings */
2128         gem_clean_rings(gp);
2129
2130         /* Bye, the pm timer will finish the job */
2131         free_irq(gp->pdev->irq, (void *) dev);
2132
2133         spin_unlock_irq(&gp->lock);
2134
2135         /* Fire the PM timer that will shut us down in about 10 seconds */
2136         gp->pm_timer.expires = jiffies + 10*HZ;
2137         add_timer(&gp->pm_timer);
2138
2139         up(&gp->pm_sem);
2140
2141         return 0;
2142 }
2143
2144 #ifdef CONFIG_PM
2145 static int gem_suspend(struct pci_dev *pdev, u32 state)
2146 {
2147         struct net_device *dev = pci_get_drvdata(pdev);
2148         struct gem *gp = dev->priv;
2149
2150         /* We hold the PM semaphore during entire driver
2151          * sleep time
2152          */
2153         down(&gp->pm_sem);
2154
2155         printk(KERN_INFO "%s: suspending, WakeOnLan %s\n",
2156                dev->name, gp->wake_on_lan ? "enabled" : "disabled");
2157
2158         /* If the driver is opened, we stop the DMA */
2159         if (gp->opened) {
2160                 spin_lock_irq(&gp->lock);
2161
2162                 /* Stop traffic, mark us closed */
2163                 netif_device_detach(dev);
2164
2165                 writel(0xffffffff, gp->regs + GREG_IMASK);
2166
2167                 /* Stop chip */
2168                 gem_stop(gp);
2169
2170                 /* Get rid of ring buffers */
2171                 gem_clean_rings(gp);
2172
2173                 spin_unlock_irq(&gp->lock);
2174
2175                 if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE)
2176                         disable_irq(gp->pdev->irq);
2177         }
2178
2179         if (gp->hw_running) {
2180                 /* Kill PM timer if any */
2181                 del_timer_sync(&gp->pm_timer);
2182                 flush_scheduled_tasks();
2183
2184                 gem_shutdown(gp);
2185         }
2186
2187         return 0;
2188 }
2189
2190 static int gem_resume(struct pci_dev *pdev)
2191 {
2192         struct net_device *dev = pci_get_drvdata(pdev);
2193         struct gem *gp = dev->priv;
2194
2195         printk(KERN_INFO "%s: resuming\n", dev->name);
2196
2197         if (gp->opened) {
2198 #ifdef CONFIG_ALL_PPC
2199                 /* First, we need to bring up the chip */
2200                 if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE) {
2201                         gem_apple_powerup(gp);
2202                         gem_check_invariants(gp);
2203                 }
2204 #endif /* CONFIG_ALL_PPC */
2205                 spin_lock_irq(&gp->lock);
2206
2207                 gem_stop(gp);
2208                 gp->hw_running = 1;
2209                 gem_init_rings(gp);
2210                 gem_init_hw(gp, 1);
2211
2212                 spin_unlock_irq(&gp->lock);
2213
2214                 netif_device_attach(dev);
2215                 if (gp->pdev->vendor == PCI_VENDOR_ID_APPLE)
2216                         enable_irq(gp->pdev->irq);
2217         }
2218         up(&gp->pm_sem);
2219
2220         return 0;
2221 }
2222 #endif /* CONFIG_PM */
2223
2224 static struct net_device_stats *gem_get_stats(struct net_device *dev)
2225 {
2226         struct gem *gp = dev->priv;
2227         struct net_device_stats *stats = &gp->net_stats;
2228
2229         spin_lock_irq(&gp->lock);
2230
2231         if (gp->hw_running) {
2232                 stats->rx_crc_errors += readl(gp->regs + MAC_FCSERR);
2233                 writel(0, gp->regs + MAC_FCSERR);
2234
2235                 stats->rx_frame_errors += readl(gp->regs + MAC_AERR);
2236                 writel(0, gp->regs + MAC_AERR);
2237
2238                 stats->rx_length_errors += readl(gp->regs + MAC_LERR);
2239                 writel(0, gp->regs + MAC_LERR);
2240
2241                 stats->tx_aborted_errors += readl(gp->regs + MAC_ECOLL);
2242                 stats->collisions +=
2243                         (readl(gp->regs + MAC_ECOLL) +
2244                          readl(gp->regs + MAC_LCOLL));
2245                 writel(0, gp->regs + MAC_ECOLL);
2246                 writel(0, gp->regs + MAC_LCOLL);
2247         }
2248
2249         spin_unlock_irq(&gp->lock);
2250
2251         return &gp->net_stats;
2252 }
2253
2254 static void gem_set_multicast(struct net_device *dev)
2255 {
2256         struct gem *gp = dev->priv;
2257         u32 rxcfg, rxcfg_new;
2258         int limit = 10000;
2259
2260         if (!gp->hw_running)
2261                 return;
2262
2263         spin_lock_irq(&gp->lock);
2264
2265         netif_stop_queue(dev);
2266
2267         rxcfg = readl(gp->regs + MAC_RXCFG);
2268         gp->mac_rx_cfg = rxcfg_new = gem_setup_multicast(gp);
2269
2270         writel(rxcfg & ~MAC_RXCFG_ENAB, gp->regs + MAC_RXCFG);
2271         while (readl(gp->regs + MAC_RXCFG) & MAC_RXCFG_ENAB) {
2272                 if (!limit--)
2273                         break;
2274                 udelay(10);
2275         }
2276
2277         rxcfg &= ~(MAC_RXCFG_PROM | MAC_RXCFG_HFE);
2278         rxcfg |= rxcfg_new;
2279
2280         writel(rxcfg, gp->regs + MAC_RXCFG);
2281
2282         netif_wake_queue(dev);
2283
2284         spin_unlock_irq(&gp->lock);
2285 }
2286
2287 /* Eventually add support for changing the advertisement
2288  * on autoneg.
2289  */
2290 static int gem_ethtool_ioctl(struct net_device *dev, void *ep_user)
2291 {
2292         struct gem *gp = dev->priv;
2293         struct ethtool_cmd ecmd;
2294
2295         if (copy_from_user(&ecmd, ep_user, sizeof(ecmd)))
2296                 return -EFAULT;
2297
2298         switch(ecmd.cmd) {
2299         case ETHTOOL_GDRVINFO: {
2300                 struct ethtool_drvinfo info = { cmd: ETHTOOL_GDRVINFO };
2301
2302                 strncpy(info.driver, DRV_NAME, ETHTOOL_BUSINFO_LEN);
2303                 strncpy(info.version, DRV_VERSION, ETHTOOL_BUSINFO_LEN);
2304                 info.fw_version[0] = '\0';
2305                 strncpy(info.bus_info, gp->pdev->slot_name, ETHTOOL_BUSINFO_LEN);
2306                 info.regdump_len = 0; /*SUNGEM_NREGS;*/
2307
2308                 if (copy_to_user(ep_user, &info, sizeof(info)))
2309                         return -EFAULT;
2310
2311                 return 0;
2312         }
2313
2314         case ETHTOOL_GSET:
2315                 if (gp->phy_type == phy_mii_mdio0 ||
2316                     gp->phy_type == phy_mii_mdio1) {
2317                         if (gp->phy_mii.def)
2318                                 ecmd.supported = gp->phy_mii.def->features;
2319                         else
2320                                 ecmd.supported = SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full;
2321
2322                         /* XXX hardcoded stuff for now */
2323                         ecmd.port = PORT_MII;
2324                         ecmd.transceiver = XCVR_EXTERNAL;
2325                         ecmd.phy_address = 0; /* XXX fixed PHYAD */
2326
2327                         /* Record PHY settings if HW is on. */
2328                         spin_lock_irq(&gp->lock);
2329                         ecmd.autoneg = gp->want_autoneg;
2330                         ecmd.speed = gp->phy_mii.speed;
2331                         ecmd.duplex = gp->phy_mii.duplex;
2332                         spin_unlock_irq(&gp->lock);
2333                 } else { // XXX PCS ?
2334                     ecmd.supported =
2335                         (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
2336                          SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
2337                          SUPPORTED_Autoneg);
2338                 }
2339                 if (copy_to_user(ep_user, &ecmd, sizeof(ecmd)))
2340                         return -EFAULT;
2341                 return 0;
2342
2343         case ETHTOOL_SSET:
2344                 if (!capable(CAP_NET_ADMIN))
2345                         return -EPERM;
2346
2347                 /* Verify the settings we care about. */
2348                 if (ecmd.autoneg != AUTONEG_ENABLE &&
2349                     ecmd.autoneg != AUTONEG_DISABLE)
2350                         return -EINVAL;
2351
2352                 if (ecmd.autoneg == AUTONEG_ENABLE &&
2353                     ecmd.advertising == 0)
2354                         return -EINVAL;
2355
2356                 if (ecmd.autoneg == AUTONEG_DISABLE &&
2357                     ((ecmd.speed != SPEED_1000 &&
2358                       ecmd.speed != SPEED_100 &&
2359                       ecmd.speed != SPEED_10) ||
2360                      (ecmd.duplex != DUPLEX_HALF &&
2361                       ecmd.duplex != DUPLEX_FULL)))
2362                         return -EINVAL;
2363
2364                 if (ecmd.autoneg == AUTONEG_DISABLE &&
2365                       ecmd.speed == SPEED_1000 &&
2366                       gp->gigabit_capable == 0)
2367                         return -EINVAL;
2368
2369                 /* Apply settings and restart link process. */
2370                 spin_lock_irq(&gp->lock);
2371                 gem_begin_auto_negotiation(gp, &ecmd);
2372                 spin_unlock_irq(&gp->lock);
2373
2374                 return 0;
2375
2376         case ETHTOOL_NWAY_RST:
2377                 if (!gp->want_autoneg)
2378                         return -EINVAL;
2379
2380                 /* Restart link process. */
2381                 spin_lock_irq(&gp->lock);
2382                 gem_begin_auto_negotiation(gp, NULL);
2383                 spin_unlock_irq(&gp->lock);
2384
2385                 return 0;
2386
2387         case ETHTOOL_GWOL:
2388         case ETHTOOL_SWOL:
2389                 break; /* todo */
2390
2391         /* get link status */
2392         case ETHTOOL_GLINK: {
2393                 struct ethtool_value edata = { cmd: ETHTOOL_GLINK };
2394
2395                 edata.data = (gp->lstate == link_up);
2396                 if (copy_to_user(ep_user, &edata, sizeof(edata)))
2397                         return -EFAULT;
2398                 return 0;
2399         }
2400
2401         /* get message-level */
2402         case ETHTOOL_GMSGLVL: {
2403                 struct ethtool_value edata = { cmd: ETHTOOL_GMSGLVL };
2404
2405                 edata.data = gp->msg_enable;
2406                 if (copy_to_user(ep_user, &edata, sizeof(edata)))
2407                         return -EFAULT;
2408                 return 0;
2409         }
2410
2411         /* set message-level */
2412         case ETHTOOL_SMSGLVL: {
2413                 struct ethtool_value edata;
2414
2415                 if (copy_from_user(&edata, ep_user, sizeof(edata)))
2416                         return -EFAULT;
2417                 gp->msg_enable = edata.data;
2418                 return 0;
2419         }
2420
2421 #if 0
2422         case ETHTOOL_GREGS: {
2423                 struct ethtool_regs regs;
2424                 u32 *regbuf;
2425                 int r = 0;
2426
2427                 if (copy_from_user(&regs, useraddr, sizeof(regs)))
2428                         return -EFAULT;
2429
2430                 if (regs.len > SUNGEM_NREGS) {
2431                         regs.len = SUNGEM_NREGS;
2432                 }
2433                 regs.version = 0;
2434                 if (copy_to_user(useraddr, &regs, sizeof(regs)))
2435                         return -EFAULT;
2436
2437                 if (!gp->hw_running)
2438                         return -ENODEV;
2439                 useraddr += offsetof(struct ethtool_regs, data);
2440
2441                 /* Use kmalloc to avoid bloating the stack */
2442                 regbuf = kmalloc(4 * SUNGEM_NREGS, GFP_KERNEL);
2443                 if (!regbuf)
2444                         return -ENOMEM;
2445                 spin_lock_irq(&np->lock);
2446                 gem_get_regs(gp, regbuf);
2447                 spin_unlock_irq(&np->lock);
2448
2449                 if (copy_to_user(useraddr, regbuf, regs.len*sizeof(u32)))
2450                         r = -EFAULT;
2451                 kfree(regbuf);
2452                 return r;
2453         }
2454 #endif
2455         };
2456
2457         return -EOPNOTSUPP;
2458 }
2459
2460 static int gem_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2461 {
2462         struct gem *gp = dev->priv;
2463         struct mii_ioctl_data *data = (struct mii_ioctl_data *)&ifr->ifr_data;
2464         int rc = -EOPNOTSUPP;
2465
2466         /* Hold the PM semaphore while doing ioctl's or we may collide
2467          * with open/close and power management and oops.
2468          */
2469         down(&gp->pm_sem);
2470
2471         switch (cmd) {
2472         case SIOCETHTOOL:
2473                 rc = gem_ethtool_ioctl(dev, ifr->ifr_data);
2474                 break;
2475
2476         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
2477                 data->phy_id = gp->mii_phy_addr;
2478                 /* Fallthrough... */
2479
2480         case SIOCGMIIREG:               /* Read MII PHY register. */
2481                 if (!gp->hw_running)
2482                         rc = -EIO;
2483                 else {
2484                         data->val_out = __phy_read(gp, data->phy_id & 0x1f, data->reg_num & 0x1f);
2485                         rc = 0;
2486                 }
2487                 break;
2488
2489         case SIOCSMIIREG:               /* Write MII PHY register. */
2490                 if (!capable(CAP_NET_ADMIN))
2491                         rc = -EPERM;
2492                 else if (!gp->hw_running)
2493                         rc = -EIO;
2494                 else {
2495                         __phy_write(gp, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
2496                         rc = 0;
2497                 }
2498                 break;
2499         };
2500
2501         up(&gp->pm_sem);
2502
2503         return rc;
2504 }
2505
2506 #if (!defined(__sparc__) && !defined(CONFIG_ALL_PPC))
2507 /* Fetch MAC address from vital product data of PCI ROM. */
2508 static void find_eth_addr_in_vpd(void *rom_base, int len, unsigned char *dev_addr)
2509 {
2510         int this_offset;
2511
2512         for (this_offset = 0x20; this_offset < len; this_offset++) {
2513                 void *p = rom_base + this_offset;
2514                 int i;
2515
2516                 if (readb(p + 0) != 0x90 ||
2517                     readb(p + 1) != 0x00 ||
2518                     readb(p + 2) != 0x09 ||
2519                     readb(p + 3) != 0x4e ||
2520                     readb(p + 4) != 0x41 ||
2521                     readb(p + 5) != 0x06)
2522                         continue;
2523
2524                 this_offset += 6;
2525                 p += 6;
2526
2527                 for (i = 0; i < 6; i++)
2528                         dev_addr[i] = readb(p + i);
2529                 break;
2530         }
2531 }
2532
2533 static void get_gem_mac_nonobp(struct pci_dev *pdev, unsigned char *dev_addr)
2534 {
2535         u32 rom_reg_orig;
2536         void *p;
2537
2538         if (pdev->resource[PCI_ROM_RESOURCE].parent == NULL) {
2539                 if (pci_assign_resource(pdev, PCI_ROM_RESOURCE) < 0)
2540                         goto use_random;
2541         }
2542
2543         pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_reg_orig);
2544         pci_write_config_dword(pdev, pdev->rom_base_reg,
2545                                rom_reg_orig | PCI_ROM_ADDRESS_ENABLE);
2546
2547         p = ioremap(pci_resource_start(pdev, PCI_ROM_RESOURCE), (64 * 1024));
2548         if (p != NULL && readb(p) == 0x55 && readb(p + 1) == 0xaa)
2549                 find_eth_addr_in_vpd(p, (64 * 1024), dev_addr);
2550
2551         if (p != NULL)
2552                 iounmap(p);
2553
2554         pci_write_config_dword(pdev, pdev->rom_base_reg, rom_reg_orig);
2555         return;
2556
2557 use_random:
2558         /* Sun MAC prefix then 3 random bytes. */
2559         dev_addr[0] = 0x08;
2560         dev_addr[1] = 0x00;
2561         dev_addr[2] = 0x20;
2562         get_random_bytes(dev_addr + 3, 3);
2563         return;
2564 }
2565 #endif /* not Sparc and not PPC */
2566
2567 static int __devinit gem_get_device_address(struct gem *gp)
2568 {
2569 #if defined(__sparc__) || defined(CONFIG_ALL_PPC)
2570         struct net_device *dev = gp->dev;
2571 #endif
2572
2573 #if defined(__sparc__)
2574         struct pci_dev *pdev = gp->pdev;
2575         struct pcidev_cookie *pcp = pdev->sysdata;
2576         int node = -1;
2577
2578         if (pcp != NULL) {
2579                 node = pcp->prom_node;
2580                 if (prom_getproplen(node, "local-mac-address") == 6)
2581                         prom_getproperty(node, "local-mac-address",
2582                                          dev->dev_addr, 6);
2583                 else
2584                         node = -1;
2585         }
2586         if (node == -1)
2587                 memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
2588 #elif defined(CONFIG_ALL_PPC)
2589         unsigned char *addr;
2590
2591         addr = get_property(gp->of_node, "local-mac-address", NULL);
2592         if (addr == NULL) {
2593                 printk("\n");
2594                 printk(KERN_ERR "%s: can't get mac-address\n", dev->name);
2595                 return -1;
2596         }
2597         memcpy(dev->dev_addr, addr, MAX_ADDR_LEN);
2598 #else
2599         get_gem_mac_nonobp(gp->pdev, gp->dev->dev_addr);
2600 #endif
2601         return 0;
2602 }
2603
2604 static int __devinit gem_init_one(struct pci_dev *pdev,
2605                                   const struct pci_device_id *ent)
2606 {
2607         static int gem_version_printed = 0;
2608         unsigned long gemreg_base, gemreg_len;
2609         struct net_device *dev;
2610         struct gem *gp;
2611         int i, err, pci_using_dac;
2612
2613         if (gem_version_printed++ == 0)
2614                 printk(KERN_INFO "%s", version);
2615
2616         /* Apple gmac note: during probe, the chip is powered up by
2617          * the arch code to allow the code below to work (and to let
2618          * the chip be probed on the config space. It won't stay powered
2619          * up until the interface is brought up however, so we can't rely
2620          * on register configuration done at this point.
2621          */
2622         err = pci_enable_device(pdev);
2623         if (err) {
2624                 printk(KERN_ERR PFX "Cannot enable MMIO operation, "
2625                        "aborting.\n");
2626                 return err;
2627         }
2628         pci_set_master(pdev);
2629
2630         /* Configure DMA attributes. */
2631
2632         /* All of the GEM documentation states that 64-bit DMA addressing
2633          * is fully supported and should work just fine.  However the
2634          * front end for RIO based GEMs is different and only supports
2635          * 32-bit addressing.
2636          *
2637          * For now we assume the various PPC GEMs are 32-bit only as well.
2638          */
2639         if (pdev->vendor == PCI_VENDOR_ID_SUN &&
2640             pdev->device == PCI_DEVICE_ID_SUN_GEM &&
2641             !pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff)) {
2642                 pci_using_dac = 1;
2643         } else {
2644                 err = pci_set_dma_mask(pdev, (u64) 0xffffffff);
2645                 if (err) {
2646                         printk(KERN_ERR PFX "No usable DMA configuration, "
2647                                "aborting.\n");
2648                         return err;
2649                 }
2650                 pci_using_dac = 0;
2651         }
2652
2653         gemreg_base = pci_resource_start(pdev, 0);
2654         gemreg_len = pci_resource_len(pdev, 0);
2655
2656         if ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) != 0) {
2657                 printk(KERN_ERR PFX "Cannot find proper PCI device "
2658                        "base address, aborting.\n");
2659                 return -ENODEV;
2660         }
2661
2662         dev = alloc_etherdev(sizeof(*gp));
2663         if (!dev) {
2664                 printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
2665                 return -ENOMEM;
2666         }
2667         SET_MODULE_OWNER(dev);
2668
2669         gp = dev->priv;
2670
2671         if (pci_request_regions(pdev, dev->name)) {
2672                 printk(KERN_ERR PFX "Cannot obtain PCI resources, "
2673                        "aborting.\n");
2674                 goto err_out_free_netdev;
2675         }
2676
2677         gp->pdev = pdev;
2678         dev->base_addr = (long) pdev;
2679         gp->dev = dev;
2680
2681         gp->msg_enable = (gem_debug < 0 ? DEFAULT_MSG : gem_debug);
2682
2683         spin_lock_init(&gp->lock);
2684         init_MUTEX(&gp->pm_sem);
2685
2686         init_timer(&gp->link_timer);
2687         gp->link_timer.function = gem_link_timer;
2688         gp->link_timer.data = (unsigned long) gp;
2689
2690         init_timer(&gp->pm_timer);
2691         gp->pm_timer.function = gem_pm_timer;
2692         gp->pm_timer.data = (unsigned long) gp;
2693
2694         INIT_TQUEUE(&gp->pm_task, gem_pm_task, gp);
2695         INIT_TQUEUE(&gp->reset_task, gem_reset_task, gp);
2696
2697         gp->lstate = link_down;
2698         gp->timer_ticks = 0;
2699         netif_carrier_off(dev);
2700
2701         gp->regs = (unsigned long) ioremap(gemreg_base, gemreg_len);
2702         if (gp->regs == 0UL) {
2703                 printk(KERN_ERR PFX "Cannot map device registers, "
2704                        "aborting.\n");
2705                 goto err_out_free_res;
2706         }
2707
2708         /* On Apple, we power the chip up now in order for check
2709          * invariants to work, but also because the firmware might
2710          * not have properly shut down the PHY.
2711          */
2712 #ifdef CONFIG_ALL_PPC
2713         gp->of_node = pci_device_to_OF_node(pdev);
2714         if (pdev->vendor == PCI_VENDOR_ID_APPLE)
2715                 gem_apple_powerup(gp);
2716 #endif
2717         spin_lock_irq(&gp->lock);
2718         gem_stop(gp);
2719         spin_unlock_irq(&gp->lock);
2720
2721         /* Fill up the mii_phy structure (even if we won't use it) */
2722         gp->phy_mii.dev = dev;
2723         gp->phy_mii.mdio_read = _phy_read;
2724         gp->phy_mii.mdio_write = _phy_write;
2725
2726         /* Default link parameters */
2727         if (forced_speed != -1 &&
2728             forced_speed != SPEED_10 &&
2729             forced_speed != SPEED_100 &&
2730             forced_speed != SPEED_1000) {
2731                 forced_speed = -1;
2732                 printk(KERN_WARNING "forced_speed argument invalid, reverting to autoneg\n");
2733         }
2734         if (forced_speed < SPEED_10)
2735                 gp->want_autoneg = 1;
2736         else {
2737                 gp->want_autoneg = 0;
2738                 gp->phy_mii.speed = forced_speed;
2739                 if (forced_duplex > 0)
2740                         gp->phy_mii.duplex = DUPLEX_FULL;
2741                 else
2742                         gp->phy_mii.duplex = DUPLEX_HALF;
2743         }
2744
2745         if (gem_check_invariants(gp))
2746                 goto err_out_iounmap;
2747
2748         /* It is guarenteed that the returned buffer will be at least
2749          * PAGE_SIZE aligned.
2750          */
2751         gp->init_block = (struct gem_init_block *)
2752                 pci_alloc_consistent(pdev, sizeof(struct gem_init_block),
2753                                      &gp->gblock_dvma);
2754         if (!gp->init_block) {
2755                 printk(KERN_ERR PFX "Cannot allocate init block, "
2756                        "aborting.\n");
2757                 goto err_out_iounmap;
2758         }
2759
2760         if (gem_get_device_address(gp))
2761                 goto err_out_free_consistent;
2762
2763         if (register_netdev(dev)) {
2764                 printk(KERN_ERR PFX "Cannot register net device, "
2765                        "aborting.\n");
2766                 goto err_out_free_consistent;
2767         }
2768
2769         printk(KERN_INFO "%s: Sun GEM (PCI) 10/100/1000BaseT Ethernet ",
2770                dev->name);
2771         for (i = 0; i < 6; i++)
2772                 printk("%2.2x%c", dev->dev_addr[i],
2773                        i == 5 ? ' ' : ':');
2774         printk("\n");
2775
2776         /* Detect & init PHY, start autoneg */
2777         spin_lock_irq(&gp->lock);
2778         gp->hw_running = 1;
2779         gem_init_phy(gp);
2780         gem_begin_auto_negotiation(gp, NULL);
2781         spin_unlock_irq(&gp->lock);
2782
2783         if (gp->phy_type == phy_mii_mdio0 ||
2784             gp->phy_type == phy_mii_mdio1)
2785                 printk(KERN_INFO "%s: Found %s PHY\n", dev->name,
2786                         gp->phy_mii.def ? gp->phy_mii.def->name : "no");
2787
2788         pci_set_drvdata(pdev, dev);
2789
2790         dev->open = gem_open;
2791         dev->stop = gem_close;
2792         dev->hard_start_xmit = gem_start_xmit;
2793         dev->get_stats = gem_get_stats;
2794         dev->set_multicast_list = gem_set_multicast;
2795         dev->do_ioctl = gem_ioctl;
2796         dev->tx_timeout = gem_tx_timeout;
2797         dev->watchdog_timeo = 5 * HZ;
2798         dev->change_mtu = gem_change_mtu;
2799         dev->irq = pdev->irq;
2800         dev->dma = 0;
2801
2802         /* GEM can do it all... */
2803         dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2804         if (pci_using_dac)
2805                 dev->features |= NETIF_F_HIGHDMA;
2806
2807         /* Fire the PM timer that will shut us down in about 10 seconds */
2808         gp->pm_timer.expires = jiffies + 10*HZ;
2809         add_timer(&gp->pm_timer);
2810
2811         return 0;
2812
2813 err_out_free_consistent:
2814         pci_free_consistent(pdev,
2815                             sizeof(struct gem_init_block),
2816                             gp->init_block,
2817                             gp->gblock_dvma);
2818
2819 err_out_iounmap:
2820         down(&gp->pm_sem);
2821         /* Stop the PM timer & task */
2822         del_timer_sync(&gp->pm_timer);
2823         flush_scheduled_tasks();
2824         if (gp->hw_running)
2825                 gem_shutdown(gp);
2826         up(&gp->pm_sem);
2827
2828         iounmap((void *) gp->regs);
2829
2830 err_out_free_res:
2831         pci_release_regions(pdev);
2832
2833 err_out_free_netdev:
2834         kfree(dev);
2835
2836         return -ENODEV;
2837
2838 }
2839
2840 static void __devexit gem_remove_one(struct pci_dev *pdev)
2841 {
2842         struct net_device *dev = pci_get_drvdata(pdev);
2843
2844         if (dev) {
2845                 struct gem *gp = dev->priv;
2846
2847                 unregister_netdev(dev);
2848
2849                 down(&gp->pm_sem);
2850                 /* Stop the PM timer & task */
2851                 del_timer_sync(&gp->pm_timer);
2852                 flush_scheduled_tasks();
2853                 if (gp->hw_running)
2854                         gem_shutdown(gp);
2855                 up(&gp->pm_sem);
2856
2857                 pci_free_consistent(pdev,
2858                                     sizeof(struct gem_init_block),
2859                                     gp->init_block,
2860                                     gp->gblock_dvma);
2861                 iounmap((void *) gp->regs);
2862                 pci_release_regions(pdev);
2863                 kfree(dev);
2864
2865                 pci_set_drvdata(pdev, NULL);
2866         }
2867 }
2868
2869 static struct pci_driver gem_driver = {
2870         name:           GEM_MODULE_NAME,
2871         id_table:       gem_pci_tbl,
2872         probe:          gem_init_one,
2873         remove:         __devexit_p(gem_remove_one),
2874 #ifdef CONFIG_PM
2875         suspend:        gem_suspend,
2876         resume:         gem_resume,
2877 #endif /* CONFIG_PM */
2878 };
2879
2880 static int __init gem_init(void)
2881 {
2882         return pci_module_init(&gem_driver);
2883 }
2884
2885 static void __exit gem_cleanup(void)
2886 {
2887         pci_unregister_driver(&gem_driver);
2888 }
2889
2890 module_init(gem_init);
2891 module_exit(gem_cleanup);