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