src/drivers/net/skge.c

   1 /*
   2  * gPXE driver for Marvell Yukon chipset and SysKonnect Gigabit
   3  * Ethernet adapters. Derived from Linux skge driver (v1.13), which was
   4  * based on earlier sk98lin, e100 and FreeBSD if_sk drivers.
   5  *
   6  * This driver intentionally does not support all the features
   7  * of the original driver such as link fail-over and link management because
   8  * those should be done at higher levels.
   9  *
  10  * Copyright (C) 2004, 2005 Stephen Hemminger <shemminger@osdl.org>
  11  *
  12  * Modified for gPXE, July 2008 by Michael Decker and in
  13  * December 2009 by Thomas Miletich <thomas.miletich@gmail.com>
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27  */
  28
  29 FILE_LICENCE ( GPL2_ONLY );
  30
  31 #include <stdint.h>
  32 #include <errno.h>
  33 #include <stdio.h>
  34 #include <unistd.h>
  35 #include <gpxe/netdevice.h>
  36 #include <gpxe/ethernet.h>
  37 #include <gpxe/if_ether.h>
  38 #include <gpxe/iobuf.h>
  39 #include <gpxe/malloc.h>
  40 #include <gpxe/pci.h>
  41
  42 #include "skge.h"
  43
  44 static struct pci_device_id skge_id_table[] = {
  45         PCI_ROM(0x10b7, 0x1700,     "3C940",     "3COM 3C940", 0),
  46         PCI_ROM(0x10b7, 0x80eb,     "3C940B",    "3COM 3C940", 0),
  47         PCI_ROM(0x1148, 0x4300,     "GE",        "Syskonnect GE", 0),
  48         PCI_ROM(0x1148, 0x4320,     "YU",        "Syskonnect YU", 0),
  49         PCI_ROM(0x1186, 0x4C00,     "DGE510T",   "DLink DGE-510T", 0),
  50         PCI_ROM(0x1186, 0x4b01,     "DGE530T",   "DLink DGE-530T", 0),
  51         PCI_ROM(0x11ab, 0x4320,     "id4320",    "Marvell id4320", 0),
  52         PCI_ROM(0x11ab, 0x5005,     "id5005",    "Marvell id5005", 0), /* Belkin */
  53         PCI_ROM(0x1371, 0x434e,     "Gigacard",  "CNET Gigacard", 0),
  54         PCI_ROM(0x1737, 0x1064,     "EG1064",    "Linksys EG1064", 0),
  55         PCI_ROM(0x1737, 0xffff,     "id_any",    "Linksys [any]", 0)
  56 };
  57
  58 static int skge_up(struct net_device *dev);
  59 static void skge_down(struct net_device *dev);
  60 static void skge_tx_clean(struct net_device *dev);
  61 static int xm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val);
  62 static int gm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val);
  63 static void yukon_init(struct skge_hw *hw, int port);
  64 static void genesis_mac_init(struct skge_hw *hw, int port);
  65 static void genesis_link_up(struct skge_port *skge);
  66
  67 static void skge_phyirq(struct skge_hw *hw);
  68 static void skge_poll(struct net_device *dev);
  69 static int skge_xmit_frame(struct net_device *dev, struct io_buffer *iob);
  70 static void skge_net_irq ( struct net_device *dev, int enable );
  71
  72 static void skge_rx_refill(struct net_device *dev);
  73
  74 static struct net_device_operations skge_operations = {
  75         .open     = skge_up,
  76         .close    = skge_down,
  77         .transmit = skge_xmit_frame,
  78         .poll     = skge_poll,
  79         .irq      = skge_net_irq
  80 };
  81
  82 /* Avoid conditionals by using array */
  83 static const int txqaddr[] = { Q_XA1, Q_XA2 };
  84 static const int rxqaddr[] = { Q_R1, Q_R2 };
  85 static const u32 rxirqmask[] = { IS_R1_F, IS_R2_F };
  86 static const u32 txirqmask[] = { IS_XA1_F, IS_XA2_F };
  87 static const u32 napimask[] = { IS_R1_F|IS_XA1_F, IS_R2_F|IS_XA2_F };
  88 static const u32 portmask[] = { IS_PORT_1, IS_PORT_2 };
  89
  90 /* Determine supported/advertised modes based on hardware.
  91  * Note: ethtool ADVERTISED_xxx == SUPPORTED_xxx
  92  */
  93 static u32 skge_supported_modes(const struct skge_hw *hw)
  94 {
  95         u32 supported;
  96
  97         if (hw->copper) {
  98                 supported = SUPPORTED_10baseT_Half
  99                         | SUPPORTED_10baseT_Full
 100                         | SUPPORTED_100baseT_Half
 101                         | SUPPORTED_100baseT_Full
 102                         | SUPPORTED_1000baseT_Half
 103                         | SUPPORTED_1000baseT_Full
 104                         | SUPPORTED_Autoneg| SUPPORTED_TP;
 105
 106                 if (hw->chip_id == CHIP_ID_GENESIS)
 107                         supported &= ~(SUPPORTED_10baseT_Half
 108                                              | SUPPORTED_10baseT_Full
 109                                              | SUPPORTED_100baseT_Half
 110                                              | SUPPORTED_100baseT_Full);
 111
 112                 else if (hw->chip_id == CHIP_ID_YUKON)
 113                         supported &= ~SUPPORTED_1000baseT_Half;
 114         } else
 115                 supported = SUPPORTED_1000baseT_Full | SUPPORTED_1000baseT_Half
 116                         | SUPPORTED_FIBRE | SUPPORTED_Autoneg;
 117
 118         return supported;
 119 }
 120
 121 /* Chip internal frequency for clock calculations */
 122 static inline u32 hwkhz(const struct skge_hw *hw)
 123 {
 124         return (hw->chip_id == CHIP_ID_GENESIS) ? 53125 : 78125;
 125 }
 126
 127 /* Microseconds to chip HZ */
 128 static inline u32 skge_usecs2clk(const struct skge_hw *hw, u32 usec)
 129 {
 130         return hwkhz(hw) * usec / 1000;
 131 }
 132
 133 enum led_mode { LED_MODE_OFF, LED_MODE_ON, LED_MODE_TST };
 134 static void skge_led(struct skge_port *skge, enum led_mode mode)
 135 {
 136         struct skge_hw *hw = skge->hw;
 137         int port = skge->port;
 138
 139         if (hw->chip_id == CHIP_ID_GENESIS) {
 140                 switch (mode) {
 141                 case LED_MODE_OFF:
 142                         if (hw->phy_type == SK_PHY_BCOM)
 143                                 xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_OFF);
 144                         else {
 145                                 skge_write32(hw, SK_REG(port, TX_LED_VAL), 0);
 146                                 skge_write8(hw, SK_REG(port, TX_LED_CTRL), LED_T_OFF);
 147                         }
 148                         skge_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_OFF);
 149                         skge_write32(hw, SK_REG(port, RX_LED_VAL), 0);
 150                         skge_write8(hw, SK_REG(port, RX_LED_CTRL), LED_T_OFF);
 151                         break;
 152
 153                 case LED_MODE_ON:
 154                         skge_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_ON);
 155                         skge_write8(hw, SK_REG(port, LNK_LED_REG), LINKLED_LINKSYNC_ON);
 156
 157                         skge_write8(hw, SK_REG(port, RX_LED_CTRL), LED_START);
 158                         skge_write8(hw, SK_REG(port, TX_LED_CTRL), LED_START);
 159
 160                         break;
 161
 162                 case LED_MODE_TST:
 163                         skge_write8(hw, SK_REG(port, RX_LED_TST), LED_T_ON);
 164                         skge_write32(hw, SK_REG(port, RX_LED_VAL), 100);
 165                         skge_write8(hw, SK_REG(port, RX_LED_CTRL), LED_START);
 166
 167                         if (hw->phy_type == SK_PHY_BCOM)
 168                                 xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, PHY_B_PEC_LED_ON);
 169                         else {
 170                                 skge_write8(hw, SK_REG(port, TX_LED_TST), LED_T_ON);
 171                                 skge_write32(hw, SK_REG(port, TX_LED_VAL), 100);
 172                                 skge_write8(hw, SK_REG(port, TX_LED_CTRL), LED_START);
 173                         }
 174
 175                 }
 176         } else {
 177                 switch (mode) {
 178                 case LED_MODE_OFF:
 179                         gm_phy_write(hw, port, PHY_MARV_LED_CTRL, 0);
 180                         gm_phy_write(hw, port, PHY_MARV_LED_OVER,
 181                                      PHY_M_LED_MO_DUP(MO_LED_OFF)  |
 182                                      PHY_M_LED_MO_10(MO_LED_OFF)   |
 183                                      PHY_M_LED_MO_100(MO_LED_OFF)  |
 184                                      PHY_M_LED_MO_1000(MO_LED_OFF) |
 185                                      PHY_M_LED_MO_RX(MO_LED_OFF));
 186                         break;
 187                 case LED_MODE_ON:
 188                         gm_phy_write(hw, port, PHY_MARV_LED_CTRL,
 189                                      PHY_M_LED_PULS_DUR(PULS_170MS) |
 190                                      PHY_M_LED_BLINK_RT(BLINK_84MS) |
 191                                      PHY_M_LEDC_TX_CTRL |
 192                                      PHY_M_LEDC_DP_CTRL);
 193
 194                         gm_phy_write(hw, port, PHY_MARV_LED_OVER,
 195                                      PHY_M_LED_MO_RX(MO_LED_OFF) |
 196                                      (skge->speed == SPEED_100 ?
 197                                       PHY_M_LED_MO_100(MO_LED_ON) : 0));
 198                         break;
 199                 case LED_MODE_TST:
 200                         gm_phy_write(hw, port, PHY_MARV_LED_CTRL, 0);
 201                         gm_phy_write(hw, port, PHY_MARV_LED_OVER,
 202                                      PHY_M_LED_MO_DUP(MO_LED_ON)  |
 203                                      PHY_M_LED_MO_10(MO_LED_ON)   |
 204                                      PHY_M_LED_MO_100(MO_LED_ON)  |
 205                                      PHY_M_LED_MO_1000(MO_LED_ON) |
 206                                      PHY_M_LED_MO_RX(MO_LED_ON));
 207                 }
 208         }
 209 }
 210
 211 /*
 212  * I've left in these EEPROM and VPD functions, as someone may desire to
 213  * integrate them in the future. -mdeck
 214  *
 215  * static int skge_get_eeprom_len(struct net_device *dev)
 216  * {
 217  *      struct skge_port *skge = netdev_priv(dev);
 218  *      u32 reg2;
 219  *
 220  *      pci_read_config_dword(skge->hw->pdev, PCI_DEV_REG2, &reg2);
 221  *      return 1 << ( ((reg2 & PCI_VPD_ROM_SZ) >> 14) + 8);
 222  * }
 223  *
 224  * static u32 skge_vpd_read(struct pci_dev *pdev, int cap, u16 offset)
 225  * {
 226  *      u32 val;
 227  *
 228  *      pci_write_config_word(pdev, cap + PCI_VPD_ADDR, offset);
 229  *
 230  *      do {
 231  *              pci_read_config_word(pdev, cap + PCI_VPD_ADDR, &offset);
 232  *      } while (!(offset & PCI_VPD_ADDR_F));
 233  *
 234  *      pci_read_config_dword(pdev, cap + PCI_VPD_DATA, &val);
 235  *      return val;
 236  * }
 237  *
 238  * static void skge_vpd_write(struct pci_dev *pdev, int cap, u16 offset, u32 val)
 239  * {
 240  *      pci_write_config_dword(pdev, cap + PCI_VPD_DATA, val);
 241  *      pci_write_config_word(pdev, cap + PCI_VPD_ADDR,
 242  *                            offset | PCI_VPD_ADDR_F);
 243  *
 244  *      do {
 245  *              pci_read_config_word(pdev, cap + PCI_VPD_ADDR, &offset);
 246  *      } while (offset & PCI_VPD_ADDR_F);
 247  * }
 248  *
 249  * static int skge_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 250  *                         u8 *data)
 251  * {
 252  *      struct skge_port *skge = netdev_priv(dev);
 253  *      struct pci_dev *pdev = skge->hw->pdev;
 254  *      int cap = pci_find_capability(pdev, PCI_CAP_ID_VPD);
 255  *      int length = eeprom->len;
 256  *      u16 offset = eeprom->offset;
 257  *
 258  *      if (!cap)
 259  *              return -EINVAL;
 260  *
 261  *      eeprom->magic = SKGE_EEPROM_MAGIC;
 262  *
 263  *      while (length > 0) {
 264  *              u32 val = skge_vpd_read(pdev, cap, offset);
 265  *              int n = min_t(int, length, sizeof(val));
 266  *
 267  *              memcpy(data, &val, n);
 268  *              length -= n;
 269  *              data += n;
 270  *              offset += n;
 271  *      }
 272  *      return 0;
 273  * }
 274  *
 275  * static int skge_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 276  *                         u8 *data)
 277  * {
 278  *      struct skge_port *skge = netdev_priv(dev);
 279  *      struct pci_dev *pdev = skge->hw->pdev;
 280  *      int cap = pci_find_capability(pdev, PCI_CAP_ID_VPD);
 281  *      int length = eeprom->len;
 282  *      u16 offset = eeprom->offset;
 283  *
 284  *      if (!cap)
 285  *              return -EINVAL;
 286  *
 287  *      if (eeprom->magic != SKGE_EEPROM_MAGIC)
 288  *              return -EINVAL;
 289  *
 290  *      while (length > 0) {
 291  *              u32 val;
 292  *              int n = min_t(int, length, sizeof(val));
 293  *
 294  *              if (n < sizeof(val))
 295  *                      val = skge_vpd_read(pdev, cap, offset);
 296  *              memcpy(&val, data, n);
 297  *
 298  *              skge_vpd_write(pdev, cap, offset, val);
 299  *
 300  *              length -= n;
 301  *              data += n;
 302  *              offset += n;
 303  *      }
 304  *      return 0;
 305  * }
 306  */
 307
 308 /*
 309  * Allocate ring elements and chain them together
 310  * One-to-one association of board descriptors with ring elements
 311  */
 312 static int skge_ring_alloc(struct skge_ring *ring, void *vaddr, u32 base,
 313                            size_t num)
 314 {
 315         struct skge_tx_desc *d;
 316         struct skge_element *e;
 317         unsigned int i;
 318
 319         ring->start = zalloc(num*sizeof(*e));
 320         if (!ring->start)
 321                 return -ENOMEM;
 322
 323         for (i = 0, e = ring->start, d = vaddr; i < num; i++, e++, d++) {
 324                 e->desc = d;
 325                 if (i == num - 1) {
 326                         e->next = ring->start;
 327                         d->next_offset = base;
 328                 } else {
 329                         e->next = e + 1;
 330                         d->next_offset = base + (i+1) * sizeof(*d);
 331                 }
 332         }
 333         ring->to_use = ring->to_clean = ring->start;
 334
 335         return 0;
 336 }
 337
 338 /* Allocate and setup a new buffer for receiving */
 339 static void skge_rx_setup(struct skge_port *skge __unused,
 340                           struct skge_element *e,
 341                           struct io_buffer *iob, unsigned int bufsize)
 342 {
 343         struct skge_rx_desc *rd = e->desc;
 344         u64 map;
 345
 346         map = ( iob != NULL ) ? virt_to_bus(iob->data) : 0;
 347
 348         rd->dma_lo = map;
 349         rd->dma_hi = map >> 32;
 350         e->iob = iob;
 351         rd->csum1_start = ETH_HLEN;
 352         rd->csum2_start = ETH_HLEN;
 353         rd->csum1 = 0;
 354         rd->csum2 = 0;
 355
 356         wmb();
 357
 358         rd->control = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | bufsize;
 359 }
 360
 361 /* Resume receiving using existing skb,
 362  * Note: DMA address is not changed by chip.
 363  *       MTU not changed while receiver active.
 364  */
 365 static inline void skge_rx_reuse(struct skge_element *e, unsigned int size)
 366 {
 367         struct skge_rx_desc *rd = e->desc;
 368
 369         rd->csum2 = 0;
 370         rd->csum2_start = ETH_HLEN;
 371
 372         wmb();
 373
 374         rd->control = BMU_OWN | BMU_STF | BMU_IRQ_EOF | BMU_TCP_CHECK | size;
 375 }
 376
 377
 378 /* Free all  buffers in receive ring, assumes receiver stopped */
 379 static void skge_rx_clean(struct skge_port *skge)
 380 {
 381         struct skge_ring *ring = &skge->rx_ring;
 382         struct skge_element *e;
 383
 384         e = ring->start;
 385         do {
 386                 struct skge_rx_desc *rd = e->desc;
 387                 rd->control = 0;
 388                 if (e->iob) {
 389                         free_iob(e->iob);
 390                         e->iob = NULL;
 391                 }
 392         } while ((e = e->next) != ring->start);
 393 }
 394
 395 static void skge_link_up(struct skge_port *skge)
 396 {
 397         skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG),
 398                     LED_BLK_OFF|LED_SYNC_OFF|LED_ON);
 399
 400         netdev_link_up(skge->netdev);
 401
 402         DBG2(PFX "%s: Link is up at %d Mbps, %s duplex\n",
 403              skge->netdev->name, skge->speed,
 404              skge->duplex == DUPLEX_FULL ? "full" : "half");
 405 }
 406
 407 static void skge_link_down(struct skge_port *skge)
 408 {
 409         skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_OFF);
 410         netdev_link_down(skge->netdev);
 411
 412         DBG2(PFX "%s: Link is down.\n", skge->netdev->name);
 413 }
 414
 415
 416 static void xm_link_down(struct skge_hw *hw, int port)
 417 {
 418         struct net_device *dev = hw->dev[port];
 419         struct skge_port *skge = netdev_priv(dev);
 420
 421         xm_write16(hw, port, XM_IMSK, XM_IMSK_DISABLE);
 422
 423         if (netdev_link_ok(dev))
 424                 skge_link_down(skge);
 425 }
 426
 427 static int __xm_phy_read(struct skge_hw *hw, int port, u16 reg, u16 *val)
 428 {
 429         int i;
 430
 431         xm_write16(hw, port, XM_PHY_ADDR, reg | hw->phy_addr);
 432         *val = xm_read16(hw, port, XM_PHY_DATA);
 433
 434         if (hw->phy_type == SK_PHY_XMAC)
 435                 goto ready;
 436
 437         for (i = 0; i < PHY_RETRIES; i++) {
 438                 if (xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_RDY)
 439                         goto ready;
 440                 udelay(1);
 441         }
 442
 443         return -ETIMEDOUT;
 444  ready:
 445         *val = xm_read16(hw, port, XM_PHY_DATA);
 446
 447         return 0;
 448 }
 449
 450 static u16 xm_phy_read(struct skge_hw *hw, int port, u16 reg)
 451 {
 452         u16 v = 0;
 453         if (__xm_phy_read(hw, port, reg, &v))
 454                 DBG(PFX "%s: phy read timed out\n",
 455                        hw->dev[port]->name);
 456         return v;
 457 }
 458
 459 static int xm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val)
 460 {
 461         int i;
 462
 463         xm_write16(hw, port, XM_PHY_ADDR, reg | hw->phy_addr);
 464         for (i = 0; i < PHY_RETRIES; i++) {
 465                 if (!(xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_BUSY))
 466                         goto ready;
 467                 udelay(1);
 468         }
 469         return -EIO;
 470
 471  ready:
 472         xm_write16(hw, port, XM_PHY_DATA, val);
 473         for (i = 0; i < PHY_RETRIES; i++) {
 474                 if (!(xm_read16(hw, port, XM_MMU_CMD) & XM_MMU_PHY_BUSY))
 475                         return 0;
 476                 udelay(1);
 477         }
 478         return -ETIMEDOUT;
 479 }
 480
 481 static void genesis_init(struct skge_hw *hw)
 482 {
 483         /* set blink source counter */
 484         skge_write32(hw, B2_BSC_INI, (SK_BLK_DUR * SK_FACT_53) / 100);
 485         skge_write8(hw, B2_BSC_CTRL, BSC_START);
 486
 487         /* configure mac arbiter */
 488         skge_write16(hw, B3_MA_TO_CTRL, MA_RST_CLR);
 489
 490         /* configure mac arbiter timeout values */
 491         skge_write8(hw, B3_MA_TOINI_RX1, SK_MAC_TO_53);
 492         skge_write8(hw, B3_MA_TOINI_RX2, SK_MAC_TO_53);
 493         skge_write8(hw, B3_MA_TOINI_TX1, SK_MAC_TO_53);
 494         skge_write8(hw, B3_MA_TOINI_TX2, SK_MAC_TO_53);
 495
 496         skge_write8(hw, B3_MA_RCINI_RX1, 0);
 497         skge_write8(hw, B3_MA_RCINI_RX2, 0);
 498         skge_write8(hw, B3_MA_RCINI_TX1, 0);
 499         skge_write8(hw, B3_MA_RCINI_TX2, 0);
 500
 501         /* configure packet arbiter timeout */
 502         skge_write16(hw, B3_PA_CTRL, PA_RST_CLR);
 503         skge_write16(hw, B3_PA_TOINI_RX1, SK_PKT_TO_MAX);
 504         skge_write16(hw, B3_PA_TOINI_TX1, SK_PKT_TO_MAX);
 505         skge_write16(hw, B3_PA_TOINI_RX2, SK_PKT_TO_MAX);
 506         skge_write16(hw, B3_PA_TOINI_TX2, SK_PKT_TO_MAX);
 507 }
 508
 509 static void genesis_reset(struct skge_hw *hw, int port)
 510 {
 511         const u8 zero[8]  = { 0 };
 512         u32 reg;
 513
 514         skge_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0);
 515
 516         /* reset the statistics module */
 517         xm_write32(hw, port, XM_GP_PORT, XM_GP_RES_STAT);
 518         xm_write16(hw, port, XM_IMSK, XM_IMSK_DISABLE);
 519         xm_write32(hw, port, XM_MODE, 0);               /* clear Mode Reg */
 520         xm_write16(hw, port, XM_TX_CMD, 0);     /* reset TX CMD Reg */
 521         xm_write16(hw, port, XM_RX_CMD, 0);     /* reset RX CMD Reg */
 522
 523         /* disable Broadcom PHY IRQ */
 524         if (hw->phy_type == SK_PHY_BCOM)
 525                 xm_write16(hw, port, PHY_BCOM_INT_MASK, 0xffff);
 526
 527         xm_outhash(hw, port, XM_HSM, zero);
 528
 529         /* Flush TX and RX fifo */
 530         reg = xm_read32(hw, port, XM_MODE);
 531         xm_write32(hw, port, XM_MODE, reg | XM_MD_FTF);
 532         xm_write32(hw, port, XM_MODE, reg | XM_MD_FRF);
 533 }
 534
 535
 536 /* Convert mode to MII values  */
 537 static const u16 phy_pause_map[] = {
 538         [FLOW_MODE_NONE] =      0,
 539         [FLOW_MODE_LOC_SEND] =  PHY_AN_PAUSE_ASYM,
 540         [FLOW_MODE_SYMMETRIC] = PHY_AN_PAUSE_CAP,
 541         [FLOW_MODE_SYM_OR_REM]  = PHY_AN_PAUSE_CAP | PHY_AN_PAUSE_ASYM,
 542 };
 543
 544 /* special defines for FIBER (88E1011S only) */
 545 static const u16 fiber_pause_map[] = {
 546         [FLOW_MODE_NONE]        = PHY_X_P_NO_PAUSE,
 547         [FLOW_MODE_LOC_SEND]    = PHY_X_P_ASYM_MD,
 548         [FLOW_MODE_SYMMETRIC]   = PHY_X_P_SYM_MD,
 549         [FLOW_MODE_SYM_OR_REM]  = PHY_X_P_BOTH_MD,
 550 };
 551
 552
 553 /* Check status of Broadcom phy link */
 554 static void bcom_check_link(struct skge_hw *hw, int port)
 555 {
 556         struct net_device *dev = hw->dev[port];
 557         struct skge_port *skge = netdev_priv(dev);
 558         u16 status;
 559
 560         /* read twice because of latch */
 561         xm_phy_read(hw, port, PHY_BCOM_STAT);
 562         status = xm_phy_read(hw, port, PHY_BCOM_STAT);
 563
 564         if ((status & PHY_ST_LSYNC) == 0) {
 565                 xm_link_down(hw, port);
 566                 return;
 567         }
 568
 569         if (skge->autoneg == AUTONEG_ENABLE) {
 570                 u16 lpa, aux;
 571
 572                 if (!(status & PHY_ST_AN_OVER))
 573                         return;
 574
 575                 lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
 576                 if (lpa & PHY_B_AN_RF) {
 577                         DBG(PFX "%s: remote fault\n",
 578                                dev->name);
 579                         return;
 580                 }
 581
 582                 aux = xm_phy_read(hw, port, PHY_BCOM_AUX_STAT);
 583
 584                 /* Check Duplex mismatch */
 585                 switch (aux & PHY_B_AS_AN_RES_MSK) {
 586                 case PHY_B_RES_1000FD:
 587                         skge->duplex = DUPLEX_FULL;
 588                         break;
 589                 case PHY_B_RES_1000HD:
 590                         skge->duplex = DUPLEX_HALF;
 591                         break;
 592                 default:
 593                         DBG(PFX "%s: duplex mismatch\n",
 594                                dev->name);
 595                         return;
 596                 }
 597
 598                 /* We are using IEEE 802.3z/D5.0 Table 37-4 */
 599                 switch (aux & PHY_B_AS_PAUSE_MSK) {
 600                 case PHY_B_AS_PAUSE_MSK:
 601                         skge->flow_status = FLOW_STAT_SYMMETRIC;
 602                         break;
 603                 case PHY_B_AS_PRR:
 604                         skge->flow_status = FLOW_STAT_REM_SEND;
 605                         break;
 606                 case PHY_B_AS_PRT:
 607                         skge->flow_status = FLOW_STAT_LOC_SEND;
 608                         break;
 609                 default:
 610                         skge->flow_status = FLOW_STAT_NONE;
 611                 }
 612                 skge->speed = SPEED_1000;
 613         }
 614
 615         if (!netdev_link_ok(dev))
 616                 genesis_link_up(skge);
 617 }
 618
 619 /* Broadcom 5400 only supports giagabit! SysKonnect did not put an additional
 620  * Phy on for 100 or 10Mbit operation
 621  */
 622 static void bcom_phy_init(struct skge_port *skge)
 623 {
 624         struct skge_hw *hw = skge->hw;
 625         int port = skge->port;
 626         unsigned int i;
 627         u16 id1, r, ext, ctl;
 628
 629         /* magic workaround patterns for Broadcom */
 630         static const struct {
 631                 u16 reg;
 632                 u16 val;
 633         } A1hack[] = {
 634                 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1104 },
 635                 { 0x17, 0x0013 }, { 0x15, 0x0404 }, { 0x17, 0x8006 },
 636                 { 0x15, 0x0132 }, { 0x17, 0x8006 }, { 0x15, 0x0232 },
 637                 { 0x17, 0x800D }, { 0x15, 0x000F }, { 0x18, 0x0420 },
 638         }, C0hack[] = {
 639                 { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1204 },
 640                 { 0x17, 0x0013 }, { 0x15, 0x0A04 }, { 0x18, 0x0420 },
 641         };
 642
 643         /* read Id from external PHY (all have the same address) */
 644         id1 = xm_phy_read(hw, port, PHY_XMAC_ID1);
 645
 646         /* Optimize MDIO transfer by suppressing preamble. */
 647         r = xm_read16(hw, port, XM_MMU_CMD);
 648         r |=  XM_MMU_NO_PRE;
 649         xm_write16(hw, port, XM_MMU_CMD,r);
 650
 651         switch (id1) {
 652         case PHY_BCOM_ID1_C0:
 653                 /*
 654                  * Workaround BCOM Errata for the C0 type.
 655                  * Write magic patterns to reserved registers.
 656                  */
 657                 for (i = 0; i < ARRAY_SIZE(C0hack); i++)
 658                         xm_phy_write(hw, port,
 659                                      C0hack[i].reg, C0hack[i].val);
 660
 661                 break;
 662         case PHY_BCOM_ID1_A1:
 663                 /*
 664                  * Workaround BCOM Errata for the A1 type.
 665                  * Write magic patterns to reserved registers.
 666                  */
 667                 for (i = 0; i < ARRAY_SIZE(A1hack); i++)
 668                         xm_phy_write(hw, port,
 669                                      A1hack[i].reg, A1hack[i].val);
 670                 break;
 671         }
 672
 673         /*
 674          * Workaround BCOM Errata (#10523) for all BCom PHYs.
 675          * Disable Power Management after reset.
 676          */
 677         r = xm_phy_read(hw, port, PHY_BCOM_AUX_CTRL);
 678         r |= PHY_B_AC_DIS_PM;
 679         xm_phy_write(hw, port, PHY_BCOM_AUX_CTRL, r);
 680
 681         /* Dummy read */
 682         xm_read16(hw, port, XM_ISRC);
 683
 684         ext = PHY_B_PEC_EN_LTR; /* enable tx led */
 685         ctl = PHY_CT_SP1000;    /* always 1000mbit */
 686
 687         if (skge->autoneg == AUTONEG_ENABLE) {
 688                 /*
 689                  * Workaround BCOM Errata #1 for the C5 type.
 690                  * 1000Base-T Link Acquisition Failure in Slave Mode
 691                  * Set Repeater/DTE bit 10 of the 1000Base-T Control Register
 692                  */
 693                 u16 adv = PHY_B_1000C_RD;
 694                 if (skge->advertising & ADVERTISED_1000baseT_Half)
 695                         adv |= PHY_B_1000C_AHD;
 696                 if (skge->advertising & ADVERTISED_1000baseT_Full)
 697                         adv |= PHY_B_1000C_AFD;
 698                 xm_phy_write(hw, port, PHY_BCOM_1000T_CTRL, adv);
 699
 700                 ctl |= PHY_CT_ANE | PHY_CT_RE_CFG;
 701         } else {
 702                 if (skge->duplex == DUPLEX_FULL)
 703                         ctl |= PHY_CT_DUP_MD;
 704                 /* Force to slave */
 705                 xm_phy_write(hw, port, PHY_BCOM_1000T_CTRL, PHY_B_1000C_MSE);
 706         }
 707
 708         /* Set autonegotiation pause parameters */
 709         xm_phy_write(hw, port, PHY_BCOM_AUNE_ADV,
 710                      phy_pause_map[skge->flow_control] | PHY_AN_CSMA);
 711
 712         xm_phy_write(hw, port, PHY_BCOM_P_EXT_CTRL, ext);
 713         xm_phy_write(hw, port, PHY_BCOM_CTRL, ctl);
 714
 715         /* Use link status change interrupt */
 716         xm_phy_write(hw, port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
 717 }
 718
 719 static void xm_phy_init(struct skge_port *skge)
 720 {
 721         struct skge_hw *hw = skge->hw;
 722         int port = skge->port;
 723         u16 ctrl = 0;
 724
 725         if (skge->autoneg == AUTONEG_ENABLE) {
 726                 if (skge->advertising & ADVERTISED_1000baseT_Half)
 727                         ctrl |= PHY_X_AN_HD;
 728                 if (skge->advertising & ADVERTISED_1000baseT_Full)
 729                         ctrl |= PHY_X_AN_FD;
 730
 731                 ctrl |= fiber_pause_map[skge->flow_control];
 732
 733                 xm_phy_write(hw, port, PHY_XMAC_AUNE_ADV, ctrl);
 734
 735                 /* Restart Auto-negotiation */
 736                 ctrl = PHY_CT_ANE | PHY_CT_RE_CFG;
 737         } else {
 738                 /* Set DuplexMode in Config register */
 739                 if (skge->duplex == DUPLEX_FULL)
 740                         ctrl |= PHY_CT_DUP_MD;
 741                 /*
 742                  * Do NOT enable Auto-negotiation here. This would hold
 743                  * the link down because no IDLEs are transmitted
 744                  */
 745         }
 746
 747         xm_phy_write(hw, port, PHY_XMAC_CTRL, ctrl);
 748
 749         /* Poll PHY for status changes */
 750         skge->use_xm_link_timer = 1;
 751 }
 752
 753 static int xm_check_link(struct net_device *dev)
 754 {
 755         struct skge_port *skge = netdev_priv(dev);
 756         struct skge_hw *hw = skge->hw;
 757         int port = skge->port;
 758         u16 status;
 759
 760         /* read twice because of latch */
 761         xm_phy_read(hw, port, PHY_XMAC_STAT);
 762         status = xm_phy_read(hw, port, PHY_XMAC_STAT);
 763
 764         if ((status & PHY_ST_LSYNC) == 0) {
 765                 xm_link_down(hw, port);
 766                 return 0;
 767         }
 768
 769         if (skge->autoneg == AUTONEG_ENABLE) {
 770                 u16 lpa, res;
 771
 772                 if (!(status & PHY_ST_AN_OVER))
 773                         return 0;
 774
 775                 lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
 776                 if (lpa & PHY_B_AN_RF) {
 777                         DBG(PFX "%s: remote fault\n",
 778                                dev->name);
 779                         return 0;
 780                 }
 781
 782                 res = xm_phy_read(hw, port, PHY_XMAC_RES_ABI);
 783
 784                 /* Check Duplex mismatch */
 785                 switch (res & (PHY_X_RS_HD | PHY_X_RS_FD)) {
 786                 case PHY_X_RS_FD:
 787                         skge->duplex = DUPLEX_FULL;
 788                         break;
 789                 case PHY_X_RS_HD:
 790                         skge->duplex = DUPLEX_HALF;
 791                         break;
 792                 default:
 793                         DBG(PFX "%s: duplex mismatch\n",
 794                                dev->name);
 795                         return 0;
 796                 }
 797
 798                 /* We are using IEEE 802.3z/D5.0 Table 37-4 */
 799                 if ((skge->flow_control == FLOW_MODE_SYMMETRIC ||
 800                      skge->flow_control == FLOW_MODE_SYM_OR_REM) &&
 801                     (lpa & PHY_X_P_SYM_MD))
 802                         skge->flow_status = FLOW_STAT_SYMMETRIC;
 803                 else if (skge->flow_control == FLOW_MODE_SYM_OR_REM &&
 804                          (lpa & PHY_X_RS_PAUSE) == PHY_X_P_ASYM_MD)
 805                         /* Enable PAUSE receive, disable PAUSE transmit */
 806                         skge->flow_status  = FLOW_STAT_REM_SEND;
 807                 else if (skge->flow_control == FLOW_MODE_LOC_SEND &&
 808                          (lpa & PHY_X_RS_PAUSE) == PHY_X_P_BOTH_MD)
 809                         /* Disable PAUSE receive, enable PAUSE transmit */
 810                         skge->flow_status = FLOW_STAT_LOC_SEND;
 811                 else
 812                         skge->flow_status = FLOW_STAT_NONE;
 813
 814                 skge->speed = SPEED_1000;
 815         }
 816
 817         if (!netdev_link_ok(dev))
 818                 genesis_link_up(skge);
 819         return 1;
 820 }
 821
 822 /* Poll to check for link coming up.
 823  *
 824  * Since internal PHY is wired to a level triggered pin, can't
 825  * get an interrupt when carrier is detected, need to poll for
 826  * link coming up.
 827  */
 828 static void xm_link_timer(struct skge_port *skge)
 829 {
 830         struct net_device *dev = skge->netdev;
 831         struct skge_hw *hw = skge->hw;
 832         int port = skge->port;
 833         int i;
 834
 835         /*
 836          * Verify that the link by checking GPIO register three times.
 837          * This pin has the signal from the link_sync pin connected to it.
 838          */
 839         for (i = 0; i < 3; i++) {
 840                 if (xm_read16(hw, port, XM_GP_PORT) & XM_GP_INP_ASS)
 841                         return;
 842         }
 843
 844         /* Re-enable interrupt to detect link down */
 845         if (xm_check_link(dev)) {
 846                 u16 msk = xm_read16(hw, port, XM_IMSK);
 847                 msk &= ~XM_IS_INP_ASS;
 848                 xm_write16(hw, port, XM_IMSK, msk);
 849                 xm_read16(hw, port, XM_ISRC);
 850         }
 851 }
 852
 853 static void genesis_mac_init(struct skge_hw *hw, int port)
 854 {
 855         struct net_device *dev = hw->dev[port];
 856         struct skge_port *skge = netdev_priv(dev);
 857         int i;
 858         u32 r;
 859         const u8 zero[6]  = { 0 };
 860
 861         for (i = 0; i < 10; i++) {
 862                 skge_write16(hw, SK_REG(port, TX_MFF_CTRL1),
 863                              MFF_SET_MAC_RST);
 864                 if (skge_read16(hw, SK_REG(port, TX_MFF_CTRL1)) & MFF_SET_MAC_RST)
 865                         goto reset_ok;
 866                 udelay(1);
 867         }
 868
 869         DBG(PFX "%s: genesis reset failed\n", dev->name);
 870
 871  reset_ok:
 872         /* Unreset the XMAC. */
 873         skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_CLR_MAC_RST);
 874
 875         /*
 876          * Perform additional initialization for external PHYs,
 877          * namely for the 1000baseTX cards that use the XMAC's
 878          * GMII mode.
 879          */
 880         if (hw->phy_type != SK_PHY_XMAC) {
 881                 /* Take external Phy out of reset */
 882                 r = skge_read32(hw, B2_GP_IO);
 883                 if (port == 0)
 884                         r |= GP_DIR_0|GP_IO_0;
 885                 else
 886                         r |= GP_DIR_2|GP_IO_2;
 887
 888                 skge_write32(hw, B2_GP_IO, r);
 889
 890                 /* Enable GMII interface */
 891                 xm_write16(hw, port, XM_HW_CFG, XM_HW_GMII_MD);
 892         }
 893
 894
 895         switch(hw->phy_type) {
 896         case SK_PHY_XMAC:
 897                 xm_phy_init(skge);
 898                 break;
 899         case SK_PHY_BCOM:
 900                 bcom_phy_init(skge);
 901                 bcom_check_link(hw, port);
 902         }
 903
 904         /* Set Station Address */
 905         xm_outaddr(hw, port, XM_SA, dev->ll_addr);
 906
 907         /* We don't use match addresses so clear */
 908         for (i = 1; i < 16; i++)
 909                 xm_outaddr(hw, port, XM_EXM(i), zero);
 910
 911         /* Clear MIB counters */
 912         xm_write16(hw, port, XM_STAT_CMD,
 913                         XM_SC_CLR_RXC | XM_SC_CLR_TXC);
 914         /* Clear two times according to Errata #3 */
 915         xm_write16(hw, port, XM_STAT_CMD,
 916                         XM_SC_CLR_RXC | XM_SC_CLR_TXC);
 917
 918         /* configure Rx High Water Mark (XM_RX_HI_WM) */
 919         xm_write16(hw, port, XM_RX_HI_WM, 1450);
 920
 921         /* We don't need the FCS appended to the packet. */
 922         r = XM_RX_LENERR_OK | XM_RX_STRIP_FCS;
 923
 924         if (skge->duplex == DUPLEX_HALF) {
 925                 /*
 926                  * If in manual half duplex mode the other side might be in
 927                  * full duplex mode, so ignore if a carrier extension is not seen
 928                  * on frames received
 929                  */
 930                 r |= XM_RX_DIS_CEXT;
 931         }
 932         xm_write16(hw, port, XM_RX_CMD, r);
 933
 934         /* We want short frames padded to 60 bytes. */
 935         xm_write16(hw, port, XM_TX_CMD, XM_TX_AUTO_PAD);
 936
 937         xm_write16(hw, port, XM_TX_THR, 512);
 938
 939         /*
 940          * Enable the reception of all error frames. This is is
 941          * a necessary evil due to the design of the XMAC. The
 942          * XMAC's receive FIFO is only 8K in size, however jumbo
 943          * frames can be up to 9000 bytes in length. When bad
 944          * frame filtering is enabled, the XMAC's RX FIFO operates
 945          * in 'store and forward' mode. For this to work, the
 946          * entire frame has to fit into the FIFO, but that means
 947          * that jumbo frames larger than 8192 bytes will be
 948          * truncated. Disabling all bad frame filtering causes
 949          * the RX FIFO to operate in streaming mode, in which
 950          * case the XMAC will start transferring frames out of the
 951          * RX FIFO as soon as the FIFO threshold is reached.
 952          */
 953         xm_write32(hw, port, XM_MODE, XM_DEF_MODE);
 954
 955
 956         /*
 957          * Initialize the Receive Counter Event Mask (XM_RX_EV_MSK)
 958          *      - Enable all bits excepting 'Octets Rx OK Low CntOv'
 959          *        and 'Octets Rx OK Hi Cnt Ov'.
 960          */
 961         xm_write32(hw, port, XM_RX_EV_MSK, XMR_DEF_MSK);
 962
 963         /*
 964          * Initialize the Transmit Counter Event Mask (XM_TX_EV_MSK)
 965          *      - Enable all bits excepting 'Octets Tx OK Low CntOv'
 966          *        and 'Octets Tx OK Hi Cnt Ov'.
 967          */
 968         xm_write32(hw, port, XM_TX_EV_MSK, XMT_DEF_MSK);
 969
 970         /* Configure MAC arbiter */
 971         skge_write16(hw, B3_MA_TO_CTRL, MA_RST_CLR);
 972
 973         /* configure timeout values */
 974         skge_write8(hw, B3_MA_TOINI_RX1, 72);
 975         skge_write8(hw, B3_MA_TOINI_RX2, 72);
 976         skge_write8(hw, B3_MA_TOINI_TX1, 72);
 977         skge_write8(hw, B3_MA_TOINI_TX2, 72);
 978
 979         skge_write8(hw, B3_MA_RCINI_RX1, 0);
 980         skge_write8(hw, B3_MA_RCINI_RX2, 0);
 981         skge_write8(hw, B3_MA_RCINI_TX1, 0);
 982         skge_write8(hw, B3_MA_RCINI_TX2, 0);
 983
 984         /* Configure Rx MAC FIFO */
 985         skge_write8(hw, SK_REG(port, RX_MFF_CTRL2), MFF_RST_CLR);
 986         skge_write16(hw, SK_REG(port, RX_MFF_CTRL1), MFF_ENA_TIM_PAT);
 987         skge_write8(hw, SK_REG(port, RX_MFF_CTRL2), MFF_ENA_OP_MD);
 988
 989         /* Configure Tx MAC FIFO */
 990         skge_write8(hw, SK_REG(port, TX_MFF_CTRL2), MFF_RST_CLR);
 991         skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_TX_CTRL_DEF);
 992         skge_write8(hw, SK_REG(port, TX_MFF_CTRL2), MFF_ENA_OP_MD);
 993
 994         /* enable timeout timers */
 995         skge_write16(hw, B3_PA_CTRL,
 996                      (port == 0) ? PA_ENA_TO_TX1 : PA_ENA_TO_TX2);
 997 }
 998
 999 static void genesis_stop(struct skge_port *skge)
1000 {
1001         struct skge_hw *hw = skge->hw;
1002         int port = skge->port;
1003         unsigned retries = 1000;
1004         u16 cmd;
1005
1006         /* Disable Tx and Rx */
1007         cmd = xm_read16(hw, port, XM_MMU_CMD);
1008         cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
1009         xm_write16(hw, port, XM_MMU_CMD, cmd);
1010
1011         genesis_reset(hw, port);
1012
1013         /* Clear Tx packet arbiter timeout IRQ */
1014         skge_write16(hw, B3_PA_CTRL,
1015                      port == 0 ? PA_CLR_TO_TX1 : PA_CLR_TO_TX2);
1016
1017         /* Reset the MAC */
1018         skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_CLR_MAC_RST);
1019         do {
1020                 skge_write16(hw, SK_REG(port, TX_MFF_CTRL1), MFF_SET_MAC_RST);
1021                 if (!(skge_read16(hw, SK_REG(port, TX_MFF_CTRL1)) & MFF_SET_MAC_RST))
1022                         break;
1023         } while (--retries > 0);
1024
1025         /* For external PHYs there must be special handling */
1026         if (hw->phy_type != SK_PHY_XMAC) {
1027                 u32 reg = skge_read32(hw, B2_GP_IO);
1028                 if (port == 0) {
1029                         reg |= GP_DIR_0;
1030                         reg &= ~GP_IO_0;
1031                 } else {
1032                         reg |= GP_DIR_2;
1033                         reg &= ~GP_IO_2;
1034                 }
1035                 skge_write32(hw, B2_GP_IO, reg);
1036                 skge_read32(hw, B2_GP_IO);
1037         }
1038
1039         xm_write16(hw, port, XM_MMU_CMD,
1040                         xm_read16(hw, port, XM_MMU_CMD)
1041                         & ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX));
1042
1043         xm_read16(hw, port, XM_MMU_CMD);
1044 }
1045
1046 static void genesis_link_up(struct skge_port *skge)
1047 {
1048         struct skge_hw *hw = skge->hw;
1049         int port = skge->port;
1050         u16 cmd, msk;
1051         u32 mode;
1052
1053         cmd = xm_read16(hw, port, XM_MMU_CMD);
1054
1055         /*
1056          * enabling pause frame reception is required for 1000BT
1057          * because the XMAC is not reset if the link is going down
1058          */
1059         if (skge->flow_status == FLOW_STAT_NONE ||
1060             skge->flow_status == FLOW_STAT_LOC_SEND)
1061                 /* Disable Pause Frame Reception */
1062                 cmd |= XM_MMU_IGN_PF;
1063         else
1064                 /* Enable Pause Frame Reception */
1065                 cmd &= ~XM_MMU_IGN_PF;
1066
1067         xm_write16(hw, port, XM_MMU_CMD, cmd);
1068
1069         mode = xm_read32(hw, port, XM_MODE);
1070         if (skge->flow_status== FLOW_STAT_SYMMETRIC ||
1071             skge->flow_status == FLOW_STAT_LOC_SEND) {
1072                 /*
1073                  * Configure Pause Frame Generation
1074                  * Use internal and external Pause Frame Generation.
1075                  * Sending pause frames is edge triggered.
1076                  * Send a Pause frame with the maximum pause time if
1077                  * internal oder external FIFO full condition occurs.
1078                  * Send a zero pause time frame to re-start transmission.
1079                  */
1080                 /* XM_PAUSE_DA = '010000C28001' (default) */
1081                 /* XM_MAC_PTIME = 0xffff (maximum) */
1082                 /* remember this value is defined in big endian (!) */
1083                 xm_write16(hw, port, XM_MAC_PTIME, 0xffff);
1084
1085                 mode |= XM_PAUSE_MODE;
1086                 skge_write16(hw, SK_REG(port, RX_MFF_CTRL1), MFF_ENA_PAUSE);
1087         } else {
1088                 /*
1089                  * disable pause frame generation is required for 1000BT
1090                  * because the XMAC is not reset if the link is going down
1091                  */
1092                 /* Disable Pause Mode in Mode Register */
1093                 mode &= ~XM_PAUSE_MODE;
1094
1095                 skge_write16(hw, SK_REG(port, RX_MFF_CTRL1), MFF_DIS_PAUSE);
1096         }
1097
1098         xm_write32(hw, port, XM_MODE, mode);
1099
1100         /* Turn on detection of Tx underrun */
1101         msk = xm_read16(hw, port, XM_IMSK);
1102         msk &= ~XM_IS_TXF_UR;
1103         xm_write16(hw, port, XM_IMSK, msk);
1104
1105         xm_read16(hw, port, XM_ISRC);
1106
1107         /* get MMU Command Reg. */
1108         cmd = xm_read16(hw, port, XM_MMU_CMD);
1109         if (hw->phy_type != SK_PHY_XMAC && skge->duplex == DUPLEX_FULL)
1110                 cmd |= XM_MMU_GMII_FD;
1111
1112         /*
1113          * Workaround BCOM Errata (#10523) for all BCom Phys
1114          * Enable Power Management after link up
1115          */
1116         if (hw->phy_type == SK_PHY_BCOM) {
1117                 xm_phy_write(hw, port, PHY_BCOM_AUX_CTRL,
1118                              xm_phy_read(hw, port, PHY_BCOM_AUX_CTRL)
1119                              & ~PHY_B_AC_DIS_PM);
1120                 xm_phy_write(hw, port, PHY_BCOM_INT_MASK, PHY_B_DEF_MSK);
1121         }
1122
1123         /* enable Rx/Tx */
1124         xm_write16(hw, port, XM_MMU_CMD,
1125                         cmd | XM_MMU_ENA_RX | XM_MMU_ENA_TX);
1126         skge_link_up(skge);
1127 }
1128
1129
1130 static inline void bcom_phy_intr(struct skge_port *skge)
1131 {
1132         struct skge_hw *hw = skge->hw;
1133         int port = skge->port;
1134         u16 isrc;
1135
1136         isrc = xm_phy_read(hw, port, PHY_BCOM_INT_STAT);
1137         DBGIO(PFX "%s: phy interrupt status 0x%x\n",
1138              skge->netdev->name, isrc);
1139
1140         if (isrc & PHY_B_IS_PSE)
1141                 DBG(PFX "%s: uncorrectable pair swap error\n",
1142                     hw->dev[port]->name);
1143
1144         /* Workaround BCom Errata:
1145          *      enable and disable loopback mode if "NO HCD" occurs.
1146          */
1147         if (isrc & PHY_B_IS_NO_HDCL) {
1148                 u16 ctrl = xm_phy_read(hw, port, PHY_BCOM_CTRL);
1149                 xm_phy_write(hw, port, PHY_BCOM_CTRL,
1150                                   ctrl | PHY_CT_LOOP);
1151                 xm_phy_write(hw, port, PHY_BCOM_CTRL,
1152                                   ctrl & ~PHY_CT_LOOP);
1153         }
1154
1155         if (isrc & (PHY_B_IS_AN_PR | PHY_B_IS_LST_CHANGE))
1156                 bcom_check_link(hw, port);
1157
1158 }
1159
1160 static int gm_phy_write(struct skge_hw *hw, int port, u16 reg, u16 val)
1161 {
1162         int i;
1163
1164         gma_write16(hw, port, GM_SMI_DATA, val);
1165         gma_write16(hw, port, GM_SMI_CTRL,
1166                          GM_SMI_CT_PHY_AD(hw->phy_addr) | GM_SMI_CT_REG_AD(reg));
1167         for (i = 0; i < PHY_RETRIES; i++) {
1168                 udelay(1);
1169
1170                 if (!(gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_BUSY))
1171                         return 0;
1172         }
1173
1174         DBG(PFX "%s: phy write timeout port %x reg %x val %x\n",
1175             hw->dev[port]->name,
1176             port, reg, val);
1177         return -EIO;
1178 }
1179
1180 static int __gm_phy_read(struct skge_hw *hw, int port, u16 reg, u16 *val)
1181 {
1182         int i;
1183
1184         gma_write16(hw, port, GM_SMI_CTRL,
1185                          GM_SMI_CT_PHY_AD(hw->phy_addr)
1186                          | GM_SMI_CT_REG_AD(reg) | GM_SMI_CT_OP_RD);
1187
1188         for (i = 0; i < PHY_RETRIES; i++) {
1189                 udelay(1);
1190                 if (gma_read16(hw, port, GM_SMI_CTRL) & GM_SMI_CT_RD_VAL)
1191                         goto ready;
1192         }
1193
1194         return -ETIMEDOUT;
1195  ready:
1196         *val = gma_read16(hw, port, GM_SMI_DATA);
1197         return 0;
1198 }
1199
1200 static u16 gm_phy_read(struct skge_hw *hw, int port, u16 reg)
1201 {
1202         u16 v = 0;
1203         if (__gm_phy_read(hw, port, reg, &v))
1204                 DBG(PFX "%s: phy read timeout port %x reg %x val %x\n",
1205                hw->dev[port]->name,
1206                port, reg, v);
1207         return v;
1208 }
1209
1210 /* Marvell Phy Initialization */
1211 static void yukon_init(struct skge_hw *hw, int port)
1212 {
1213         struct skge_port *skge = netdev_priv(hw->dev[port]);
1214         u16 ctrl, ct1000, adv;
1215
1216         if (skge->autoneg == AUTONEG_ENABLE) {
1217                 u16 ectrl = gm_phy_read(hw, port, PHY_MARV_EXT_CTRL);
1218
1219                 ectrl &= ~(PHY_M_EC_M_DSC_MSK | PHY_M_EC_S_DSC_MSK |
1220                           PHY_M_EC_MAC_S_MSK);
1221                 ectrl |= PHY_M_EC_MAC_S(MAC_TX_CLK_25_MHZ);
1222
1223                 ectrl |= PHY_M_EC_M_DSC(0) | PHY_M_EC_S_DSC(1);
1224
1225                 gm_phy_write(hw, port, PHY_MARV_EXT_CTRL, ectrl);
1226         }
1227
1228         ctrl = gm_phy_read(hw, port, PHY_MARV_CTRL);
1229         if (skge->autoneg == AUTONEG_DISABLE)
1230                 ctrl &= ~PHY_CT_ANE;
1231
1232         ctrl |= PHY_CT_RESET;
1233         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
1234
1235         ctrl = 0;
1236         ct1000 = 0;
1237         adv = PHY_AN_CSMA;
1238
1239         if (skge->autoneg == AUTONEG_ENABLE) {
1240                 if (hw->copper) {
1241                         if (skge->advertising & ADVERTISED_1000baseT_Full)
1242                                 ct1000 |= PHY_M_1000C_AFD;
1243                         if (skge->advertising & ADVERTISED_1000baseT_Half)
1244                                 ct1000 |= PHY_M_1000C_AHD;
1245                         if (skge->advertising & ADVERTISED_100baseT_Full)
1246                                 adv |= PHY_M_AN_100_FD;
1247                         if (skge->advertising & ADVERTISED_100baseT_Half)
1248                                 adv |= PHY_M_AN_100_HD;
1249                         if (skge->advertising & ADVERTISED_10baseT_Full)
1250                                 adv |= PHY_M_AN_10_FD;
1251                         if (skge->advertising & ADVERTISED_10baseT_Half)
1252                                 adv |= PHY_M_AN_10_HD;
1253
1254                         /* Set Flow-control capabilities */
1255                         adv |= phy_pause_map[skge->flow_control];
1256                 } else {
1257                         if (skge->advertising & ADVERTISED_1000baseT_Full)
1258                                 adv |= PHY_M_AN_1000X_AFD;
1259                         if (skge->advertising & ADVERTISED_1000baseT_Half)
1260                                 adv |= PHY_M_AN_1000X_AHD;
1261
1262                         adv |= fiber_pause_map[skge->flow_control];
1263                 }
1264
1265                 /* Restart Auto-negotiation */
1266                 ctrl |= PHY_CT_ANE | PHY_CT_RE_CFG;
1267         } else {
1268                 /* forced speed/duplex settings */
1269                 ct1000 = PHY_M_1000C_MSE;
1270
1271                 if (skge->duplex == DUPLEX_FULL)
1272                         ctrl |= PHY_CT_DUP_MD;
1273
1274                 switch (skge->speed) {
1275                 case SPEED_1000:
1276                         ctrl |= PHY_CT_SP1000;
1277                         break;
1278                 case SPEED_100:
1279                         ctrl |= PHY_CT_SP100;
1280                         break;
1281                 }
1282
1283                 ctrl |= PHY_CT_RESET;
1284         }
1285
1286         gm_phy_write(hw, port, PHY_MARV_1000T_CTRL, ct1000);
1287
1288         gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, adv);
1289         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
1290
1291         /* Enable phy interrupt on autonegotiation complete (or link up) */
1292         if (skge->autoneg == AUTONEG_ENABLE)
1293                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_AN_MSK);
1294         else
1295                 gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_DEF_MSK);
1296 }
1297
1298 static void yukon_reset(struct skge_hw *hw, int port)
1299 {
1300         gm_phy_write(hw, port, PHY_MARV_INT_MASK, 0);/* disable PHY IRQs */
1301         gma_write16(hw, port, GM_MC_ADDR_H1, 0);        /* clear MC hash */
1302         gma_write16(hw, port, GM_MC_ADDR_H2, 0);
1303         gma_write16(hw, port, GM_MC_ADDR_H3, 0);
1304         gma_write16(hw, port, GM_MC_ADDR_H4, 0);
1305
1306         gma_write16(hw, port, GM_RX_CTRL,
1307                          gma_read16(hw, port, GM_RX_CTRL)
1308                          | GM_RXCR_UCF_ENA | GM_RXCR_MCF_ENA);
1309 }
1310
1311 /* Apparently, early versions of Yukon-Lite had wrong chip_id? */
1312 static int is_yukon_lite_a0(struct skge_hw *hw)
1313 {
1314         u32 reg;
1315         int ret;
1316
1317         if (hw->chip_id != CHIP_ID_YUKON)
1318                 return 0;
1319
1320         reg = skge_read32(hw, B2_FAR);
1321         skge_write8(hw, B2_FAR + 3, 0xff);
1322         ret = (skge_read8(hw, B2_FAR + 3) != 0);
1323         skge_write32(hw, B2_FAR, reg);
1324         return ret;
1325 }
1326
1327 static void yukon_mac_init(struct skge_hw *hw, int port)
1328 {
1329         struct skge_port *skge = netdev_priv(hw->dev[port]);
1330         int i;
1331         u32 reg;
1332         const u8 *addr = hw->dev[port]->ll_addr;
1333
1334         /* WA code for COMA mode -- set PHY reset */
1335         if (hw->chip_id == CHIP_ID_YUKON_LITE &&
1336             hw->chip_rev >= CHIP_REV_YU_LITE_A3) {
1337                 reg = skge_read32(hw, B2_GP_IO);
1338                 reg |= GP_DIR_9 | GP_IO_9;
1339                 skge_write32(hw, B2_GP_IO, reg);
1340         }
1341
1342         /* hard reset */
1343         skge_write32(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
1344         skge_write32(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET);
1345
1346         /* WA code for COMA mode -- clear PHY reset */
1347         if (hw->chip_id == CHIP_ID_YUKON_LITE &&
1348             hw->chip_rev >= CHIP_REV_YU_LITE_A3) {
1349                 reg = skge_read32(hw, B2_GP_IO);
1350                 reg |= GP_DIR_9;
1351                 reg &= ~GP_IO_9;
1352                 skge_write32(hw, B2_GP_IO, reg);
1353         }
1354
1355         /* Set hardware config mode */
1356         reg = GPC_INT_POL_HI | GPC_DIS_FC | GPC_DIS_SLEEP |
1357                 GPC_ENA_XC | GPC_ANEG_ADV_ALL_M | GPC_ENA_PAUSE;
1358         reg |= hw->copper ? GPC_HWCFG_GMII_COP : GPC_HWCFG_GMII_FIB;
1359
1360         /* Clear GMC reset */
1361         skge_write32(hw, SK_REG(port, GPHY_CTRL), reg | GPC_RST_SET);
1362         skge_write32(hw, SK_REG(port, GPHY_CTRL), reg | GPC_RST_CLR);
1363         skge_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON | GMC_RST_CLR);
1364
1365         if (skge->autoneg == AUTONEG_DISABLE) {
1366                 reg = GM_GPCR_AU_ALL_DIS;
1367                 gma_write16(hw, port, GM_GP_CTRL,
1368                                  gma_read16(hw, port, GM_GP_CTRL) | reg);
1369
1370                 switch (skge->speed) {
1371                 case SPEED_1000:
1372                         reg &= ~GM_GPCR_SPEED_100;
1373                         reg |= GM_GPCR_SPEED_1000;
1374                         break;
1375                 case SPEED_100:
1376                         reg &= ~GM_GPCR_SPEED_1000;
1377                         reg |= GM_GPCR_SPEED_100;
1378                         break;
1379                 case SPEED_10:
1380                         reg &= ~(GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100);
1381                         break;
1382                 }
1383
1384                 if (skge->duplex == DUPLEX_FULL)
1385                         reg |= GM_GPCR_DUP_FULL;
1386         } else
1387                 reg = GM_GPCR_SPEED_1000 | GM_GPCR_SPEED_100 | GM_GPCR_DUP_FULL;
1388
1389         switch (skge->flow_control) {
1390         case FLOW_MODE_NONE:
1391                 skge_write32(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
1392                 reg |= GM_GPCR_FC_TX_DIS | GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS;
1393                 break;
1394         case FLOW_MODE_LOC_SEND:
1395                 /* disable Rx flow-control */
1396                 reg |= GM_GPCR_FC_RX_DIS | GM_GPCR_AU_FCT_DIS;
1397                 break;
1398         case FLOW_MODE_SYMMETRIC:
1399         case FLOW_MODE_SYM_OR_REM:
1400                 /* enable Tx & Rx flow-control */
1401                 break;
1402         }
1403
1404         gma_write16(hw, port, GM_GP_CTRL, reg);
1405         skge_read16(hw, SK_REG(port, GMAC_IRQ_SRC));
1406
1407         yukon_init(hw, port);
1408
1409         /* MIB clear */
1410         reg = gma_read16(hw, port, GM_PHY_ADDR);
1411         gma_write16(hw, port, GM_PHY_ADDR, reg | GM_PAR_MIB_CLR);
1412
1413         for (i = 0; i < GM_MIB_CNT_SIZE; i++)
1414                 gma_read16(hw, port, GM_MIB_CNT_BASE + 8*i);
1415         gma_write16(hw, port, GM_PHY_ADDR, reg);
1416
1417         /* transmit control */
1418         gma_write16(hw, port, GM_TX_CTRL, TX_COL_THR(TX_COL_DEF));
1419
1420         /* receive control reg: unicast + multicast + no FCS  */
1421         gma_write16(hw, port, GM_RX_CTRL,
1422                          GM_RXCR_UCF_ENA | GM_RXCR_CRC_DIS | GM_RXCR_MCF_ENA);
1423
1424         /* transmit flow control */
1425         gma_write16(hw, port, GM_TX_FLOW_CTRL, 0xffff);
1426
1427         /* transmit parameter */
1428         gma_write16(hw, port, GM_TX_PARAM,
1429                          TX_JAM_LEN_VAL(TX_JAM_LEN_DEF) |
1430                          TX_JAM_IPG_VAL(TX_JAM_IPG_DEF) |
1431                          TX_IPG_JAM_DATA(TX_IPG_JAM_DEF));
1432
1433         /* configure the Serial Mode Register */
1434         reg = DATA_BLIND_VAL(DATA_BLIND_DEF)
1435                 | GM_SMOD_VLAN_ENA
1436                 | IPG_DATA_VAL(IPG_DATA_DEF);
1437
1438         gma_write16(hw, port, GM_SERIAL_MODE, reg);
1439
1440         /* physical address: used for pause frames */
1441         gma_set_addr(hw, port, GM_SRC_ADDR_1L, addr);
1442         /* virtual address for data */
1443         gma_set_addr(hw, port, GM_SRC_ADDR_2L, addr);
1444
1445         /* enable interrupt mask for counter overflows */
1446         gma_write16(hw, port, GM_TX_IRQ_MSK, 0);
1447         gma_write16(hw, port, GM_RX_IRQ_MSK, 0);
1448         gma_write16(hw, port, GM_TR_IRQ_MSK, 0);
1449
1450         /* Initialize Mac Fifo */
1451
1452         /* Configure Rx MAC FIFO */
1453         skge_write16(hw, SK_REG(port, RX_GMF_FL_MSK), RX_FF_FL_DEF_MSK);
1454         reg = GMF_OPER_ON | GMF_RX_F_FL_ON;
1455
1456         /* disable Rx GMAC FIFO Flush for YUKON-Lite Rev. A0 only */
1457         if (is_yukon_lite_a0(hw))
1458                 reg &= ~GMF_RX_F_FL_ON;
1459
1460         skge_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_CLR);
1461         skge_write16(hw, SK_REG(port, RX_GMF_CTRL_T), reg);
1462         /*
1463          * because Pause Packet Truncation in GMAC is not working
1464          * we have to increase the Flush Threshold to 64 bytes
1465          * in order to flush pause packets in Rx FIFO on Yukon-1
1466          */
1467         skge_write16(hw, SK_REG(port, RX_GMF_FL_THR), RX_GMF_FL_THR_DEF+1);
1468
1469         /* Configure Tx MAC FIFO */
1470         skge_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_CLR);
1471         skge_write16(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_OPER_ON);
1472 }
1473
1474 /* Go into power down mode */
1475 static void yukon_suspend(struct skge_hw *hw, int port)
1476 {
1477         u16 ctrl;
1478
1479         ctrl = gm_phy_read(hw, port, PHY_MARV_PHY_CTRL);
1480         ctrl |= PHY_M_PC_POL_R_DIS;
1481         gm_phy_write(hw, port, PHY_MARV_PHY_CTRL, ctrl);
1482
1483         ctrl = gm_phy_read(hw, port, PHY_MARV_CTRL);
1484         ctrl |= PHY_CT_RESET;
1485         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
1486
1487         /* switch IEEE compatible power down mode on */
1488         ctrl = gm_phy_read(hw, port, PHY_MARV_CTRL);
1489         ctrl |= PHY_CT_PDOWN;
1490         gm_phy_write(hw, port, PHY_MARV_CTRL, ctrl);
1491 }
1492
1493 static void yukon_stop(struct skge_port *skge)
1494 {
1495         struct skge_hw *hw = skge->hw;
1496         int port = skge->port;
1497
1498         skge_write8(hw, SK_REG(port, GMAC_IRQ_MSK), 0);
1499         yukon_reset(hw, port);
1500
1501         gma_write16(hw, port, GM_GP_CTRL,
1502                          gma_read16(hw, port, GM_GP_CTRL)
1503                          & ~(GM_GPCR_TX_ENA|GM_GPCR_RX_ENA));
1504         gma_read16(hw, port, GM_GP_CTRL);
1505
1506         yukon_suspend(hw, port);
1507
1508         /* set GPHY Control reset */
1509         skge_write8(hw, SK_REG(port, GPHY_CTRL), GPC_RST_SET);
1510         skge_write8(hw, SK_REG(port, GMAC_CTRL), GMC_RST_SET);
1511 }
1512
1513 static u16 yukon_speed(const struct skge_hw *hw __unused, u16 aux)
1514 {
1515         switch (aux & PHY_M_PS_SPEED_MSK) {
1516         case PHY_M_PS_SPEED_1000:
1517                 return SPEED_1000;
1518         case PHY_M_PS_SPEED_100:
1519                 return SPEED_100;
1520         default:
1521                 return SPEED_10;
1522         }
1523 }
1524
1525 static void yukon_link_up(struct skge_port *skge)
1526 {
1527         struct skge_hw *hw = skge->hw;
1528         int port = skge->port;
1529         u16 reg;
1530
1531         /* Enable Transmit FIFO Underrun */
1532         skge_write8(hw, SK_REG(port, GMAC_IRQ_MSK), GMAC_DEF_MSK);
1533
1534         reg = gma_read16(hw, port, GM_GP_CTRL);
1535         if (skge->duplex == DUPLEX_FULL || skge->autoneg == AUTONEG_ENABLE)
1536                 reg |= GM_GPCR_DUP_FULL;
1537
1538         /* enable Rx/Tx */
1539         reg |= GM_GPCR_RX_ENA | GM_GPCR_TX_ENA;
1540         gma_write16(hw, port, GM_GP_CTRL, reg);
1541
1542         gm_phy_write(hw, port, PHY_MARV_INT_MASK, PHY_M_IS_DEF_MSK);
1543         skge_link_up(skge);
1544 }
1545
1546 static void yukon_link_down(struct skge_port *skge)
1547 {
1548         struct skge_hw *hw = skge->hw;
1549         int port = skge->port;
1550         u16 ctrl;
1551
1552         ctrl = gma_read16(hw, port, GM_GP_CTRL);
1553         ctrl &= ~(GM_GPCR_RX_ENA | GM_GPCR_TX_ENA);
1554         gma_write16(hw, port, GM_GP_CTRL, ctrl);
1555
1556         if (skge->flow_status == FLOW_STAT_REM_SEND) {
1557                 ctrl = gm_phy_read(hw, port, PHY_MARV_AUNE_ADV);
1558                 ctrl |= PHY_M_AN_ASP;
1559                 /* restore Asymmetric Pause bit */
1560                 gm_phy_write(hw, port, PHY_MARV_AUNE_ADV, ctrl);
1561         }
1562
1563         skge_link_down(skge);
1564
1565         yukon_init(hw, port);
1566 }
1567
1568 static void yukon_phy_intr(struct skge_port *skge)
1569 {
1570         struct skge_hw *hw = skge->hw;
1571         int port = skge->port;
1572         const char *reason = NULL;
1573         u16 istatus, phystat;
1574
1575         istatus = gm_phy_read(hw, port, PHY_MARV_INT_STAT);
1576         phystat = gm_phy_read(hw, port, PHY_MARV_PHY_STAT);
1577
1578         DBGIO(PFX "%s: phy interrupt status 0x%x 0x%x\n",
1579              skge->netdev->name, istatus, phystat);
1580
1581         if (istatus & PHY_M_IS_AN_COMPL) {
1582                 if (gm_phy_read(hw, port, PHY_MARV_AUNE_LP)
1583                     & PHY_M_AN_RF) {
1584                         reason = "remote fault";
1585                         goto failed;
1586                 }
1587
1588                 if (gm_phy_read(hw, port, PHY_MARV_1000T_STAT) & PHY_B_1000S_MSF) {
1589                         reason = "master/slave fault";
1590                         goto failed;
1591                 }
1592
1593                 if (!(phystat & PHY_M_PS_SPDUP_RES)) {
1594                         reason = "speed/duplex";
1595                         goto failed;
1596                 }
1597
1598                 skge->duplex = (phystat & PHY_M_PS_FULL_DUP)
1599                         ? DUPLEX_FULL : DUPLEX_HALF;
1600                 skge->speed = yukon_speed(hw, phystat);
1601
1602                 /* We are using IEEE 802.3z/D5.0 Table 37-4 */
1603                 switch (phystat & PHY_M_PS_PAUSE_MSK) {
1604                 case PHY_M_PS_PAUSE_MSK:
1605                         skge->flow_status = FLOW_STAT_SYMMETRIC;
1606                         break;
1607                 case PHY_M_PS_RX_P_EN:
1608                         skge->flow_status = FLOW_STAT_REM_SEND;
1609                         break;
1610                 case PHY_M_PS_TX_P_EN:
1611                         skge->flow_status = FLOW_STAT_LOC_SEND;
1612                         break;
1613                 default:
1614                         skge->flow_status = FLOW_STAT_NONE;
1615                 }
1616
1617                 if (skge->flow_status == FLOW_STAT_NONE ||
1618                     (skge->speed < SPEED_1000 && skge->duplex == DUPLEX_HALF))
1619                         skge_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_OFF);
1620                 else
1621                         skge_write8(hw, SK_REG(port, GMAC_CTRL), GMC_PAUSE_ON);
1622                 yukon_link_up(skge);
1623                 return;
1624         }
1625
1626         if (istatus & PHY_M_IS_LSP_CHANGE)
1627                 skge->speed = yukon_speed(hw, phystat);
1628
1629         if (istatus & PHY_M_IS_DUP_CHANGE)
1630                 skge->duplex = (phystat & PHY_M_PS_FULL_DUP) ? DUPLEX_FULL : DUPLEX_HALF;
1631         if (istatus & PHY_M_IS_LST_CHANGE) {
1632                 if (phystat & PHY_M_PS_LINK_UP)
1633                         yukon_link_up(skge);
1634                 else
1635                         yukon_link_down(skge);
1636         }
1637         return;
1638  failed:
1639         DBG(PFX "%s: autonegotiation failed (%s)\n",
1640                skge->netdev->name, reason);
1641
1642         /* XXX restart autonegotiation? */
1643 }
1644
1645 static void skge_ramset(struct skge_hw *hw, u16 q, u32 start, size_t len)
1646 {
1647         u32 end;
1648
1649         start /= 8;
1650         len /= 8;
1651         end = start + len - 1;
1652
1653         skge_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR);
1654         skge_write32(hw, RB_ADDR(q, RB_START), start);
1655         skge_write32(hw, RB_ADDR(q, RB_WP), start);
1656         skge_write32(hw, RB_ADDR(q, RB_RP), start);
1657         skge_write32(hw, RB_ADDR(q, RB_END), end);
1658
1659         if (q == Q_R1 || q == Q_R2) {
1660                 /* Set thresholds on receive queue's */
1661                 skge_write32(hw, RB_ADDR(q, RB_RX_UTPP),
1662                              start + (2*len)/3);
1663                 skge_write32(hw, RB_ADDR(q, RB_RX_LTPP),
1664                              start + (len/3));
1665         } else {
1666                 /* Enable store & forward on Tx queue's because
1667                  * Tx FIFO is only 4K on Genesis and 1K on Yukon
1668                  */
1669                 skge_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_STFWD);
1670         }
1671
1672         skge_write8(hw, RB_ADDR(q, RB_CTRL), RB_ENA_OP_MD);
1673 }
1674
1675 /* Setup Bus Memory Interface */
1676 static void skge_qset(struct skge_port *skge, u16 q,
1677                       const struct skge_element *e)
1678 {
1679         struct skge_hw *hw = skge->hw;
1680         u32 watermark = 0x600;
1681         u64 base = skge->dma + (e->desc - skge->mem);
1682
1683         /* optimization to reduce window on 32bit/33mhz */
1684         if ((skge_read16(hw, B0_CTST) & (CS_BUS_CLOCK | CS_BUS_SLOT_SZ)) == 0)
1685                 watermark /= 2;
1686
1687         skge_write32(hw, Q_ADDR(q, Q_CSR), CSR_CLR_RESET);
1688         skge_write32(hw, Q_ADDR(q, Q_F), watermark);
1689         skge_write32(hw, Q_ADDR(q, Q_DA_H), (u32)(base >> 32));
1690         skge_write32(hw, Q_ADDR(q, Q_DA_L), (u32)base);
1691 }
1692
1693 void skge_free(struct net_device *dev)
1694 {
1695         struct skge_port *skge = netdev_priv(dev);
1696
1697         free(skge->rx_ring.start);
1698         skge->rx_ring.start = NULL;
1699
1700         free(skge->tx_ring.start);
1701         skge->tx_ring.start = NULL;
1702
1703         free_dma(skge->mem, RING_SIZE);
1704         skge->mem = NULL;
1705         skge->dma = 0;
1706 }
1707
1708 static int skge_up(struct net_device *dev)
1709 {
1710         struct skge_port *skge = netdev_priv(dev);
1711         struct skge_hw *hw = skge->hw;
1712         int port = skge->port;
1713         u32 chunk, ram_addr;
1714         int err;
1715
1716         DBG2(PFX "%s: enabling interface\n", dev->name);
1717
1718         skge->mem = malloc_dma(RING_SIZE, SKGE_RING_ALIGN);
1719         skge->dma = virt_to_bus(skge->mem);
1720         if (!skge->mem)
1721                 return -ENOMEM;
1722         memset(skge->mem, 0, RING_SIZE);
1723
1724         assert(!(skge->dma & 7));
1725
1726         /* FIXME: find out whether 64 bit gPXE will be loaded > 4GB */
1727         if ((u64)skge->dma >> 32 != ((u64) skge->dma + RING_SIZE) >> 32) {
1728                 DBG(PFX "pci_alloc_consistent region crosses 4G boundary\n");
1729                 err = -EINVAL;
1730                 goto err;
1731         }
1732
1733         err = skge_ring_alloc(&skge->rx_ring, skge->mem, skge->dma, NUM_RX_DESC);
1734         if (err)
1735                 goto err;
1736
1737         /* this call relies on e->iob and d->control to be 0
1738          * This is assured by calling memset() on skge->mem and using zalloc()
1739          * for the skge_element structures.
1740          */
1741         skge_rx_refill(dev);
1742
1743         err = skge_ring_alloc(&skge->tx_ring, skge->mem + RX_RING_SIZE,
1744                               skge->dma + RX_RING_SIZE, NUM_TX_DESC);
1745         if (err)
1746                 goto err;
1747
1748         /* Initialize MAC */
1749         if (hw->chip_id == CHIP_ID_GENESIS)
1750                 genesis_mac_init(hw, port);
1751         else
1752                 yukon_mac_init(hw, port);
1753
1754         /* Configure RAMbuffers - equally between ports and tx/rx */
1755         chunk = (hw->ram_size  - hw->ram_offset) / (hw->ports * 2);
1756         ram_addr = hw->ram_offset + 2 * chunk * port;
1757
1758         skge_ramset(hw, rxqaddr[port], ram_addr, chunk);
1759         skge_qset(skge, rxqaddr[port], skge->rx_ring.to_clean);
1760
1761         assert(!(skge->tx_ring.to_use != skge->tx_ring.to_clean));
1762         skge_ramset(hw, txqaddr[port], ram_addr+chunk, chunk);
1763         skge_qset(skge, txqaddr[port], skge->tx_ring.to_use);
1764
1765         /* Start receiver BMU */
1766         wmb();
1767         skge_write8(hw, Q_ADDR(rxqaddr[port], Q_CSR), CSR_START | CSR_IRQ_CL_F);
1768         skge_led(skge, LED_MODE_ON);
1769
1770         hw->intr_mask |= portmask[port];
1771         skge_write32(hw, B0_IMSK, hw->intr_mask);
1772
1773         return 0;
1774
1775  err:
1776         skge_rx_clean(skge);
1777         skge_free(dev);
1778
1779         return err;
1780 }
1781
1782 /* stop receiver */
1783 static void skge_rx_stop(struct skge_hw *hw, int port)
1784 {
1785         skge_write8(hw, Q_ADDR(rxqaddr[port], Q_CSR), CSR_STOP);
1786         skge_write32(hw, RB_ADDR(port ? Q_R2 : Q_R1, RB_CTRL),
1787                      RB_RST_SET|RB_DIS_OP_MD);
1788         skge_write32(hw, Q_ADDR(rxqaddr[port], Q_CSR), CSR_SET_RESET);
1789 }
1790
1791 static void skge_down(struct net_device *dev)
1792 {
1793         struct skge_port *skge = netdev_priv(dev);
1794         struct skge_hw *hw = skge->hw;
1795         int port = skge->port;
1796
1797         if (skge->mem == NULL)
1798                 return;
1799
1800         DBG2(PFX "%s: disabling interface\n", dev->name);
1801
1802         if (hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC)
1803                 skge->use_xm_link_timer = 0;
1804
1805         netdev_link_down(dev);
1806
1807         hw->intr_mask &= ~portmask[port];
1808         skge_write32(hw, B0_IMSK, hw->intr_mask);
1809
1810         skge_write8(skge->hw, SK_REG(skge->port, LNK_LED_REG), LED_OFF);
1811         if (hw->chip_id == CHIP_ID_GENESIS)
1812                 genesis_stop(skge);
1813         else
1814                 yukon_stop(skge);
1815
1816         /* Stop transmitter */
1817         skge_write8(hw, Q_ADDR(txqaddr[port], Q_CSR), CSR_STOP);
1818         skge_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL),
1819                      RB_RST_SET|RB_DIS_OP_MD);
1820
1821
1822         /* Disable Force Sync bit and Enable Alloc bit */
1823         skge_write8(hw, SK_REG(port, TXA_CTRL),
1824                     TXA_DIS_FSYNC | TXA_DIS_ALLOC | TXA_STOP_RC);
1825
1826         /* Stop Interval Timer and Limit Counter of Tx Arbiter */
1827         skge_write32(hw, SK_REG(port, TXA_ITI_INI), 0L);
1828         skge_write32(hw, SK_REG(port, TXA_LIM_INI), 0L);
1829
1830         /* Reset PCI FIFO */
1831         skge_write32(hw, Q_ADDR(txqaddr[port], Q_CSR), CSR_SET_RESET);
1832         skge_write32(hw, RB_ADDR(txqaddr[port], RB_CTRL), RB_RST_SET);
1833
1834         /* Reset the RAM Buffer async Tx queue */
1835         skge_write8(hw, RB_ADDR(port == 0 ? Q_XA1 : Q_XA2, RB_CTRL), RB_RST_SET);
1836
1837         skge_rx_stop(hw, port);
1838
1839         if (hw->chip_id == CHIP_ID_GENESIS) {
1840                 skge_write8(hw, SK_REG(port, TX_MFF_CTRL2), MFF_RST_SET);
1841                 skge_write8(hw, SK_REG(port, RX_MFF_CTRL2), MFF_RST_SET);
1842         } else {
1843                 skge_write8(hw, SK_REG(port, RX_GMF_CTRL_T), GMF_RST_SET);
1844                 skge_write8(hw, SK_REG(port, TX_GMF_CTRL_T), GMF_RST_SET);
1845         }
1846
1847         skge_led(skge, LED_MODE_OFF);
1848
1849         skge_tx_clean(dev);
1850
1851         skge_rx_clean(skge);
1852
1853         skge_free(dev);
1854         return;
1855 }
1856
1857 static inline int skge_tx_avail(const struct skge_ring *ring)
1858 {
1859         mb();
1860         return ((ring->to_clean > ring->to_use) ? 0 : NUM_TX_DESC)
1861                 + (ring->to_clean - ring->to_use) - 1;
1862 }
1863
1864 static int skge_xmit_frame(struct net_device *dev, struct io_buffer *iob)
1865 {
1866         struct skge_port *skge = netdev_priv(dev);
1867         struct skge_hw *hw = skge->hw;
1868         struct skge_element *e;
1869         struct skge_tx_desc *td;
1870         u32 control, len;
1871         u64 map;
1872
1873         if (skge_tx_avail(&skge->tx_ring) < 1)
1874                 return -EBUSY;
1875
1876         e = skge->tx_ring.to_use;
1877         td = e->desc;
1878         assert(!(td->control & BMU_OWN));
1879         e->iob = iob;
1880         len = iob_len(iob);
1881         map = virt_to_bus(iob->data);
1882
1883         td->dma_lo = map;
1884         td->dma_hi = map >> 32;
1885
1886         control = BMU_CHECK;
1887
1888         control |= BMU_EOF| BMU_IRQ_EOF;
1889         /* Make sure all the descriptors written */
1890         wmb();
1891         td->control = BMU_OWN | BMU_SW | BMU_STF | control | len;
1892         wmb();
1893
1894         skge_write8(hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_START);
1895
1896         DBGIO(PFX "%s: tx queued, slot %td, len %d\n",
1897              dev->name, e - skge->tx_ring.start, (unsigned int)len);
1898
1899         skge->tx_ring.to_use = e->next;
1900         wmb();
1901
1902         if (skge_tx_avail(&skge->tx_ring) <= 1) {
1903                 DBG(PFX "%s: transmit queue full\n", dev->name);
1904         }
1905
1906         return 0;
1907 }
1908
1909 /* Free all buffers in transmit ring */
1910 static void skge_tx_clean(struct net_device *dev)
1911 {
1912         struct skge_port *skge = netdev_priv(dev);
1913         struct skge_element *e;
1914
1915         for (e = skge->tx_ring.to_clean; e != skge->tx_ring.to_use; e = e->next) {
1916                 struct skge_tx_desc *td = e->desc;
1917                 td->control = 0;
1918         }
1919
1920         skge->tx_ring.to_clean = e;
1921 }
1922
1923 static const u8 pause_mc_addr[ETH_ALEN] = { 0x1, 0x80, 0xc2, 0x0, 0x0, 0x1 };
1924
1925 static inline u16 phy_length(const struct skge_hw *hw, u32 status)
1926 {
1927         if (hw->chip_id == CHIP_ID_GENESIS)
1928                 return status >> XMR_FS_LEN_SHIFT;
1929         else
1930                 return status >> GMR_FS_LEN_SHIFT;
1931 }
1932
1933 static inline int bad_phy_status(const struct skge_hw *hw, u32 status)
1934 {
1935         if (hw->chip_id == CHIP_ID_GENESIS)
1936                 return (status & (XMR_FS_ERR | XMR_FS_2L_VLAN)) != 0;
1937         else
1938                 return (status & GMR_FS_ANY_ERR) ||
1939                         (status & GMR_FS_RX_OK) == 0;
1940 }
1941
1942 /* Free all buffers in Tx ring which are no longer owned by device */
1943 static void skge_tx_done(struct net_device *dev)
1944 {
1945         struct skge_port *skge = netdev_priv(dev);
1946         struct skge_ring *ring = &skge->tx_ring;
1947         struct skge_element *e;
1948
1949         skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
1950
1951         for (e = ring->to_clean; e != ring->to_use; e = e->next) {
1952                 u32 control = ((const struct skge_tx_desc *) e->desc)->control;
1953
1954                 if (control & BMU_OWN)
1955                         break;
1956
1957                 netdev_tx_complete(dev, e->iob);
1958         }
1959         skge->tx_ring.to_clean = e;
1960
1961         /* Can run lockless until we need to synchronize to restart queue. */
1962         mb();
1963 }
1964
1965 static void skge_rx_refill(struct net_device *dev)
1966 {
1967         struct skge_port *skge = netdev_priv(dev);
1968         struct skge_ring *ring = &skge->rx_ring;
1969         struct skge_element *e;
1970         struct io_buffer *iob;
1971         struct skge_rx_desc *rd;
1972         u32 control;
1973         int i;
1974
1975         for (i = 0; i < NUM_RX_DESC; i++) {
1976                 e = ring->to_clean;
1977                 rd = e->desc;
1978                 iob = e->iob;
1979                 control = rd->control;
1980
1981                 /* nothing to do here */
1982                 if (iob || (control & BMU_OWN))
1983                         continue;
1984
1985                 DBG2("refilling rx desc %d: ", (ring->to_clean - ring->start));
1986
1987                 iob = alloc_iob(RX_BUF_SIZE);
1988                 if (iob) {
1989                         skge_rx_setup(skge, e, iob, RX_BUF_SIZE);
1990                 } else {
1991                         DBG("descr %d: alloc_iob() failed\n",
1992                              (ring->to_clean - ring->start));
1993                         /* We pass the descriptor to the NIC even if the
1994                          * allocation failed. The card will stop as soon as it
1995                          * encounters a descriptor with the OWN bit set to 0,
1996                          * thus never getting to the next descriptor that might
1997                          * contain a valid io_buffer. This would effectively
1998                          * stall the receive.
1999                          */
2000                         skge_rx_setup(skge, e, NULL, 0);
2001                 }
2002
2003                 ring->to_clean = e->next;
2004         }
2005 }
2006
2007 static void skge_rx_done(struct net_device *dev)
2008 {
2009         struct skge_port *skge = netdev_priv(dev);
2010         struct skge_ring *ring = &skge->rx_ring;
2011         struct skge_rx_desc *rd;
2012         struct skge_element *e;
2013         struct io_buffer *iob;
2014         u32 control;
2015         u16 len;
2016         int i;
2017
2018         e = ring->to_clean;
2019         for (i = 0; i < NUM_RX_DESC; i++) {
2020                 iob = e->iob;
2021                 rd = e->desc;
2022
2023                 rmb();
2024                 control = rd->control;
2025
2026                 if ((control & BMU_OWN))
2027                         break;
2028
2029                 if (!iob)
2030                         continue;
2031
2032                 len = control & BMU_BBC;
2033
2034                 /* catch RX errors */
2035                 if ((bad_phy_status(skge->hw, rd->status)) ||
2036                    (phy_length(skge->hw, rd->status) != len)) {
2037                         /* report receive errors */
2038                         DBG("rx error\n");
2039                         netdev_rx_err(dev, iob, -EIO);
2040                 } else {
2041                         DBG2("received packet, len %d\n", len);
2042                         iob_put(iob, len);
2043                         netdev_rx(dev, iob);
2044                 }
2045
2046                 /* io_buffer passed to core, make sure we don't reuse it */
2047                 e->iob = NULL;
2048
2049                 e = e->next;
2050         }
2051         skge_rx_refill(dev);
2052 }
2053
2054 static void skge_poll(struct net_device *dev)
2055 {
2056         struct skge_port *skge = netdev_priv(dev);
2057         struct skge_hw *hw = skge->hw;
2058         u32 status;
2059
2060         /* reading this register ACKs interrupts */
2061         status = skge_read32(hw, B0_SP_ISRC);
2062
2063         /* Link event? */
2064         if (status & IS_EXT_REG) {
2065                 skge_phyirq(hw);
2066                 if (skge->use_xm_link_timer)
2067                         xm_link_timer(skge);
2068         }
2069
2070         skge_tx_done(dev);
2071
2072         skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
2073
2074         skge_rx_done(dev);
2075
2076         /* restart receiver */
2077         wmb();
2078         skge_write8(hw, Q_ADDR(rxqaddr[skge->port], Q_CSR), CSR_START);
2079
2080         skge_read32(hw, B0_IMSK);
2081
2082         return;
2083 }
2084
2085 static void skge_phyirq(struct skge_hw *hw)
2086 {
2087         int port;
2088
2089         for (port = 0; port < hw->ports; port++) {
2090                 struct net_device *dev = hw->dev[port];
2091                 struct skge_port *skge = netdev_priv(dev);
2092
2093                 if (hw->chip_id != CHIP_ID_GENESIS)
2094                         yukon_phy_intr(skge);
2095                 else if (hw->phy_type == SK_PHY_BCOM)
2096                         bcom_phy_intr(skge);
2097         }
2098
2099         hw->intr_mask |= IS_EXT_REG;
2100         skge_write32(hw, B0_IMSK, hw->intr_mask);
2101         skge_read32(hw, B0_IMSK);
2102 }
2103
2104 static const struct {
2105         u8 id;
2106         const char *name;
2107 } skge_chips[] = {
2108         { CHIP_ID_GENESIS,      "Genesis" },
2109         { CHIP_ID_YUKON,         "Yukon" },
2110         { CHIP_ID_YUKON_LITE,    "Yukon-Lite"},
2111         { CHIP_ID_YUKON_LP,      "Yukon-LP"},
2112 };
2113
2114 static const char *skge_board_name(const struct skge_hw *hw)
2115 {
2116         unsigned int i;
2117         static char buf[16];
2118
2119         for (i = 0; i < ARRAY_SIZE(skge_chips); i++)
2120                 if (skge_chips[i].id == hw->chip_id)
2121                         return skge_chips[i].name;
2122
2123         snprintf(buf, sizeof buf, "chipid 0x%x", hw->chip_id);
2124         return buf;
2125 }
2126
2127
2128 /*
2129  * Setup the board data structure, but don't bring up
2130  * the port(s)
2131  */
2132 static int skge_reset(struct skge_hw *hw)
2133 {
2134         u32 reg;
2135         u16 ctst, pci_status;
2136         u8 t8, mac_cfg, pmd_type;
2137         int i;
2138
2139         ctst = skge_read16(hw, B0_CTST);
2140
2141         /* do a SW reset */
2142         skge_write8(hw, B0_CTST, CS_RST_SET);
2143         skge_write8(hw, B0_CTST, CS_RST_CLR);
2144
2145         /* clear PCI errors, if any */
2146         skge_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2147         skge_write8(hw, B2_TST_CTRL2, 0);
2148
2149         pci_read_config_word(hw->pdev, PCI_STATUS, &pci_status);
2150         pci_write_config_word(hw->pdev, PCI_STATUS,
2151                               pci_status | PCI_STATUS_ERROR_BITS);
2152         skge_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2153         skge_write8(hw, B0_CTST, CS_MRST_CLR);
2154
2155         /* restore CLK_RUN bits (for Yukon-Lite) */
2156         skge_write16(hw, B0_CTST,
2157                      ctst & (CS_CLK_RUN_HOT|CS_CLK_RUN_RST|CS_CLK_RUN_ENA));
2158
2159         hw->chip_id = skge_read8(hw, B2_CHIP_ID);
2160         hw->phy_type = skge_read8(hw, B2_E_1) & 0xf;
2161         pmd_type = skge_read8(hw, B2_PMD_TYP);
2162         hw->copper = (pmd_type == 'T' || pmd_type == '1');
2163
2164         switch (hw->chip_id) {
2165         case CHIP_ID_GENESIS:
2166                 switch (hw->phy_type) {
2167                 case SK_PHY_XMAC:
2168                         hw->phy_addr = PHY_ADDR_XMAC;
2169                         break;
2170                 case SK_PHY_BCOM:
2171                         hw->phy_addr = PHY_ADDR_BCOM;
2172                         break;
2173                 default:
2174                         DBG(PFX "unsupported phy type 0x%x\n",
2175                                hw->phy_type);
2176                         return -EOPNOTSUPP;
2177                 }
2178                 break;
2179
2180         case CHIP_ID_YUKON:
2181         case CHIP_ID_YUKON_LITE:
2182         case CHIP_ID_YUKON_LP:
2183                 if (hw->phy_type < SK_PHY_MARV_COPPER && pmd_type != 'S')
2184                         hw->copper = 1;
2185
2186                 hw->phy_addr = PHY_ADDR_MARV;
2187                 break;
2188
2189         default:
2190                 DBG(PFX "unsupported chip type 0x%x\n",
2191                        hw->chip_id);
2192                 return -EOPNOTSUPP;
2193         }
2194
2195         mac_cfg = skge_read8(hw, B2_MAC_CFG);
2196         hw->ports = (mac_cfg & CFG_SNG_MAC) ? 1 : 2;
2197         hw->chip_rev = (mac_cfg & CFG_CHIP_R_MSK) >> 4;
2198
2199         /* read the adapters RAM size */
2200         t8 = skge_read8(hw, B2_E_0);
2201         if (hw->chip_id == CHIP_ID_GENESIS) {
2202                 if (t8 == 3) {
2203                         /* special case: 4 x 64k x 36, offset = 0x80000 */
2204                         hw->ram_size = 0x100000;
2205                         hw->ram_offset = 0x80000;
2206                 } else
2207                         hw->ram_size = t8 * 512;
2208         }
2209         else if (t8 == 0)
2210                 hw->ram_size = 0x20000;
2211         else
2212                 hw->ram_size = t8 * 4096;
2213
2214         hw->intr_mask = IS_HW_ERR;
2215
2216         /* Use PHY IRQ for all but fiber based Genesis board */
2217         if (!(hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC))
2218                 hw->intr_mask |= IS_EXT_REG;
2219
2220         if (hw->chip_id == CHIP_ID_GENESIS)
2221                 genesis_init(hw);
2222         else {
2223                 /* switch power to VCC (WA for VAUX problem) */
2224                 skge_write8(hw, B0_POWER_CTRL,
2225                             PC_VAUX_ENA | PC_VCC_ENA | PC_VAUX_OFF | PC_VCC_ON);
2226
2227                 /* avoid boards with stuck Hardware error bits */
2228                 if ((skge_read32(hw, B0_ISRC) & IS_HW_ERR) &&
2229                     (skge_read32(hw, B0_HWE_ISRC) & IS_IRQ_SENSOR)) {
2230                         DBG(PFX "stuck hardware sensor bit\n");
2231                         hw->intr_mask &= ~IS_HW_ERR;
2232                 }
2233
2234                 /* Clear PHY COMA */
2235                 skge_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
2236                 pci_read_config_dword(hw->pdev, PCI_DEV_REG1, &reg);
2237                 reg &= ~PCI_PHY_COMA;
2238                 pci_write_config_dword(hw->pdev, PCI_DEV_REG1, reg);
2239                 skge_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
2240
2241
2242                 for (i = 0; i < hw->ports; i++) {
2243                         skge_write16(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_SET);
2244                         skge_write16(hw, SK_REG(i, GMAC_LINK_CTRL), GMLC_RST_CLR);
2245                 }
2246         }
2247
2248         /* turn off hardware timer (unused) */
2249         skge_write8(hw, B2_TI_CTRL, TIM_STOP);
2250         skge_write8(hw, B2_TI_CTRL, TIM_CLR_IRQ);
2251         skge_write8(hw, B0_LED, LED_STAT_ON);
2252
2253         /* enable the Tx Arbiters */
2254         for (i = 0; i < hw->ports; i++)
2255                 skge_write8(hw, SK_REG(i, TXA_CTRL), TXA_ENA_ARB);
2256
2257         /* Initialize ram interface */
2258         skge_write16(hw, B3_RI_CTRL, RI_RST_CLR);
2259
2260         skge_write8(hw, B3_RI_WTO_R1, SK_RI_TO_53);
2261         skge_write8(hw, B3_RI_WTO_XA1, SK_RI_TO_53);
2262         skge_write8(hw, B3_RI_WTO_XS1, SK_RI_TO_53);
2263         skge_write8(hw, B3_RI_RTO_R1, SK_RI_TO_53);
2264         skge_write8(hw, B3_RI_RTO_XA1, SK_RI_TO_53);
2265         skge_write8(hw, B3_RI_RTO_XS1, SK_RI_TO_53);
2266         skge_write8(hw, B3_RI_WTO_R2, SK_RI_TO_53);
2267         skge_write8(hw, B3_RI_WTO_XA2, SK_RI_TO_53);
2268         skge_write8(hw, B3_RI_WTO_XS2, SK_RI_TO_53);
2269         skge_write8(hw, B3_RI_RTO_R2, SK_RI_TO_53);
2270         skge_write8(hw, B3_RI_RTO_XA2, SK_RI_TO_53);
2271         skge_write8(hw, B3_RI_RTO_XS2, SK_RI_TO_53);
2272
2273         skge_write32(hw, B0_HWE_IMSK, IS_ERR_MSK);
2274
2275         /* Set interrupt moderation for Transmit only
2276          * Receive interrupts avoided by NAPI
2277          */
2278         skge_write32(hw, B2_IRQM_MSK, IS_XA1_F|IS_XA2_F);
2279         skge_write32(hw, B2_IRQM_INI, skge_usecs2clk(hw, 100));
2280         skge_write32(hw, B2_IRQM_CTRL, TIM_START);
2281
2282         skge_write32(hw, B0_IMSK, hw->intr_mask);
2283
2284         for (i = 0; i < hw->ports; i++) {
2285                 if (hw->chip_id == CHIP_ID_GENESIS)
2286                         genesis_reset(hw, i);
2287                 else
2288                         yukon_reset(hw, i);
2289         }
2290
2291         return 0;
2292 }
2293
2294 /* Initialize network device */
2295 static struct net_device *skge_devinit(struct skge_hw *hw, int port,
2296                                        int highmem __unused)
2297 {
2298         struct skge_port *skge;
2299         struct net_device *dev = alloc_etherdev(sizeof(*skge));
2300
2301         if (!dev) {
2302                 DBG(PFX "etherdev alloc failed\n");
2303                 return NULL;
2304         }
2305
2306         dev->dev = &hw->pdev->dev;
2307
2308         skge = netdev_priv(dev);
2309         skge->netdev = dev;
2310         skge->hw = hw;
2311
2312         /* Auto speed and flow control */
2313         skge->autoneg = AUTONEG_ENABLE;
2314         skge->flow_control = FLOW_MODE_SYM_OR_REM;
2315         skge->duplex = -1;
2316         skge->speed = -1;
2317         skge->advertising = skge_supported_modes(hw);
2318
2319         hw->dev[port] = dev;
2320
2321         skge->port = port;
2322
2323         /* read the mac address */
2324         memcpy(dev->hw_addr, (void *) (hw->regs + B2_MAC_1 + port*8), ETH_ALEN);
2325
2326         /* device is off until link detection */
2327         netdev_link_down(dev);
2328
2329         return dev;
2330 }
2331
2332 static void skge_show_addr(struct net_device *dev)
2333 {
2334         DBG2(PFX "%s: addr %s\n",
2335              dev->name, netdev_addr(dev));
2336 }
2337
2338 static int skge_probe(struct pci_device *pdev,
2339                                 const struct pci_device_id *ent __unused)
2340 {
2341         struct net_device *dev, *dev1;
2342         struct skge_hw *hw;
2343         int err, using_dac = 0;
2344
2345         adjust_pci_device(pdev);
2346
2347         err = -ENOMEM;
2348         hw = zalloc(sizeof(*hw));
2349         if (!hw) {
2350                 DBG(PFX "cannot allocate hardware struct\n");
2351                 goto err_out_free_regions;
2352         }
2353
2354         hw->pdev = pdev;
2355
2356         hw->regs = (u32)ioremap(pci_bar_start(pdev, PCI_BASE_ADDRESS_0),
2357                                 SKGE_REG_SIZE);
2358         if (!hw->regs) {
2359                 DBG(PFX "cannot map device registers\n");
2360                 goto err_out_free_hw;
2361         }
2362
2363         err = skge_reset(hw);
2364         if (err)
2365                 goto err_out_iounmap;
2366
2367         DBG(PFX " addr 0x%llx irq %d chip %s rev %d\n",
2368             (unsigned long long)pdev->ioaddr, pdev->irq,
2369             skge_board_name(hw), hw->chip_rev);
2370
2371         dev = skge_devinit(hw, 0, using_dac);
2372         if (!dev)
2373                 goto err_out_led_off;
2374
2375         netdev_init ( dev, &skge_operations );
2376
2377         err = register_netdev(dev);
2378         if (err) {
2379                 DBG(PFX "cannot register net device\n");
2380                 goto err_out_free_netdev;
2381         }
2382
2383         skge_show_addr(dev);
2384
2385         if (hw->ports > 1 && (dev1 = skge_devinit(hw, 1, using_dac))) {
2386                 if (register_netdev(dev1) == 0)
2387                         skge_show_addr(dev1);
2388                 else {
2389                         /* Failure to register second port need not be fatal */
2390                         DBG(PFX "register of second port failed\n");
2391                         hw->dev[1] = NULL;
2392                         netdev_nullify(dev1);
2393                         netdev_put(dev1);
2394                 }
2395         }
2396         pci_set_drvdata(pdev, hw);
2397
2398         return 0;
2399
2400 err_out_free_netdev:
2401         netdev_nullify(dev);
2402         netdev_put(dev);
2403 err_out_led_off:
2404         skge_write16(hw, B0_LED, LED_STAT_OFF);
2405 err_out_iounmap:
2406         iounmap((void*)hw->regs);
2407 err_out_free_hw:
2408         free(hw);
2409 err_out_free_regions:
2410         pci_set_drvdata(pdev, NULL);
2411         return err;
2412 }
2413
2414 static void skge_remove(struct pci_device *pdev)
2415 {
2416         struct skge_hw *hw  = pci_get_drvdata(pdev);
2417         struct net_device *dev0, *dev1;
2418
2419         if (!hw)
2420                 return;
2421
2422         if ((dev1 = hw->dev[1]))
2423                 unregister_netdev(dev1);
2424         dev0 = hw->dev[0];
2425         unregister_netdev(dev0);
2426
2427         hw->intr_mask = 0;
2428         skge_write32(hw, B0_IMSK, 0);
2429         skge_read32(hw, B0_IMSK);
2430
2431         skge_write16(hw, B0_LED, LED_STAT_OFF);
2432         skge_write8(hw, B0_CTST, CS_RST_SET);
2433
2434         if (dev1) {
2435                 netdev_nullify(dev1);
2436                 netdev_put(dev1);
2437         }
2438         netdev_nullify(dev0);
2439         netdev_put(dev0);
2440
2441         iounmap((void*)hw->regs);
2442         free(hw);
2443         pci_set_drvdata(pdev, NULL);
2444 }
2445
2446 /*
2447  * Enable or disable IRQ masking.
2448  *
2449  * @v netdev            Device to control.
2450  * @v enable            Zero to mask off IRQ, non-zero to enable IRQ.
2451  *
2452  * This is a gPXE Network Driver API function.
2453  */
2454 static void skge_net_irq ( struct net_device *dev, int enable ) {
2455         struct skge_port *skge = netdev_priv(dev);
2456         struct skge_hw *hw = skge->hw;
2457
2458         if (enable)
2459                 hw->intr_mask |= portmask[skge->port];
2460         else
2461                 hw->intr_mask &= ~portmask[skge->port];
2462         skge_write32(hw, B0_IMSK, hw->intr_mask);
2463 }
2464
2465 struct pci_driver skge_driver __pci_driver = {
2466         .ids      = skge_id_table,
2467         .id_count = ( sizeof (skge_id_table) / sizeof (skge_id_table[0]) ),
2468         .probe    = skge_probe,
2469         .remove   = skge_remove
2470 };
2471