[SK_BUFF]: Introduce skb_copy_from_linear_data{_offset}
[linux-3.10.git] / drivers / net / b44.c
1 /* b44.c: Broadcom 4400 device driver.
2  *
3  * Copyright (C) 2002 David S. Miller (davem@redhat.com)
4  * Fixed by Pekka Pietikainen (pp@ee.oulu.fi)
5  * Copyright (C) 2006 Broadcom Corporation.
6  *
7  * Distribute under GPL.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/types.h>
14 #include <linux/netdevice.h>
15 #include <linux/ethtool.h>
16 #include <linux/mii.h>
17 #include <linux/if_ether.h>
18 #include <linux/etherdevice.h>
19 #include <linux/pci.h>
20 #include <linux/delay.h>
21 #include <linux/init.h>
22 #include <linux/dma-mapping.h>
23
24 #include <asm/uaccess.h>
25 #include <asm/io.h>
26 #include <asm/irq.h>
27
28 #include "b44.h"
29
30 #define DRV_MODULE_NAME         "b44"
31 #define PFX DRV_MODULE_NAME     ": "
32 #define DRV_MODULE_VERSION      "1.01"
33 #define DRV_MODULE_RELDATE      "Jun 16, 2006"
34
35 #define B44_DEF_MSG_ENABLE        \
36         (NETIF_MSG_DRV          | \
37          NETIF_MSG_PROBE        | \
38          NETIF_MSG_LINK         | \
39          NETIF_MSG_TIMER        | \
40          NETIF_MSG_IFDOWN       | \
41          NETIF_MSG_IFUP         | \
42          NETIF_MSG_RX_ERR       | \
43          NETIF_MSG_TX_ERR)
44
45 /* length of time before we decide the hardware is borked,
46  * and dev->tx_timeout() should be called to fix the problem
47  */
48 #define B44_TX_TIMEOUT                  (5 * HZ)
49
50 /* hardware minimum and maximum for a single frame's data payload */
51 #define B44_MIN_MTU                     60
52 #define B44_MAX_MTU                     1500
53
54 #define B44_RX_RING_SIZE                512
55 #define B44_DEF_RX_RING_PENDING         200
56 #define B44_RX_RING_BYTES       (sizeof(struct dma_desc) * \
57                                  B44_RX_RING_SIZE)
58 #define B44_TX_RING_SIZE                512
59 #define B44_DEF_TX_RING_PENDING         (B44_TX_RING_SIZE - 1)
60 #define B44_TX_RING_BYTES       (sizeof(struct dma_desc) * \
61                                  B44_TX_RING_SIZE)
62
63 #define TX_RING_GAP(BP) \
64         (B44_TX_RING_SIZE - (BP)->tx_pending)
65 #define TX_BUFFS_AVAIL(BP)                                              \
66         (((BP)->tx_cons <= (BP)->tx_prod) ?                             \
67           (BP)->tx_cons + (BP)->tx_pending - (BP)->tx_prod :            \
68           (BP)->tx_cons - (BP)->tx_prod - TX_RING_GAP(BP))
69 #define NEXT_TX(N)              (((N) + 1) & (B44_TX_RING_SIZE - 1))
70
71 #define RX_PKT_BUF_SZ           (1536 + bp->rx_offset + 64)
72 #define TX_PKT_BUF_SZ           (B44_MAX_MTU + ETH_HLEN + 8)
73
74 /* minimum number of free TX descriptors required to wake up TX process */
75 #define B44_TX_WAKEUP_THRESH            (B44_TX_RING_SIZE / 4)
76
77 /* b44 internal pattern match filter info */
78 #define B44_PATTERN_BASE        0x400
79 #define B44_PATTERN_SIZE        0x80
80 #define B44_PMASK_BASE          0x600
81 #define B44_PMASK_SIZE          0x10
82 #define B44_MAX_PATTERNS        16
83 #define B44_ETHIPV6UDP_HLEN     62
84 #define B44_ETHIPV4UDP_HLEN     42
85
86 static char version[] __devinitdata =
87         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
88
89 MODULE_AUTHOR("Florian Schirmer, Pekka Pietikainen, David S. Miller");
90 MODULE_DESCRIPTION("Broadcom 4400 10/100 PCI ethernet driver");
91 MODULE_LICENSE("GPL");
92 MODULE_VERSION(DRV_MODULE_VERSION);
93
94 static int b44_debug = -1;      /* -1 == use B44_DEF_MSG_ENABLE as value */
95 module_param(b44_debug, int, 0);
96 MODULE_PARM_DESC(b44_debug, "B44 bitmapped debugging message enable value");
97
98 static struct pci_device_id b44_pci_tbl[] = {
99         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401,
100           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
101         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B0,
102           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
103         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B1,
104           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
105         { }     /* terminate list with empty entry */
106 };
107
108 MODULE_DEVICE_TABLE(pci, b44_pci_tbl);
109
110 static void b44_halt(struct b44 *);
111 static void b44_init_rings(struct b44 *);
112
113 #define B44_FULL_RESET          1
114 #define B44_FULL_RESET_SKIP_PHY 2
115 #define B44_PARTIAL_RESET       3
116
117 static void b44_init_hw(struct b44 *, int);
118
119 static int dma_desc_align_mask;
120 static int dma_desc_sync_size;
121
122 static const char b44_gstrings[][ETH_GSTRING_LEN] = {
123 #define _B44(x...)      # x,
124 B44_STAT_REG_DECLARE
125 #undef _B44
126 };
127
128 static inline void b44_sync_dma_desc_for_device(struct pci_dev *pdev,
129                                                 dma_addr_t dma_base,
130                                                 unsigned long offset,
131                                                 enum dma_data_direction dir)
132 {
133         dma_sync_single_range_for_device(&pdev->dev, dma_base,
134                                          offset & dma_desc_align_mask,
135                                          dma_desc_sync_size, dir);
136 }
137
138 static inline void b44_sync_dma_desc_for_cpu(struct pci_dev *pdev,
139                                              dma_addr_t dma_base,
140                                              unsigned long offset,
141                                              enum dma_data_direction dir)
142 {
143         dma_sync_single_range_for_cpu(&pdev->dev, dma_base,
144                                       offset & dma_desc_align_mask,
145                                       dma_desc_sync_size, dir);
146 }
147
148 static inline unsigned long br32(const struct b44 *bp, unsigned long reg)
149 {
150         return readl(bp->regs + reg);
151 }
152
153 static inline void bw32(const struct b44 *bp,
154                         unsigned long reg, unsigned long val)
155 {
156         writel(val, bp->regs + reg);
157 }
158
159 static int b44_wait_bit(struct b44 *bp, unsigned long reg,
160                         u32 bit, unsigned long timeout, const int clear)
161 {
162         unsigned long i;
163
164         for (i = 0; i < timeout; i++) {
165                 u32 val = br32(bp, reg);
166
167                 if (clear && !(val & bit))
168                         break;
169                 if (!clear && (val & bit))
170                         break;
171                 udelay(10);
172         }
173         if (i == timeout) {
174                 printk(KERN_ERR PFX "%s: BUG!  Timeout waiting for bit %08x of register "
175                        "%lx to %s.\n",
176                        bp->dev->name,
177                        bit, reg,
178                        (clear ? "clear" : "set"));
179                 return -ENODEV;
180         }
181         return 0;
182 }
183
184 /* Sonics SiliconBackplane support routines.  ROFL, you should see all the
185  * buzz words used on this company's website :-)
186  *
187  * All of these routines must be invoked with bp->lock held and
188  * interrupts disabled.
189  */
190
191 #define SB_PCI_DMA             0x40000000      /* Client Mode PCI memory access space (1 GB) */
192 #define BCM4400_PCI_CORE_ADDR  0x18002000      /* Address of PCI core on BCM4400 cards */
193
194 static u32 ssb_get_core_rev(struct b44 *bp)
195 {
196         return (br32(bp, B44_SBIDHIGH) & SBIDHIGH_RC_MASK);
197 }
198
199 static u32 ssb_pci_setup(struct b44 *bp, u32 cores)
200 {
201         u32 bar_orig, pci_rev, val;
202
203         pci_read_config_dword(bp->pdev, SSB_BAR0_WIN, &bar_orig);
204         pci_write_config_dword(bp->pdev, SSB_BAR0_WIN, BCM4400_PCI_CORE_ADDR);
205         pci_rev = ssb_get_core_rev(bp);
206
207         val = br32(bp, B44_SBINTVEC);
208         val |= cores;
209         bw32(bp, B44_SBINTVEC, val);
210
211         val = br32(bp, SSB_PCI_TRANS_2);
212         val |= SSB_PCI_PREF | SSB_PCI_BURST;
213         bw32(bp, SSB_PCI_TRANS_2, val);
214
215         pci_write_config_dword(bp->pdev, SSB_BAR0_WIN, bar_orig);
216
217         return pci_rev;
218 }
219
220 static void ssb_core_disable(struct b44 *bp)
221 {
222         if (br32(bp, B44_SBTMSLOW) & SBTMSLOW_RESET)
223                 return;
224
225         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_CLOCK));
226         b44_wait_bit(bp, B44_SBTMSLOW, SBTMSLOW_REJECT, 100000, 0);
227         b44_wait_bit(bp, B44_SBTMSHIGH, SBTMSHIGH_BUSY, 100000, 1);
228         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_FGC | SBTMSLOW_CLOCK |
229                             SBTMSLOW_REJECT | SBTMSLOW_RESET));
230         br32(bp, B44_SBTMSLOW);
231         udelay(1);
232         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_REJECT | SBTMSLOW_RESET));
233         br32(bp, B44_SBTMSLOW);
234         udelay(1);
235 }
236
237 static void ssb_core_reset(struct b44 *bp)
238 {
239         u32 val;
240
241         ssb_core_disable(bp);
242         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_RESET | SBTMSLOW_CLOCK | SBTMSLOW_FGC));
243         br32(bp, B44_SBTMSLOW);
244         udelay(1);
245
246         /* Clear SERR if set, this is a hw bug workaround.  */
247         if (br32(bp, B44_SBTMSHIGH) & SBTMSHIGH_SERR)
248                 bw32(bp, B44_SBTMSHIGH, 0);
249
250         val = br32(bp, B44_SBIMSTATE);
251         if (val & (SBIMSTATE_IBE | SBIMSTATE_TO))
252                 bw32(bp, B44_SBIMSTATE, val & ~(SBIMSTATE_IBE | SBIMSTATE_TO));
253
254         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK | SBTMSLOW_FGC));
255         br32(bp, B44_SBTMSLOW);
256         udelay(1);
257
258         bw32(bp, B44_SBTMSLOW, (SBTMSLOW_CLOCK));
259         br32(bp, B44_SBTMSLOW);
260         udelay(1);
261 }
262
263 static int ssb_core_unit(struct b44 *bp)
264 {
265 #if 0
266         u32 val = br32(bp, B44_SBADMATCH0);
267         u32 base;
268
269         type = val & SBADMATCH0_TYPE_MASK;
270         switch (type) {
271         case 0:
272                 base = val & SBADMATCH0_BS0_MASK;
273                 break;
274
275         case 1:
276                 base = val & SBADMATCH0_BS1_MASK;
277                 break;
278
279         case 2:
280         default:
281                 base = val & SBADMATCH0_BS2_MASK;
282                 break;
283         };
284 #endif
285         return 0;
286 }
287
288 static int ssb_is_core_up(struct b44 *bp)
289 {
290         return ((br32(bp, B44_SBTMSLOW) & (SBTMSLOW_RESET | SBTMSLOW_REJECT | SBTMSLOW_CLOCK))
291                 == SBTMSLOW_CLOCK);
292 }
293
294 static void __b44_cam_write(struct b44 *bp, unsigned char *data, int index)
295 {
296         u32 val;
297
298         val  = ((u32) data[2]) << 24;
299         val |= ((u32) data[3]) << 16;
300         val |= ((u32) data[4]) <<  8;
301         val |= ((u32) data[5]) <<  0;
302         bw32(bp, B44_CAM_DATA_LO, val);
303         val = (CAM_DATA_HI_VALID |
304                (((u32) data[0]) << 8) |
305                (((u32) data[1]) << 0));
306         bw32(bp, B44_CAM_DATA_HI, val);
307         bw32(bp, B44_CAM_CTRL, (CAM_CTRL_WRITE |
308                             (index << CAM_CTRL_INDEX_SHIFT)));
309         b44_wait_bit(bp, B44_CAM_CTRL, CAM_CTRL_BUSY, 100, 1);
310 }
311
312 static inline void __b44_disable_ints(struct b44 *bp)
313 {
314         bw32(bp, B44_IMASK, 0);
315 }
316
317 static void b44_disable_ints(struct b44 *bp)
318 {
319         __b44_disable_ints(bp);
320
321         /* Flush posted writes. */
322         br32(bp, B44_IMASK);
323 }
324
325 static void b44_enable_ints(struct b44 *bp)
326 {
327         bw32(bp, B44_IMASK, bp->imask);
328 }
329
330 static int b44_readphy(struct b44 *bp, int reg, u32 *val)
331 {
332         int err;
333
334         bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
335         bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START |
336                              (MDIO_OP_READ << MDIO_DATA_OP_SHIFT) |
337                              (bp->phy_addr << MDIO_DATA_PMD_SHIFT) |
338                              (reg << MDIO_DATA_RA_SHIFT) |
339                              (MDIO_TA_VALID << MDIO_DATA_TA_SHIFT)));
340         err = b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
341         *val = br32(bp, B44_MDIO_DATA) & MDIO_DATA_DATA;
342
343         return err;
344 }
345
346 static int b44_writephy(struct b44 *bp, int reg, u32 val)
347 {
348         bw32(bp, B44_EMAC_ISTAT, EMAC_INT_MII);
349         bw32(bp, B44_MDIO_DATA, (MDIO_DATA_SB_START |
350                              (MDIO_OP_WRITE << MDIO_DATA_OP_SHIFT) |
351                              (bp->phy_addr << MDIO_DATA_PMD_SHIFT) |
352                              (reg << MDIO_DATA_RA_SHIFT) |
353                              (MDIO_TA_VALID << MDIO_DATA_TA_SHIFT) |
354                              (val & MDIO_DATA_DATA)));
355         return b44_wait_bit(bp, B44_EMAC_ISTAT, EMAC_INT_MII, 100, 0);
356 }
357
358 /* miilib interface */
359 /* FIXME FIXME: phy_id is ignored, bp->phy_addr use is unconditional
360  * due to code existing before miilib use was added to this driver.
361  * Someone should remove this artificial driver limitation in
362  * b44_{read,write}phy.  bp->phy_addr itself is fine (and needed).
363  */
364 static int b44_mii_read(struct net_device *dev, int phy_id, int location)
365 {
366         u32 val;
367         struct b44 *bp = netdev_priv(dev);
368         int rc = b44_readphy(bp, location, &val);
369         if (rc)
370                 return 0xffffffff;
371         return val;
372 }
373
374 static void b44_mii_write(struct net_device *dev, int phy_id, int location,
375                          int val)
376 {
377         struct b44 *bp = netdev_priv(dev);
378         b44_writephy(bp, location, val);
379 }
380
381 static int b44_phy_reset(struct b44 *bp)
382 {
383         u32 val;
384         int err;
385
386         err = b44_writephy(bp, MII_BMCR, BMCR_RESET);
387         if (err)
388                 return err;
389         udelay(100);
390         err = b44_readphy(bp, MII_BMCR, &val);
391         if (!err) {
392                 if (val & BMCR_RESET) {
393                         printk(KERN_ERR PFX "%s: PHY Reset would not complete.\n",
394                                bp->dev->name);
395                         err = -ENODEV;
396                 }
397         }
398
399         return 0;
400 }
401
402 static void __b44_set_flow_ctrl(struct b44 *bp, u32 pause_flags)
403 {
404         u32 val;
405
406         bp->flags &= ~(B44_FLAG_TX_PAUSE | B44_FLAG_RX_PAUSE);
407         bp->flags |= pause_flags;
408
409         val = br32(bp, B44_RXCONFIG);
410         if (pause_flags & B44_FLAG_RX_PAUSE)
411                 val |= RXCONFIG_FLOW;
412         else
413                 val &= ~RXCONFIG_FLOW;
414         bw32(bp, B44_RXCONFIG, val);
415
416         val = br32(bp, B44_MAC_FLOW);
417         if (pause_flags & B44_FLAG_TX_PAUSE)
418                 val |= (MAC_FLOW_PAUSE_ENAB |
419                         (0xc0 & MAC_FLOW_RX_HI_WATER));
420         else
421                 val &= ~MAC_FLOW_PAUSE_ENAB;
422         bw32(bp, B44_MAC_FLOW, val);
423 }
424
425 static void b44_set_flow_ctrl(struct b44 *bp, u32 local, u32 remote)
426 {
427         u32 pause_enab = 0;
428
429         /* The driver supports only rx pause by default because
430            the b44 mac tx pause mechanism generates excessive
431            pause frames.
432            Use ethtool to turn on b44 tx pause if necessary.
433          */
434         if ((local & ADVERTISE_PAUSE_CAP) &&
435             (local & ADVERTISE_PAUSE_ASYM)){
436                 if ((remote & LPA_PAUSE_ASYM) &&
437                     !(remote & LPA_PAUSE_CAP))
438                         pause_enab |= B44_FLAG_RX_PAUSE;
439         }
440
441         __b44_set_flow_ctrl(bp, pause_enab);
442 }
443
444 static int b44_setup_phy(struct b44 *bp)
445 {
446         u32 val;
447         int err;
448
449         if ((err = b44_readphy(bp, B44_MII_ALEDCTRL, &val)) != 0)
450                 goto out;
451         if ((err = b44_writephy(bp, B44_MII_ALEDCTRL,
452                                 val & MII_ALEDCTRL_ALLMSK)) != 0)
453                 goto out;
454         if ((err = b44_readphy(bp, B44_MII_TLEDCTRL, &val)) != 0)
455                 goto out;
456         if ((err = b44_writephy(bp, B44_MII_TLEDCTRL,
457                                 val | MII_TLEDCTRL_ENABLE)) != 0)
458                 goto out;
459
460         if (!(bp->flags & B44_FLAG_FORCE_LINK)) {
461                 u32 adv = ADVERTISE_CSMA;
462
463                 if (bp->flags & B44_FLAG_ADV_10HALF)
464                         adv |= ADVERTISE_10HALF;
465                 if (bp->flags & B44_FLAG_ADV_10FULL)
466                         adv |= ADVERTISE_10FULL;
467                 if (bp->flags & B44_FLAG_ADV_100HALF)
468                         adv |= ADVERTISE_100HALF;
469                 if (bp->flags & B44_FLAG_ADV_100FULL)
470                         adv |= ADVERTISE_100FULL;
471
472                 if (bp->flags & B44_FLAG_PAUSE_AUTO)
473                         adv |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
474
475                 if ((err = b44_writephy(bp, MII_ADVERTISE, adv)) != 0)
476                         goto out;
477                 if ((err = b44_writephy(bp, MII_BMCR, (BMCR_ANENABLE |
478                                                        BMCR_ANRESTART))) != 0)
479                         goto out;
480         } else {
481                 u32 bmcr;
482
483                 if ((err = b44_readphy(bp, MII_BMCR, &bmcr)) != 0)
484                         goto out;
485                 bmcr &= ~(BMCR_FULLDPLX | BMCR_ANENABLE | BMCR_SPEED100);
486                 if (bp->flags & B44_FLAG_100_BASE_T)
487                         bmcr |= BMCR_SPEED100;
488                 if (bp->flags & B44_FLAG_FULL_DUPLEX)
489                         bmcr |= BMCR_FULLDPLX;
490                 if ((err = b44_writephy(bp, MII_BMCR, bmcr)) != 0)
491                         goto out;
492
493                 /* Since we will not be negotiating there is no safe way
494                  * to determine if the link partner supports flow control
495                  * or not.  So just disable it completely in this case.
496                  */
497                 b44_set_flow_ctrl(bp, 0, 0);
498         }
499
500 out:
501         return err;
502 }
503
504 static void b44_stats_update(struct b44 *bp)
505 {
506         unsigned long reg;
507         u32 *val;
508
509         val = &bp->hw_stats.tx_good_octets;
510         for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL) {
511                 *val++ += br32(bp, reg);
512         }
513
514         /* Pad */
515         reg += 8*4UL;
516
517         for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL) {
518                 *val++ += br32(bp, reg);
519         }
520 }
521
522 static void b44_link_report(struct b44 *bp)
523 {
524         if (!netif_carrier_ok(bp->dev)) {
525                 printk(KERN_INFO PFX "%s: Link is down.\n", bp->dev->name);
526         } else {
527                 printk(KERN_INFO PFX "%s: Link is up at %d Mbps, %s duplex.\n",
528                        bp->dev->name,
529                        (bp->flags & B44_FLAG_100_BASE_T) ? 100 : 10,
530                        (bp->flags & B44_FLAG_FULL_DUPLEX) ? "full" : "half");
531
532                 printk(KERN_INFO PFX "%s: Flow control is %s for TX and "
533                        "%s for RX.\n",
534                        bp->dev->name,
535                        (bp->flags & B44_FLAG_TX_PAUSE) ? "on" : "off",
536                        (bp->flags & B44_FLAG_RX_PAUSE) ? "on" : "off");
537         }
538 }
539
540 static void b44_check_phy(struct b44 *bp)
541 {
542         u32 bmsr, aux;
543
544         if (!b44_readphy(bp, MII_BMSR, &bmsr) &&
545             !b44_readphy(bp, B44_MII_AUXCTRL, &aux) &&
546             (bmsr != 0xffff)) {
547                 if (aux & MII_AUXCTRL_SPEED)
548                         bp->flags |= B44_FLAG_100_BASE_T;
549                 else
550                         bp->flags &= ~B44_FLAG_100_BASE_T;
551                 if (aux & MII_AUXCTRL_DUPLEX)
552                         bp->flags |= B44_FLAG_FULL_DUPLEX;
553                 else
554                         bp->flags &= ~B44_FLAG_FULL_DUPLEX;
555
556                 if (!netif_carrier_ok(bp->dev) &&
557                     (bmsr & BMSR_LSTATUS)) {
558                         u32 val = br32(bp, B44_TX_CTRL);
559                         u32 local_adv, remote_adv;
560
561                         if (bp->flags & B44_FLAG_FULL_DUPLEX)
562                                 val |= TX_CTRL_DUPLEX;
563                         else
564                                 val &= ~TX_CTRL_DUPLEX;
565                         bw32(bp, B44_TX_CTRL, val);
566
567                         if (!(bp->flags & B44_FLAG_FORCE_LINK) &&
568                             !b44_readphy(bp, MII_ADVERTISE, &local_adv) &&
569                             !b44_readphy(bp, MII_LPA, &remote_adv))
570                                 b44_set_flow_ctrl(bp, local_adv, remote_adv);
571
572                         /* Link now up */
573                         netif_carrier_on(bp->dev);
574                         b44_link_report(bp);
575                 } else if (netif_carrier_ok(bp->dev) && !(bmsr & BMSR_LSTATUS)) {
576                         /* Link now down */
577                         netif_carrier_off(bp->dev);
578                         b44_link_report(bp);
579                 }
580
581                 if (bmsr & BMSR_RFAULT)
582                         printk(KERN_WARNING PFX "%s: Remote fault detected in PHY\n",
583                                bp->dev->name);
584                 if (bmsr & BMSR_JCD)
585                         printk(KERN_WARNING PFX "%s: Jabber detected in PHY\n",
586                                bp->dev->name);
587         }
588 }
589
590 static void b44_timer(unsigned long __opaque)
591 {
592         struct b44 *bp = (struct b44 *) __opaque;
593
594         spin_lock_irq(&bp->lock);
595
596         b44_check_phy(bp);
597
598         b44_stats_update(bp);
599
600         spin_unlock_irq(&bp->lock);
601
602         bp->timer.expires = jiffies + HZ;
603         add_timer(&bp->timer);
604 }
605
606 static void b44_tx(struct b44 *bp)
607 {
608         u32 cur, cons;
609
610         cur  = br32(bp, B44_DMATX_STAT) & DMATX_STAT_CDMASK;
611         cur /= sizeof(struct dma_desc);
612
613         /* XXX needs updating when NETIF_F_SG is supported */
614         for (cons = bp->tx_cons; cons != cur; cons = NEXT_TX(cons)) {
615                 struct ring_info *rp = &bp->tx_buffers[cons];
616                 struct sk_buff *skb = rp->skb;
617
618                 BUG_ON(skb == NULL);
619
620                 pci_unmap_single(bp->pdev,
621                                  pci_unmap_addr(rp, mapping),
622                                  skb->len,
623                                  PCI_DMA_TODEVICE);
624                 rp->skb = NULL;
625                 dev_kfree_skb_irq(skb);
626         }
627
628         bp->tx_cons = cons;
629         if (netif_queue_stopped(bp->dev) &&
630             TX_BUFFS_AVAIL(bp) > B44_TX_WAKEUP_THRESH)
631                 netif_wake_queue(bp->dev);
632
633         bw32(bp, B44_GPTIMER, 0);
634 }
635
636 /* Works like this.  This chip writes a 'struct rx_header" 30 bytes
637  * before the DMA address you give it.  So we allocate 30 more bytes
638  * for the RX buffer, DMA map all of it, skb_reserve the 30 bytes, then
639  * point the chip at 30 bytes past where the rx_header will go.
640  */
641 static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
642 {
643         struct dma_desc *dp;
644         struct ring_info *src_map, *map;
645         struct rx_header *rh;
646         struct sk_buff *skb;
647         dma_addr_t mapping;
648         int dest_idx;
649         u32 ctrl;
650
651         src_map = NULL;
652         if (src_idx >= 0)
653                 src_map = &bp->rx_buffers[src_idx];
654         dest_idx = dest_idx_unmasked & (B44_RX_RING_SIZE - 1);
655         map = &bp->rx_buffers[dest_idx];
656         skb = dev_alloc_skb(RX_PKT_BUF_SZ);
657         if (skb == NULL)
658                 return -ENOMEM;
659
660         mapping = pci_map_single(bp->pdev, skb->data,
661                                  RX_PKT_BUF_SZ,
662                                  PCI_DMA_FROMDEVICE);
663
664         /* Hardware bug work-around, the chip is unable to do PCI DMA
665            to/from anything above 1GB :-( */
666         if (dma_mapping_error(mapping) ||
667                 mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
668                 /* Sigh... */
669                 if (!dma_mapping_error(mapping))
670                         pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
671                 dev_kfree_skb_any(skb);
672                 skb = __dev_alloc_skb(RX_PKT_BUF_SZ,GFP_DMA);
673                 if (skb == NULL)
674                         return -ENOMEM;
675                 mapping = pci_map_single(bp->pdev, skb->data,
676                                          RX_PKT_BUF_SZ,
677                                          PCI_DMA_FROMDEVICE);
678                 if (dma_mapping_error(mapping) ||
679                         mapping + RX_PKT_BUF_SZ > DMA_30BIT_MASK) {
680                         if (!dma_mapping_error(mapping))
681                                 pci_unmap_single(bp->pdev, mapping, RX_PKT_BUF_SZ,PCI_DMA_FROMDEVICE);
682                         dev_kfree_skb_any(skb);
683                         return -ENOMEM;
684                 }
685         }
686
687         skb->dev = bp->dev;
688         skb_reserve(skb, bp->rx_offset);
689
690         rh = (struct rx_header *)
691                 (skb->data - bp->rx_offset);
692         rh->len = 0;
693         rh->flags = 0;
694
695         map->skb = skb;
696         pci_unmap_addr_set(map, mapping, mapping);
697
698         if (src_map != NULL)
699                 src_map->skb = NULL;
700
701         ctrl  = (DESC_CTRL_LEN & (RX_PKT_BUF_SZ - bp->rx_offset));
702         if (dest_idx == (B44_RX_RING_SIZE - 1))
703                 ctrl |= DESC_CTRL_EOT;
704
705         dp = &bp->rx_ring[dest_idx];
706         dp->ctrl = cpu_to_le32(ctrl);
707         dp->addr = cpu_to_le32((u32) mapping + bp->rx_offset + bp->dma_offset);
708
709         if (bp->flags & B44_FLAG_RX_RING_HACK)
710                 b44_sync_dma_desc_for_device(bp->pdev, bp->rx_ring_dma,
711                                              dest_idx * sizeof(dp),
712                                              DMA_BIDIRECTIONAL);
713
714         return RX_PKT_BUF_SZ;
715 }
716
717 static void b44_recycle_rx(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
718 {
719         struct dma_desc *src_desc, *dest_desc;
720         struct ring_info *src_map, *dest_map;
721         struct rx_header *rh;
722         int dest_idx;
723         __le32 ctrl;
724
725         dest_idx = dest_idx_unmasked & (B44_RX_RING_SIZE - 1);
726         dest_desc = &bp->rx_ring[dest_idx];
727         dest_map = &bp->rx_buffers[dest_idx];
728         src_desc = &bp->rx_ring[src_idx];
729         src_map = &bp->rx_buffers[src_idx];
730
731         dest_map->skb = src_map->skb;
732         rh = (struct rx_header *) src_map->skb->data;
733         rh->len = 0;
734         rh->flags = 0;
735         pci_unmap_addr_set(dest_map, mapping,
736                            pci_unmap_addr(src_map, mapping));
737
738         if (bp->flags & B44_FLAG_RX_RING_HACK)
739                 b44_sync_dma_desc_for_cpu(bp->pdev, bp->rx_ring_dma,
740                                           src_idx * sizeof(src_desc),
741                                           DMA_BIDIRECTIONAL);
742
743         ctrl = src_desc->ctrl;
744         if (dest_idx == (B44_RX_RING_SIZE - 1))
745                 ctrl |= cpu_to_le32(DESC_CTRL_EOT);
746         else
747                 ctrl &= cpu_to_le32(~DESC_CTRL_EOT);
748
749         dest_desc->ctrl = ctrl;
750         dest_desc->addr = src_desc->addr;
751
752         src_map->skb = NULL;
753
754         if (bp->flags & B44_FLAG_RX_RING_HACK)
755                 b44_sync_dma_desc_for_device(bp->pdev, bp->rx_ring_dma,
756                                              dest_idx * sizeof(dest_desc),
757                                              DMA_BIDIRECTIONAL);
758
759         pci_dma_sync_single_for_device(bp->pdev, le32_to_cpu(src_desc->addr),
760                                        RX_PKT_BUF_SZ,
761                                        PCI_DMA_FROMDEVICE);
762 }
763
764 static int b44_rx(struct b44 *bp, int budget)
765 {
766         int received;
767         u32 cons, prod;
768
769         received = 0;
770         prod  = br32(bp, B44_DMARX_STAT) & DMARX_STAT_CDMASK;
771         prod /= sizeof(struct dma_desc);
772         cons = bp->rx_cons;
773
774         while (cons != prod && budget > 0) {
775                 struct ring_info *rp = &bp->rx_buffers[cons];
776                 struct sk_buff *skb = rp->skb;
777                 dma_addr_t map = pci_unmap_addr(rp, mapping);
778                 struct rx_header *rh;
779                 u16 len;
780
781                 pci_dma_sync_single_for_cpu(bp->pdev, map,
782                                             RX_PKT_BUF_SZ,
783                                             PCI_DMA_FROMDEVICE);
784                 rh = (struct rx_header *) skb->data;
785                 len = le16_to_cpu(rh->len);
786                 if ((len > (RX_PKT_BUF_SZ - bp->rx_offset)) ||
787                     (rh->flags & cpu_to_le16(RX_FLAG_ERRORS))) {
788                 drop_it:
789                         b44_recycle_rx(bp, cons, bp->rx_prod);
790                 drop_it_no_recycle:
791                         bp->stats.rx_dropped++;
792                         goto next_pkt;
793                 }
794
795                 if (len == 0) {
796                         int i = 0;
797
798                         do {
799                                 udelay(2);
800                                 barrier();
801                                 len = le16_to_cpu(rh->len);
802                         } while (len == 0 && i++ < 5);
803                         if (len == 0)
804                                 goto drop_it;
805                 }
806
807                 /* Omit CRC. */
808                 len -= 4;
809
810                 if (len > RX_COPY_THRESHOLD) {
811                         int skb_size;
812                         skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
813                         if (skb_size < 0)
814                                 goto drop_it;
815                         pci_unmap_single(bp->pdev, map,
816                                          skb_size, PCI_DMA_FROMDEVICE);
817                         /* Leave out rx_header */
818                         skb_put(skb, len+bp->rx_offset);
819                         skb_pull(skb,bp->rx_offset);
820                 } else {
821                         struct sk_buff *copy_skb;
822
823                         b44_recycle_rx(bp, cons, bp->rx_prod);
824                         copy_skb = dev_alloc_skb(len + 2);
825                         if (copy_skb == NULL)
826                                 goto drop_it_no_recycle;
827
828                         skb_reserve(copy_skb, 2);
829                         skb_put(copy_skb, len);
830                         /* DMA sync done above, copy just the actual packet */
831                         skb_copy_from_linear_data_offset(skb, bp->rx_offset,
832                                                          copy_skb->data, len);
833                         skb = copy_skb;
834                 }
835                 skb->ip_summed = CHECKSUM_NONE;
836                 skb->protocol = eth_type_trans(skb, bp->dev);
837                 netif_receive_skb(skb);
838                 bp->dev->last_rx = jiffies;
839                 received++;
840                 budget--;
841         next_pkt:
842                 bp->rx_prod = (bp->rx_prod + 1) &
843                         (B44_RX_RING_SIZE - 1);
844                 cons = (cons + 1) & (B44_RX_RING_SIZE - 1);
845         }
846
847         bp->rx_cons = cons;
848         bw32(bp, B44_DMARX_PTR, cons * sizeof(struct dma_desc));
849
850         return received;
851 }
852
853 static int b44_poll(struct net_device *netdev, int *budget)
854 {
855         struct b44 *bp = netdev_priv(netdev);
856         int done;
857
858         spin_lock_irq(&bp->lock);
859
860         if (bp->istat & (ISTAT_TX | ISTAT_TO)) {
861                 /* spin_lock(&bp->tx_lock); */
862                 b44_tx(bp);
863                 /* spin_unlock(&bp->tx_lock); */
864         }
865         spin_unlock_irq(&bp->lock);
866
867         done = 1;
868         if (bp->istat & ISTAT_RX) {
869                 int orig_budget = *budget;
870                 int work_done;
871
872                 if (orig_budget > netdev->quota)
873                         orig_budget = netdev->quota;
874
875                 work_done = b44_rx(bp, orig_budget);
876
877                 *budget -= work_done;
878                 netdev->quota -= work_done;
879
880                 if (work_done >= orig_budget)
881                         done = 0;
882         }
883
884         if (bp->istat & ISTAT_ERRORS) {
885                 unsigned long flags;
886
887                 spin_lock_irqsave(&bp->lock, flags);
888                 b44_halt(bp);
889                 b44_init_rings(bp);
890                 b44_init_hw(bp, B44_FULL_RESET_SKIP_PHY);
891                 netif_wake_queue(bp->dev);
892                 spin_unlock_irqrestore(&bp->lock, flags);
893                 done = 1;
894         }
895
896         if (done) {
897                 netif_rx_complete(netdev);
898                 b44_enable_ints(bp);
899         }
900
901         return (done ? 0 : 1);
902 }
903
904 static irqreturn_t b44_interrupt(int irq, void *dev_id)
905 {
906         struct net_device *dev = dev_id;
907         struct b44 *bp = netdev_priv(dev);
908         u32 istat, imask;
909         int handled = 0;
910
911         spin_lock(&bp->lock);
912
913         istat = br32(bp, B44_ISTAT);
914         imask = br32(bp, B44_IMASK);
915
916         /* The interrupt mask register controls which interrupt bits
917          * will actually raise an interrupt to the CPU when set by hw/firmware,
918          * but doesn't mask off the bits.
919          */
920         istat &= imask;
921         if (istat) {
922                 handled = 1;
923
924                 if (unlikely(!netif_running(dev))) {
925                         printk(KERN_INFO "%s: late interrupt.\n", dev->name);
926                         goto irq_ack;
927                 }
928
929                 if (netif_rx_schedule_prep(dev)) {
930                         /* NOTE: These writes are posted by the readback of
931                          *       the ISTAT register below.
932                          */
933                         bp->istat = istat;
934                         __b44_disable_ints(bp);
935                         __netif_rx_schedule(dev);
936                 } else {
937                         printk(KERN_ERR PFX "%s: Error, poll already scheduled\n",
938                                dev->name);
939                 }
940
941 irq_ack:
942                 bw32(bp, B44_ISTAT, istat);
943                 br32(bp, B44_ISTAT);
944         }
945         spin_unlock(&bp->lock);
946         return IRQ_RETVAL(handled);
947 }
948
949 static void b44_tx_timeout(struct net_device *dev)
950 {
951         struct b44 *bp = netdev_priv(dev);
952
953         printk(KERN_ERR PFX "%s: transmit timed out, resetting\n",
954                dev->name);
955
956         spin_lock_irq(&bp->lock);
957
958         b44_halt(bp);
959         b44_init_rings(bp);
960         b44_init_hw(bp, B44_FULL_RESET);
961
962         spin_unlock_irq(&bp->lock);
963
964         b44_enable_ints(bp);
965
966         netif_wake_queue(dev);
967 }
968
969 static int b44_start_xmit(struct sk_buff *skb, struct net_device *dev)
970 {
971         struct b44 *bp = netdev_priv(dev);
972         struct sk_buff *bounce_skb;
973         int rc = NETDEV_TX_OK;
974         dma_addr_t mapping;
975         u32 len, entry, ctrl;
976
977         len = skb->len;
978         spin_lock_irq(&bp->lock);
979
980         /* This is a hard error, log it. */
981         if (unlikely(TX_BUFFS_AVAIL(bp) < 1)) {
982                 netif_stop_queue(dev);
983                 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
984                        dev->name);
985                 goto err_out;
986         }
987
988         mapping = pci_map_single(bp->pdev, skb->data, len, PCI_DMA_TODEVICE);
989         if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) {
990                 /* Chip can't handle DMA to/from >1GB, use bounce buffer */
991                 if (!dma_mapping_error(mapping))
992                         pci_unmap_single(bp->pdev, mapping, len, PCI_DMA_TODEVICE);
993
994                 bounce_skb = __dev_alloc_skb(TX_PKT_BUF_SZ,
995                                              GFP_ATOMIC|GFP_DMA);
996                 if (!bounce_skb)
997                         goto err_out;
998
999                 mapping = pci_map_single(bp->pdev, bounce_skb->data,
1000                                          len, PCI_DMA_TODEVICE);
1001                 if (dma_mapping_error(mapping) || mapping + len > DMA_30BIT_MASK) {
1002                         if (!dma_mapping_error(mapping))
1003                                 pci_unmap_single(bp->pdev, mapping,
1004                                          len, PCI_DMA_TODEVICE);
1005                         dev_kfree_skb_any(bounce_skb);
1006                         goto err_out;
1007                 }
1008
1009                 skb_copy_from_linear_data(skb, skb_put(bounce_skb, len),
1010                                           skb->len);
1011                 dev_kfree_skb_any(skb);
1012                 skb = bounce_skb;
1013         }
1014
1015         entry = bp->tx_prod;
1016         bp->tx_buffers[entry].skb = skb;
1017         pci_unmap_addr_set(&bp->tx_buffers[entry], mapping, mapping);
1018
1019         ctrl  = (len & DESC_CTRL_LEN);
1020         ctrl |= DESC_CTRL_IOC | DESC_CTRL_SOF | DESC_CTRL_EOF;
1021         if (entry == (B44_TX_RING_SIZE - 1))
1022                 ctrl |= DESC_CTRL_EOT;
1023
1024         bp->tx_ring[entry].ctrl = cpu_to_le32(ctrl);
1025         bp->tx_ring[entry].addr = cpu_to_le32((u32) mapping+bp->dma_offset);
1026
1027         if (bp->flags & B44_FLAG_TX_RING_HACK)
1028                 b44_sync_dma_desc_for_device(bp->pdev, bp->tx_ring_dma,
1029                                              entry * sizeof(bp->tx_ring[0]),
1030                                              DMA_TO_DEVICE);
1031
1032         entry = NEXT_TX(entry);
1033
1034         bp->tx_prod = entry;
1035
1036         wmb();
1037
1038         bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc));
1039         if (bp->flags & B44_FLAG_BUGGY_TXPTR)
1040                 bw32(bp, B44_DMATX_PTR, entry * sizeof(struct dma_desc));
1041         if (bp->flags & B44_FLAG_REORDER_BUG)
1042                 br32(bp, B44_DMATX_PTR);
1043
1044         if (TX_BUFFS_AVAIL(bp) < 1)
1045                 netif_stop_queue(dev);
1046
1047         dev->trans_start = jiffies;
1048
1049 out_unlock:
1050         spin_unlock_irq(&bp->lock);
1051
1052         return rc;
1053
1054 err_out:
1055         rc = NETDEV_TX_BUSY;
1056         goto out_unlock;
1057 }
1058
1059 static int b44_change_mtu(struct net_device *dev, int new_mtu)
1060 {
1061         struct b44 *bp = netdev_priv(dev);
1062
1063         if (new_mtu < B44_MIN_MTU || new_mtu > B44_MAX_MTU)
1064                 return -EINVAL;
1065
1066         if (!netif_running(dev)) {
1067                 /* We'll just catch it later when the
1068                  * device is up'd.
1069                  */
1070                 dev->mtu = new_mtu;
1071                 return 0;
1072         }
1073
1074         spin_lock_irq(&bp->lock);
1075         b44_halt(bp);
1076         dev->mtu = new_mtu;
1077         b44_init_rings(bp);
1078         b44_init_hw(bp, B44_FULL_RESET);
1079         spin_unlock_irq(&bp->lock);
1080
1081         b44_enable_ints(bp);
1082
1083         return 0;
1084 }
1085
1086 /* Free up pending packets in all rx/tx rings.
1087  *
1088  * The chip has been shut down and the driver detached from
1089  * the networking, so no interrupts or new tx packets will
1090  * end up in the driver.  bp->lock is not held and we are not
1091  * in an interrupt context and thus may sleep.
1092  */
1093 static void b44_free_rings(struct b44 *bp)
1094 {
1095         struct ring_info *rp;
1096         int i;
1097
1098         for (i = 0; i < B44_RX_RING_SIZE; i++) {
1099                 rp = &bp->rx_buffers[i];
1100
1101                 if (rp->skb == NULL)
1102                         continue;
1103                 pci_unmap_single(bp->pdev,
1104                                  pci_unmap_addr(rp, mapping),
1105                                  RX_PKT_BUF_SZ,
1106                                  PCI_DMA_FROMDEVICE);
1107                 dev_kfree_skb_any(rp->skb);
1108                 rp->skb = NULL;
1109         }
1110
1111         /* XXX needs changes once NETIF_F_SG is set... */
1112         for (i = 0; i < B44_TX_RING_SIZE; i++) {
1113                 rp = &bp->tx_buffers[i];
1114
1115                 if (rp->skb == NULL)
1116                         continue;
1117                 pci_unmap_single(bp->pdev,
1118                                  pci_unmap_addr(rp, mapping),
1119                                  rp->skb->len,
1120                                  PCI_DMA_TODEVICE);
1121                 dev_kfree_skb_any(rp->skb);
1122                 rp->skb = NULL;
1123         }
1124 }
1125
1126 /* Initialize tx/rx rings for packet processing.
1127  *
1128  * The chip has been shut down and the driver detached from
1129  * the networking, so no interrupts or new tx packets will
1130  * end up in the driver.
1131  */
1132 static void b44_init_rings(struct b44 *bp)
1133 {
1134         int i;
1135
1136         b44_free_rings(bp);
1137
1138         memset(bp->rx_ring, 0, B44_RX_RING_BYTES);
1139         memset(bp->tx_ring, 0, B44_TX_RING_BYTES);
1140
1141         if (bp->flags & B44_FLAG_RX_RING_HACK)
1142                 dma_sync_single_for_device(&bp->pdev->dev, bp->rx_ring_dma,
1143                                            DMA_TABLE_BYTES,
1144                                            PCI_DMA_BIDIRECTIONAL);
1145
1146         if (bp->flags & B44_FLAG_TX_RING_HACK)
1147                 dma_sync_single_for_device(&bp->pdev->dev, bp->tx_ring_dma,
1148                                            DMA_TABLE_BYTES,
1149                                            PCI_DMA_TODEVICE);
1150
1151         for (i = 0; i < bp->rx_pending; i++) {
1152                 if (b44_alloc_rx_skb(bp, -1, i) < 0)
1153                         break;
1154         }
1155 }
1156
1157 /*
1158  * Must not be invoked with interrupt sources disabled and
1159  * the hardware shutdown down.
1160  */
1161 static void b44_free_consistent(struct b44 *bp)
1162 {
1163         kfree(bp->rx_buffers);
1164         bp->rx_buffers = NULL;
1165         kfree(bp->tx_buffers);
1166         bp->tx_buffers = NULL;
1167         if (bp->rx_ring) {
1168                 if (bp->flags & B44_FLAG_RX_RING_HACK) {
1169                         dma_unmap_single(&bp->pdev->dev, bp->rx_ring_dma,
1170                                          DMA_TABLE_BYTES,
1171                                          DMA_BIDIRECTIONAL);
1172                         kfree(bp->rx_ring);
1173                 } else
1174                         pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
1175                                             bp->rx_ring, bp->rx_ring_dma);
1176                 bp->rx_ring = NULL;
1177                 bp->flags &= ~B44_FLAG_RX_RING_HACK;
1178         }
1179         if (bp->tx_ring) {
1180                 if (bp->flags & B44_FLAG_TX_RING_HACK) {
1181                         dma_unmap_single(&bp->pdev->dev, bp->tx_ring_dma,
1182                                          DMA_TABLE_BYTES,
1183                                          DMA_TO_DEVICE);
1184                         kfree(bp->tx_ring);
1185                 } else
1186                         pci_free_consistent(bp->pdev, DMA_TABLE_BYTES,
1187                                             bp->tx_ring, bp->tx_ring_dma);
1188                 bp->tx_ring = NULL;
1189                 bp->flags &= ~B44_FLAG_TX_RING_HACK;
1190         }
1191 }
1192
1193 /*
1194  * Must not be invoked with interrupt sources disabled and
1195  * the hardware shutdown down.  Can sleep.
1196  */
1197 static int b44_alloc_consistent(struct b44 *bp)
1198 {
1199         int size;
1200
1201         size  = B44_RX_RING_SIZE * sizeof(struct ring_info);
1202         bp->rx_buffers = kzalloc(size, GFP_KERNEL);
1203         if (!bp->rx_buffers)
1204                 goto out_err;
1205
1206         size = B44_TX_RING_SIZE * sizeof(struct ring_info);
1207         bp->tx_buffers = kzalloc(size, GFP_KERNEL);
1208         if (!bp->tx_buffers)
1209                 goto out_err;
1210
1211         size = DMA_TABLE_BYTES;
1212         bp->rx_ring = pci_alloc_consistent(bp->pdev, size, &bp->rx_ring_dma);
1213         if (!bp->rx_ring) {
1214                 /* Allocation may have failed due to pci_alloc_consistent
1215                    insisting on use of GFP_DMA, which is more restrictive
1216                    than necessary...  */
1217                 struct dma_desc *rx_ring;
1218                 dma_addr_t rx_ring_dma;
1219
1220                 rx_ring = kzalloc(size, GFP_KERNEL);
1221                 if (!rx_ring)
1222                         goto out_err;
1223
1224                 rx_ring_dma = dma_map_single(&bp->pdev->dev, rx_ring,
1225                                              DMA_TABLE_BYTES,
1226                                              DMA_BIDIRECTIONAL);
1227
1228                 if (dma_mapping_error(rx_ring_dma) ||
1229                         rx_ring_dma + size > DMA_30BIT_MASK) {
1230                         kfree(rx_ring);
1231                         goto out_err;
1232                 }
1233
1234                 bp->rx_ring = rx_ring;
1235                 bp->rx_ring_dma = rx_ring_dma;
1236                 bp->flags |= B44_FLAG_RX_RING_HACK;
1237         }
1238
1239         bp->tx_ring = pci_alloc_consistent(bp->pdev, size, &bp->tx_ring_dma);
1240         if (!bp->tx_ring) {
1241                 /* Allocation may have failed due to pci_alloc_consistent
1242                    insisting on use of GFP_DMA, which is more restrictive
1243                    than necessary...  */
1244                 struct dma_desc *tx_ring;
1245                 dma_addr_t tx_ring_dma;
1246
1247                 tx_ring = kzalloc(size, GFP_KERNEL);
1248                 if (!tx_ring)
1249                         goto out_err;
1250
1251                 tx_ring_dma = dma_map_single(&bp->pdev->dev, tx_ring,
1252                                              DMA_TABLE_BYTES,
1253                                              DMA_TO_DEVICE);
1254
1255                 if (dma_mapping_error(tx_ring_dma) ||
1256                         tx_ring_dma + size > DMA_30BIT_MASK) {
1257                         kfree(tx_ring);
1258                         goto out_err;
1259                 }
1260
1261                 bp->tx_ring = tx_ring;
1262                 bp->tx_ring_dma = tx_ring_dma;
1263                 bp->flags |= B44_FLAG_TX_RING_HACK;
1264         }
1265
1266         return 0;
1267
1268 out_err:
1269         b44_free_consistent(bp);
1270         return -ENOMEM;
1271 }
1272
1273 /* bp->lock is held. */
1274 static void b44_clear_stats(struct b44 *bp)
1275 {
1276         unsigned long reg;
1277
1278         bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
1279         for (reg = B44_TX_GOOD_O; reg <= B44_TX_PAUSE; reg += 4UL)
1280                 br32(bp, reg);
1281         for (reg = B44_RX_GOOD_O; reg <= B44_RX_NPAUSE; reg += 4UL)
1282                 br32(bp, reg);
1283 }
1284
1285 /* bp->lock is held. */
1286 static void b44_chip_reset(struct b44 *bp)
1287 {
1288         if (ssb_is_core_up(bp)) {
1289                 bw32(bp, B44_RCV_LAZY, 0);
1290                 bw32(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE);
1291                 b44_wait_bit(bp, B44_ENET_CTRL, ENET_CTRL_DISABLE, 200, 1);
1292                 bw32(bp, B44_DMATX_CTRL, 0);
1293                 bp->tx_prod = bp->tx_cons = 0;
1294                 if (br32(bp, B44_DMARX_STAT) & DMARX_STAT_EMASK) {
1295                         b44_wait_bit(bp, B44_DMARX_STAT, DMARX_STAT_SIDLE,
1296                                      100, 0);
1297                 }
1298                 bw32(bp, B44_DMARX_CTRL, 0);
1299                 bp->rx_prod = bp->rx_cons = 0;
1300         } else {
1301                 ssb_pci_setup(bp, (bp->core_unit == 0 ?
1302                                    SBINTVEC_ENET0 :
1303                                    SBINTVEC_ENET1));
1304         }
1305
1306         ssb_core_reset(bp);
1307
1308         b44_clear_stats(bp);
1309
1310         /* Make PHY accessible. */
1311         bw32(bp, B44_MDIO_CTRL, (MDIO_CTRL_PREAMBLE |
1312                              (0x0d & MDIO_CTRL_MAXF_MASK)));
1313         br32(bp, B44_MDIO_CTRL);
1314
1315         if (!(br32(bp, B44_DEVCTRL) & DEVCTRL_IPP)) {
1316                 bw32(bp, B44_ENET_CTRL, ENET_CTRL_EPSEL);
1317                 br32(bp, B44_ENET_CTRL);
1318                 bp->flags &= ~B44_FLAG_INTERNAL_PHY;
1319         } else {
1320                 u32 val = br32(bp, B44_DEVCTRL);
1321
1322                 if (val & DEVCTRL_EPR) {
1323                         bw32(bp, B44_DEVCTRL, (val & ~DEVCTRL_EPR));
1324                         br32(bp, B44_DEVCTRL);
1325                         udelay(100);
1326                 }
1327                 bp->flags |= B44_FLAG_INTERNAL_PHY;
1328         }
1329 }
1330
1331 /* bp->lock is held. */
1332 static void b44_halt(struct b44 *bp)
1333 {
1334         b44_disable_ints(bp);
1335         b44_chip_reset(bp);
1336 }
1337
1338 /* bp->lock is held. */
1339 static void __b44_set_mac_addr(struct b44 *bp)
1340 {
1341         bw32(bp, B44_CAM_CTRL, 0);
1342         if (!(bp->dev->flags & IFF_PROMISC)) {
1343                 u32 val;
1344
1345                 __b44_cam_write(bp, bp->dev->dev_addr, 0);
1346                 val = br32(bp, B44_CAM_CTRL);
1347                 bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
1348         }
1349 }
1350
1351 static int b44_set_mac_addr(struct net_device *dev, void *p)
1352 {
1353         struct b44 *bp = netdev_priv(dev);
1354         struct sockaddr *addr = p;
1355
1356         if (netif_running(dev))
1357                 return -EBUSY;
1358
1359         if (!is_valid_ether_addr(addr->sa_data))
1360                 return -EINVAL;
1361
1362         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1363
1364         spin_lock_irq(&bp->lock);
1365         __b44_set_mac_addr(bp);
1366         spin_unlock_irq(&bp->lock);
1367
1368         return 0;
1369 }
1370
1371 /* Called at device open time to get the chip ready for
1372  * packet processing.  Invoked with bp->lock held.
1373  */
1374 static void __b44_set_rx_mode(struct net_device *);
1375 static void b44_init_hw(struct b44 *bp, int reset_kind)
1376 {
1377         u32 val;
1378
1379         b44_chip_reset(bp);
1380         if (reset_kind == B44_FULL_RESET) {
1381                 b44_phy_reset(bp);
1382                 b44_setup_phy(bp);
1383         }
1384
1385         /* Enable CRC32, set proper LED modes and power on PHY */
1386         bw32(bp, B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL);
1387         bw32(bp, B44_RCV_LAZY, (1 << RCV_LAZY_FC_SHIFT));
1388
1389         /* This sets the MAC address too.  */
1390         __b44_set_rx_mode(bp->dev);
1391
1392         /* MTU + eth header + possible VLAN tag + struct rx_header */
1393         bw32(bp, B44_RXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
1394         bw32(bp, B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
1395
1396         bw32(bp, B44_TX_WMARK, 56); /* XXX magic */
1397         if (reset_kind == B44_PARTIAL_RESET) {
1398                 bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
1399                                       (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
1400         } else {
1401                 bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
1402                 bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset);
1403                 bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
1404                                       (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
1405                 bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset);
1406
1407                 bw32(bp, B44_DMARX_PTR, bp->rx_pending);
1408                 bp->rx_prod = bp->rx_pending;
1409
1410                 bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
1411         }
1412
1413         val = br32(bp, B44_ENET_CTRL);
1414         bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE));
1415 }
1416
1417 static int b44_open(struct net_device *dev)
1418 {
1419         struct b44 *bp = netdev_priv(dev);
1420         int err;
1421
1422         err = b44_alloc_consistent(bp);
1423         if (err)
1424                 goto out;
1425
1426         b44_init_rings(bp);
1427         b44_init_hw(bp, B44_FULL_RESET);
1428
1429         b44_check_phy(bp);
1430
1431         err = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
1432         if (unlikely(err < 0)) {
1433                 b44_chip_reset(bp);
1434                 b44_free_rings(bp);
1435                 b44_free_consistent(bp);
1436                 goto out;
1437         }
1438
1439         init_timer(&bp->timer);
1440         bp->timer.expires = jiffies + HZ;
1441         bp->timer.data = (unsigned long) bp;
1442         bp->timer.function = b44_timer;
1443         add_timer(&bp->timer);
1444
1445         b44_enable_ints(bp);
1446         netif_start_queue(dev);
1447 out:
1448         return err;
1449 }
1450
1451 #if 0
1452 /*static*/ void b44_dump_state(struct b44 *bp)
1453 {
1454         u32 val32, val32_2, val32_3, val32_4, val32_5;
1455         u16 val16;
1456
1457         pci_read_config_word(bp->pdev, PCI_STATUS, &val16);
1458         printk("DEBUG: PCI status [%04x] \n", val16);
1459
1460 }
1461 #endif
1462
1463 #ifdef CONFIG_NET_POLL_CONTROLLER
1464 /*
1465  * Polling receive - used by netconsole and other diagnostic tools
1466  * to allow network i/o with interrupts disabled.
1467  */
1468 static void b44_poll_controller(struct net_device *dev)
1469 {
1470         disable_irq(dev->irq);
1471         b44_interrupt(dev->irq, dev);
1472         enable_irq(dev->irq);
1473 }
1474 #endif
1475
1476 static void bwfilter_table(struct b44 *bp, u8 *pp, u32 bytes, u32 table_offset)
1477 {
1478         u32 i;
1479         u32 *pattern = (u32 *) pp;
1480
1481         for (i = 0; i < bytes; i += sizeof(u32)) {
1482                 bw32(bp, B44_FILT_ADDR, table_offset + i);
1483                 bw32(bp, B44_FILT_DATA, pattern[i / sizeof(u32)]);
1484         }
1485 }
1486
1487 static int b44_magic_pattern(u8 *macaddr, u8 *ppattern, u8 *pmask, int offset)
1488 {
1489         int magicsync = 6;
1490         int k, j, len = offset;
1491         int ethaddr_bytes = ETH_ALEN;
1492
1493         memset(ppattern + offset, 0xff, magicsync);
1494         for (j = 0; j < magicsync; j++)
1495                 set_bit(len++, (unsigned long *) pmask);
1496
1497         for (j = 0; j < B44_MAX_PATTERNS; j++) {
1498                 if ((B44_PATTERN_SIZE - len) >= ETH_ALEN)
1499                         ethaddr_bytes = ETH_ALEN;
1500                 else
1501                         ethaddr_bytes = B44_PATTERN_SIZE - len;
1502                 if (ethaddr_bytes <=0)
1503                         break;
1504                 for (k = 0; k< ethaddr_bytes; k++) {
1505                         ppattern[offset + magicsync +
1506                                 (j * ETH_ALEN) + k] = macaddr[k];
1507                         len++;
1508                         set_bit(len, (unsigned long *) pmask);
1509                 }
1510         }
1511         return len - 1;
1512 }
1513
1514 /* Setup magic packet patterns in the b44 WOL
1515  * pattern matching filter.
1516  */
1517 static void b44_setup_pseudo_magicp(struct b44 *bp)
1518 {
1519
1520         u32 val;
1521         int plen0, plen1, plen2;
1522         u8 *pwol_pattern;
1523         u8 pwol_mask[B44_PMASK_SIZE];
1524
1525         pwol_pattern = kmalloc(B44_PATTERN_SIZE, GFP_KERNEL);
1526         if (!pwol_pattern) {
1527                 printk(KERN_ERR PFX "Memory not available for WOL\n");
1528                 return;
1529         }
1530
1531         /* Ipv4 magic packet pattern - pattern 0.*/
1532         memset(pwol_pattern, 0, B44_PATTERN_SIZE);
1533         memset(pwol_mask, 0, B44_PMASK_SIZE);
1534         plen0 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
1535                                   B44_ETHIPV4UDP_HLEN);
1536
1537         bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE, B44_PATTERN_BASE);
1538         bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE, B44_PMASK_BASE);
1539
1540         /* Raw ethernet II magic packet pattern - pattern 1 */
1541         memset(pwol_pattern, 0, B44_PATTERN_SIZE);
1542         memset(pwol_mask, 0, B44_PMASK_SIZE);
1543         plen1 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
1544                                   ETH_HLEN);
1545
1546         bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
1547                        B44_PATTERN_BASE + B44_PATTERN_SIZE);
1548         bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
1549                        B44_PMASK_BASE + B44_PMASK_SIZE);
1550
1551         /* Ipv6 magic packet pattern - pattern 2 */
1552         memset(pwol_pattern, 0, B44_PATTERN_SIZE);
1553         memset(pwol_mask, 0, B44_PMASK_SIZE);
1554         plen2 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
1555                                   B44_ETHIPV6UDP_HLEN);
1556
1557         bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
1558                        B44_PATTERN_BASE + B44_PATTERN_SIZE + B44_PATTERN_SIZE);
1559         bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
1560                        B44_PMASK_BASE + B44_PMASK_SIZE + B44_PMASK_SIZE);
1561
1562         kfree(pwol_pattern);
1563
1564         /* set these pattern's lengths: one less than each real length */
1565         val = plen0 | (plen1 << 8) | (plen2 << 16) | WKUP_LEN_ENABLE_THREE;
1566         bw32(bp, B44_WKUP_LEN, val);
1567
1568         /* enable wakeup pattern matching */
1569         val = br32(bp, B44_DEVCTRL);
1570         bw32(bp, B44_DEVCTRL, val | DEVCTRL_PFE);
1571
1572 }
1573
1574 static void b44_setup_wol(struct b44 *bp)
1575 {
1576         u32 val;
1577         u16 pmval;
1578
1579         bw32(bp, B44_RXCONFIG, RXCONFIG_ALLMULTI);
1580
1581         if (bp->flags & B44_FLAG_B0_ANDLATER) {
1582
1583                 bw32(bp, B44_WKUP_LEN, WKUP_LEN_DISABLE);
1584
1585                 val = bp->dev->dev_addr[2] << 24 |
1586                         bp->dev->dev_addr[3] << 16 |
1587                         bp->dev->dev_addr[4] << 8 |
1588                         bp->dev->dev_addr[5];
1589                 bw32(bp, B44_ADDR_LO, val);
1590
1591                 val = bp->dev->dev_addr[0] << 8 |
1592                         bp->dev->dev_addr[1];
1593                 bw32(bp, B44_ADDR_HI, val);
1594
1595                 val = br32(bp, B44_DEVCTRL);
1596                 bw32(bp, B44_DEVCTRL, val | DEVCTRL_MPM | DEVCTRL_PFE);
1597
1598         } else {
1599                 b44_setup_pseudo_magicp(bp);
1600         }
1601
1602         val = br32(bp, B44_SBTMSLOW);
1603         bw32(bp, B44_SBTMSLOW, val | SBTMSLOW_PE);
1604
1605         pci_read_config_word(bp->pdev, SSB_PMCSR, &pmval);
1606         pci_write_config_word(bp->pdev, SSB_PMCSR, pmval | SSB_PE);
1607
1608 }
1609
1610 static int b44_close(struct net_device *dev)
1611 {
1612         struct b44 *bp = netdev_priv(dev);
1613
1614         netif_stop_queue(dev);
1615
1616         netif_poll_disable(dev);
1617
1618         del_timer_sync(&bp->timer);
1619
1620         spin_lock_irq(&bp->lock);
1621
1622 #if 0
1623         b44_dump_state(bp);
1624 #endif
1625         b44_halt(bp);
1626         b44_free_rings(bp);
1627         netif_carrier_off(dev);
1628
1629         spin_unlock_irq(&bp->lock);
1630
1631         free_irq(dev->irq, dev);
1632
1633         netif_poll_enable(dev);
1634
1635         if (bp->flags & B44_FLAG_WOL_ENABLE) {
1636                 b44_init_hw(bp, B44_PARTIAL_RESET);
1637                 b44_setup_wol(bp);
1638         }
1639
1640         b44_free_consistent(bp);
1641
1642         return 0;
1643 }
1644
1645 static struct net_device_stats *b44_get_stats(struct net_device *dev)
1646 {
1647         struct b44 *bp = netdev_priv(dev);
1648         struct net_device_stats *nstat = &bp->stats;
1649         struct b44_hw_stats *hwstat = &bp->hw_stats;
1650
1651         /* Convert HW stats into netdevice stats. */
1652         nstat->rx_packets = hwstat->rx_pkts;
1653         nstat->tx_packets = hwstat->tx_pkts;
1654         nstat->rx_bytes   = hwstat->rx_octets;
1655         nstat->tx_bytes   = hwstat->tx_octets;
1656         nstat->tx_errors  = (hwstat->tx_jabber_pkts +
1657                              hwstat->tx_oversize_pkts +
1658                              hwstat->tx_underruns +
1659                              hwstat->tx_excessive_cols +
1660                              hwstat->tx_late_cols);
1661         nstat->multicast  = hwstat->tx_multicast_pkts;
1662         nstat->collisions = hwstat->tx_total_cols;
1663
1664         nstat->rx_length_errors = (hwstat->rx_oversize_pkts +
1665                                    hwstat->rx_undersize);
1666         nstat->rx_over_errors   = hwstat->rx_missed_pkts;
1667         nstat->rx_frame_errors  = hwstat->rx_align_errs;
1668         nstat->rx_crc_errors    = hwstat->rx_crc_errs;
1669         nstat->rx_errors        = (hwstat->rx_jabber_pkts +
1670                                    hwstat->rx_oversize_pkts +
1671                                    hwstat->rx_missed_pkts +
1672                                    hwstat->rx_crc_align_errs +
1673                                    hwstat->rx_undersize +
1674                                    hwstat->rx_crc_errs +
1675                                    hwstat->rx_align_errs +
1676                                    hwstat->rx_symbol_errs);
1677
1678         nstat->tx_aborted_errors = hwstat->tx_underruns;
1679 #if 0
1680         /* Carrier lost counter seems to be broken for some devices */
1681         nstat->tx_carrier_errors = hwstat->tx_carrier_lost;
1682 #endif
1683
1684         return nstat;
1685 }
1686
1687 static int __b44_load_mcast(struct b44 *bp, struct net_device *dev)
1688 {
1689         struct dev_mc_list *mclist;
1690         int i, num_ents;
1691
1692         num_ents = min_t(int, dev->mc_count, B44_MCAST_TABLE_SIZE);
1693         mclist = dev->mc_list;
1694         for (i = 0; mclist && i < num_ents; i++, mclist = mclist->next) {
1695                 __b44_cam_write(bp, mclist->dmi_addr, i + 1);
1696         }
1697         return i+1;
1698 }
1699
1700 static void __b44_set_rx_mode(struct net_device *dev)
1701 {
1702         struct b44 *bp = netdev_priv(dev);
1703         u32 val;
1704
1705         val = br32(bp, B44_RXCONFIG);
1706         val &= ~(RXCONFIG_PROMISC | RXCONFIG_ALLMULTI);
1707         if (dev->flags & IFF_PROMISC) {
1708                 val |= RXCONFIG_PROMISC;
1709                 bw32(bp, B44_RXCONFIG, val);
1710         } else {
1711                 unsigned char zero[6] = {0, 0, 0, 0, 0, 0};
1712                 int i = 1;
1713
1714                 __b44_set_mac_addr(bp);
1715
1716                 if ((dev->flags & IFF_ALLMULTI) ||
1717                     (dev->mc_count > B44_MCAST_TABLE_SIZE))
1718                         val |= RXCONFIG_ALLMULTI;
1719                 else
1720                         i = __b44_load_mcast(bp, dev);
1721
1722                 for (; i < 64; i++)
1723                         __b44_cam_write(bp, zero, i);
1724
1725                 bw32(bp, B44_RXCONFIG, val);
1726                 val = br32(bp, B44_CAM_CTRL);
1727                 bw32(bp, B44_CAM_CTRL, val | CAM_CTRL_ENABLE);
1728         }
1729 }
1730
1731 static void b44_set_rx_mode(struct net_device *dev)
1732 {
1733         struct b44 *bp = netdev_priv(dev);
1734
1735         spin_lock_irq(&bp->lock);
1736         __b44_set_rx_mode(dev);
1737         spin_unlock_irq(&bp->lock);
1738 }
1739
1740 static u32 b44_get_msglevel(struct net_device *dev)
1741 {
1742         struct b44 *bp = netdev_priv(dev);
1743         return bp->msg_enable;
1744 }
1745
1746 static void b44_set_msglevel(struct net_device *dev, u32 value)
1747 {
1748         struct b44 *bp = netdev_priv(dev);
1749         bp->msg_enable = value;
1750 }
1751
1752 static void b44_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
1753 {
1754         struct b44 *bp = netdev_priv(dev);
1755         struct pci_dev *pci_dev = bp->pdev;
1756
1757         strcpy (info->driver, DRV_MODULE_NAME);
1758         strcpy (info->version, DRV_MODULE_VERSION);
1759         strcpy (info->bus_info, pci_name(pci_dev));
1760 }
1761
1762 static int b44_nway_reset(struct net_device *dev)
1763 {
1764         struct b44 *bp = netdev_priv(dev);
1765         u32 bmcr;
1766         int r;
1767
1768         spin_lock_irq(&bp->lock);
1769         b44_readphy(bp, MII_BMCR, &bmcr);
1770         b44_readphy(bp, MII_BMCR, &bmcr);
1771         r = -EINVAL;
1772         if (bmcr & BMCR_ANENABLE) {
1773                 b44_writephy(bp, MII_BMCR,
1774                              bmcr | BMCR_ANRESTART);
1775                 r = 0;
1776         }
1777         spin_unlock_irq(&bp->lock);
1778
1779         return r;
1780 }
1781
1782 static int b44_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1783 {
1784         struct b44 *bp = netdev_priv(dev);
1785
1786         cmd->supported = (SUPPORTED_Autoneg);
1787         cmd->supported |= (SUPPORTED_100baseT_Half |
1788                           SUPPORTED_100baseT_Full |
1789                           SUPPORTED_10baseT_Half |
1790                           SUPPORTED_10baseT_Full |
1791                           SUPPORTED_MII);
1792
1793         cmd->advertising = 0;
1794         if (bp->flags & B44_FLAG_ADV_10HALF)
1795                 cmd->advertising |= ADVERTISED_10baseT_Half;
1796         if (bp->flags & B44_FLAG_ADV_10FULL)
1797                 cmd->advertising |= ADVERTISED_10baseT_Full;
1798         if (bp->flags & B44_FLAG_ADV_100HALF)
1799                 cmd->advertising |= ADVERTISED_100baseT_Half;
1800         if (bp->flags & B44_FLAG_ADV_100FULL)
1801                 cmd->advertising |= ADVERTISED_100baseT_Full;
1802         cmd->advertising |= ADVERTISED_Pause | ADVERTISED_Asym_Pause;
1803         cmd->speed = (bp->flags & B44_FLAG_100_BASE_T) ?
1804                 SPEED_100 : SPEED_10;
1805         cmd->duplex = (bp->flags & B44_FLAG_FULL_DUPLEX) ?
1806                 DUPLEX_FULL : DUPLEX_HALF;
1807         cmd->port = 0;
1808         cmd->phy_address = bp->phy_addr;
1809         cmd->transceiver = (bp->flags & B44_FLAG_INTERNAL_PHY) ?
1810                 XCVR_INTERNAL : XCVR_EXTERNAL;
1811         cmd->autoneg = (bp->flags & B44_FLAG_FORCE_LINK) ?
1812                 AUTONEG_DISABLE : AUTONEG_ENABLE;
1813         if (cmd->autoneg == AUTONEG_ENABLE)
1814                 cmd->advertising |= ADVERTISED_Autoneg;
1815         if (!netif_running(dev)){
1816                 cmd->speed = 0;
1817                 cmd->duplex = 0xff;
1818         }
1819         cmd->maxtxpkt = 0;
1820         cmd->maxrxpkt = 0;
1821         return 0;
1822 }
1823
1824 static int b44_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1825 {
1826         struct b44 *bp = netdev_priv(dev);
1827
1828         /* We do not support gigabit. */
1829         if (cmd->autoneg == AUTONEG_ENABLE) {
1830                 if (cmd->advertising &
1831                     (ADVERTISED_1000baseT_Half |
1832                      ADVERTISED_1000baseT_Full))
1833                         return -EINVAL;
1834         } else if ((cmd->speed != SPEED_100 &&
1835                     cmd->speed != SPEED_10) ||
1836                    (cmd->duplex != DUPLEX_HALF &&
1837                     cmd->duplex != DUPLEX_FULL)) {
1838                         return -EINVAL;
1839         }
1840
1841         spin_lock_irq(&bp->lock);
1842
1843         if (cmd->autoneg == AUTONEG_ENABLE) {
1844                 bp->flags &= ~(B44_FLAG_FORCE_LINK |
1845                                B44_FLAG_100_BASE_T |
1846                                B44_FLAG_FULL_DUPLEX |
1847                                B44_FLAG_ADV_10HALF |
1848                                B44_FLAG_ADV_10FULL |
1849                                B44_FLAG_ADV_100HALF |
1850                                B44_FLAG_ADV_100FULL);
1851                 if (cmd->advertising == 0) {
1852                         bp->flags |= (B44_FLAG_ADV_10HALF |
1853                                       B44_FLAG_ADV_10FULL |
1854                                       B44_FLAG_ADV_100HALF |
1855                                       B44_FLAG_ADV_100FULL);
1856                 } else {
1857                         if (cmd->advertising & ADVERTISED_10baseT_Half)
1858                                 bp->flags |= B44_FLAG_ADV_10HALF;
1859                         if (cmd->advertising & ADVERTISED_10baseT_Full)
1860                                 bp->flags |= B44_FLAG_ADV_10FULL;
1861                         if (cmd->advertising & ADVERTISED_100baseT_Half)
1862                                 bp->flags |= B44_FLAG_ADV_100HALF;
1863                         if (cmd->advertising & ADVERTISED_100baseT_Full)
1864                                 bp->flags |= B44_FLAG_ADV_100FULL;
1865                 }
1866         } else {
1867                 bp->flags |= B44_FLAG_FORCE_LINK;
1868                 bp->flags &= ~(B44_FLAG_100_BASE_T | B44_FLAG_FULL_DUPLEX);
1869                 if (cmd->speed == SPEED_100)
1870                         bp->flags |= B44_FLAG_100_BASE_T;
1871                 if (cmd->duplex == DUPLEX_FULL)
1872                         bp->flags |= B44_FLAG_FULL_DUPLEX;
1873         }
1874
1875         if (netif_running(dev))
1876                 b44_setup_phy(bp);
1877
1878         spin_unlock_irq(&bp->lock);
1879
1880         return 0;
1881 }
1882
1883 static void b44_get_ringparam(struct net_device *dev,
1884                               struct ethtool_ringparam *ering)
1885 {
1886         struct b44 *bp = netdev_priv(dev);
1887
1888         ering->rx_max_pending = B44_RX_RING_SIZE - 1;
1889         ering->rx_pending = bp->rx_pending;
1890
1891         /* XXX ethtool lacks a tx_max_pending, oops... */
1892 }
1893
1894 static int b44_set_ringparam(struct net_device *dev,
1895                              struct ethtool_ringparam *ering)
1896 {
1897         struct b44 *bp = netdev_priv(dev);
1898
1899         if ((ering->rx_pending > B44_RX_RING_SIZE - 1) ||
1900             (ering->rx_mini_pending != 0) ||
1901             (ering->rx_jumbo_pending != 0) ||
1902             (ering->tx_pending > B44_TX_RING_SIZE - 1))
1903                 return -EINVAL;
1904
1905         spin_lock_irq(&bp->lock);
1906
1907         bp->rx_pending = ering->rx_pending;
1908         bp->tx_pending = ering->tx_pending;
1909
1910         b44_halt(bp);
1911         b44_init_rings(bp);
1912         b44_init_hw(bp, B44_FULL_RESET);
1913         netif_wake_queue(bp->dev);
1914         spin_unlock_irq(&bp->lock);
1915
1916         b44_enable_ints(bp);
1917
1918         return 0;
1919 }
1920
1921 static void b44_get_pauseparam(struct net_device *dev,
1922                                 struct ethtool_pauseparam *epause)
1923 {
1924         struct b44 *bp = netdev_priv(dev);
1925
1926         epause->autoneg =
1927                 (bp->flags & B44_FLAG_PAUSE_AUTO) != 0;
1928         epause->rx_pause =
1929                 (bp->flags & B44_FLAG_RX_PAUSE) != 0;
1930         epause->tx_pause =
1931                 (bp->flags & B44_FLAG_TX_PAUSE) != 0;
1932 }
1933
1934 static int b44_set_pauseparam(struct net_device *dev,
1935                                 struct ethtool_pauseparam *epause)
1936 {
1937         struct b44 *bp = netdev_priv(dev);
1938
1939         spin_lock_irq(&bp->lock);
1940         if (epause->autoneg)
1941                 bp->flags |= B44_FLAG_PAUSE_AUTO;
1942         else
1943                 bp->flags &= ~B44_FLAG_PAUSE_AUTO;
1944         if (epause->rx_pause)
1945                 bp->flags |= B44_FLAG_RX_PAUSE;
1946         else
1947                 bp->flags &= ~B44_FLAG_RX_PAUSE;
1948         if (epause->tx_pause)
1949                 bp->flags |= B44_FLAG_TX_PAUSE;
1950         else
1951                 bp->flags &= ~B44_FLAG_TX_PAUSE;
1952         if (bp->flags & B44_FLAG_PAUSE_AUTO) {
1953                 b44_halt(bp);
1954                 b44_init_rings(bp);
1955                 b44_init_hw(bp, B44_FULL_RESET);
1956         } else {
1957                 __b44_set_flow_ctrl(bp, bp->flags);
1958         }
1959         spin_unlock_irq(&bp->lock);
1960
1961         b44_enable_ints(bp);
1962
1963         return 0;
1964 }
1965
1966 static void b44_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1967 {
1968         switch(stringset) {
1969         case ETH_SS_STATS:
1970                 memcpy(data, *b44_gstrings, sizeof(b44_gstrings));
1971                 break;
1972         }
1973 }
1974
1975 static int b44_get_stats_count(struct net_device *dev)
1976 {
1977         return ARRAY_SIZE(b44_gstrings);
1978 }
1979
1980 static void b44_get_ethtool_stats(struct net_device *dev,
1981                                   struct ethtool_stats *stats, u64 *data)
1982 {
1983         struct b44 *bp = netdev_priv(dev);
1984         u32 *val = &bp->hw_stats.tx_good_octets;
1985         u32 i;
1986
1987         spin_lock_irq(&bp->lock);
1988
1989         b44_stats_update(bp);
1990
1991         for (i = 0; i < ARRAY_SIZE(b44_gstrings); i++)
1992                 *data++ = *val++;
1993
1994         spin_unlock_irq(&bp->lock);
1995 }
1996
1997 static void b44_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1998 {
1999         struct b44 *bp = netdev_priv(dev);
2000
2001         wol->supported = WAKE_MAGIC;
2002         if (bp->flags & B44_FLAG_WOL_ENABLE)
2003                 wol->wolopts = WAKE_MAGIC;
2004         else
2005                 wol->wolopts = 0;
2006         memset(&wol->sopass, 0, sizeof(wol->sopass));
2007 }
2008
2009 static int b44_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
2010 {
2011         struct b44 *bp = netdev_priv(dev);
2012
2013         spin_lock_irq(&bp->lock);
2014         if (wol->wolopts & WAKE_MAGIC)
2015                 bp->flags |= B44_FLAG_WOL_ENABLE;
2016         else
2017                 bp->flags &= ~B44_FLAG_WOL_ENABLE;
2018         spin_unlock_irq(&bp->lock);
2019
2020         return 0;
2021 }
2022
2023 static const struct ethtool_ops b44_ethtool_ops = {
2024         .get_drvinfo            = b44_get_drvinfo,
2025         .get_settings           = b44_get_settings,
2026         .set_settings           = b44_set_settings,
2027         .nway_reset             = b44_nway_reset,
2028         .get_link               = ethtool_op_get_link,
2029         .get_wol                = b44_get_wol,
2030         .set_wol                = b44_set_wol,
2031         .get_ringparam          = b44_get_ringparam,
2032         .set_ringparam          = b44_set_ringparam,
2033         .get_pauseparam         = b44_get_pauseparam,
2034         .set_pauseparam         = b44_set_pauseparam,
2035         .get_msglevel           = b44_get_msglevel,
2036         .set_msglevel           = b44_set_msglevel,
2037         .get_strings            = b44_get_strings,
2038         .get_stats_count        = b44_get_stats_count,
2039         .get_ethtool_stats      = b44_get_ethtool_stats,
2040         .get_perm_addr          = ethtool_op_get_perm_addr,
2041 };
2042
2043 static int b44_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2044 {
2045         struct mii_ioctl_data *data = if_mii(ifr);
2046         struct b44 *bp = netdev_priv(dev);
2047         int err = -EINVAL;
2048
2049         if (!netif_running(dev))
2050                 goto out;
2051
2052         spin_lock_irq(&bp->lock);
2053         err = generic_mii_ioctl(&bp->mii_if, data, cmd, NULL);
2054         spin_unlock_irq(&bp->lock);
2055 out:
2056         return err;
2057 }
2058
2059 /* Read 128-bytes of EEPROM. */
2060 static int b44_read_eeprom(struct b44 *bp, u8 *data)
2061 {
2062         long i;
2063         __le16 *ptr = (__le16 *) data;
2064
2065         for (i = 0; i < 128; i += 2)
2066                 ptr[i / 2] = cpu_to_le16(readw(bp->regs + 4096 + i));
2067
2068         return 0;
2069 }
2070
2071 static int __devinit b44_get_invariants(struct b44 *bp)
2072 {
2073         u8 eeprom[128];
2074         int err;
2075
2076         err = b44_read_eeprom(bp, &eeprom[0]);
2077         if (err)
2078                 goto out;
2079
2080         bp->dev->dev_addr[0] = eeprom[79];
2081         bp->dev->dev_addr[1] = eeprom[78];
2082         bp->dev->dev_addr[2] = eeprom[81];
2083         bp->dev->dev_addr[3] = eeprom[80];
2084         bp->dev->dev_addr[4] = eeprom[83];
2085         bp->dev->dev_addr[5] = eeprom[82];
2086
2087         if (!is_valid_ether_addr(&bp->dev->dev_addr[0])){
2088                 printk(KERN_ERR PFX "Invalid MAC address found in EEPROM\n");
2089                 return -EINVAL;
2090         }
2091
2092         memcpy(bp->dev->perm_addr, bp->dev->dev_addr, bp->dev->addr_len);
2093
2094         bp->phy_addr = eeprom[90] & 0x1f;
2095
2096         /* With this, plus the rx_header prepended to the data by the
2097          * hardware, we'll land the ethernet header on a 2-byte boundary.
2098          */
2099         bp->rx_offset = 30;
2100
2101         bp->imask = IMASK_DEF;
2102
2103         bp->core_unit = ssb_core_unit(bp);
2104         bp->dma_offset = SB_PCI_DMA;
2105
2106         /* XXX - really required?
2107            bp->flags |= B44_FLAG_BUGGY_TXPTR;
2108          */
2109
2110         if (ssb_get_core_rev(bp) >= 7)
2111                 bp->flags |= B44_FLAG_B0_ANDLATER;
2112
2113 out:
2114         return err;
2115 }
2116
2117 static int __devinit b44_init_one(struct pci_dev *pdev,
2118                                   const struct pci_device_id *ent)
2119 {
2120         static int b44_version_printed = 0;
2121         unsigned long b44reg_base, b44reg_len;
2122         struct net_device *dev;
2123         struct b44 *bp;
2124         int err, i;
2125
2126         if (b44_version_printed++ == 0)
2127                 printk(KERN_INFO "%s", version);
2128
2129         err = pci_enable_device(pdev);
2130         if (err) {
2131                 dev_err(&pdev->dev, "Cannot enable PCI device, "
2132                        "aborting.\n");
2133                 return err;
2134         }
2135
2136         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
2137                 dev_err(&pdev->dev,
2138                         "Cannot find proper PCI device "
2139                        "base address, aborting.\n");
2140                 err = -ENODEV;
2141                 goto err_out_disable_pdev;
2142         }
2143
2144         err = pci_request_regions(pdev, DRV_MODULE_NAME);
2145         if (err) {
2146                 dev_err(&pdev->dev,
2147                         "Cannot obtain PCI resources, aborting.\n");
2148                 goto err_out_disable_pdev;
2149         }
2150
2151         pci_set_master(pdev);
2152
2153         err = pci_set_dma_mask(pdev, (u64) DMA_30BIT_MASK);
2154         if (err) {
2155                 dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n");
2156                 goto err_out_free_res;
2157         }
2158
2159         err = pci_set_consistent_dma_mask(pdev, (u64) DMA_30BIT_MASK);
2160         if (err) {
2161                 dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n");
2162                 goto err_out_free_res;
2163         }
2164
2165         b44reg_base = pci_resource_start(pdev, 0);
2166         b44reg_len = pci_resource_len(pdev, 0);
2167
2168         dev = alloc_etherdev(sizeof(*bp));
2169         if (!dev) {
2170                 dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n");
2171                 err = -ENOMEM;
2172                 goto err_out_free_res;
2173         }
2174
2175         SET_MODULE_OWNER(dev);
2176         SET_NETDEV_DEV(dev,&pdev->dev);
2177
2178         /* No interesting netdevice features in this card... */
2179         dev->features |= 0;
2180
2181         bp = netdev_priv(dev);
2182         bp->pdev = pdev;
2183         bp->dev = dev;
2184
2185         bp->msg_enable = netif_msg_init(b44_debug, B44_DEF_MSG_ENABLE);
2186
2187         spin_lock_init(&bp->lock);
2188
2189         bp->regs = ioremap(b44reg_base, b44reg_len);
2190         if (bp->regs == 0UL) {
2191                 dev_err(&pdev->dev, "Cannot map device registers, aborting.\n");
2192                 err = -ENOMEM;
2193                 goto err_out_free_dev;
2194         }
2195
2196         bp->rx_pending = B44_DEF_RX_RING_PENDING;
2197         bp->tx_pending = B44_DEF_TX_RING_PENDING;
2198
2199         dev->open = b44_open;
2200         dev->stop = b44_close;
2201         dev->hard_start_xmit = b44_start_xmit;
2202         dev->get_stats = b44_get_stats;
2203         dev->set_multicast_list = b44_set_rx_mode;
2204         dev->set_mac_address = b44_set_mac_addr;
2205         dev->do_ioctl = b44_ioctl;
2206         dev->tx_timeout = b44_tx_timeout;
2207         dev->poll = b44_poll;
2208         dev->weight = 64;
2209         dev->watchdog_timeo = B44_TX_TIMEOUT;
2210 #ifdef CONFIG_NET_POLL_CONTROLLER
2211         dev->poll_controller = b44_poll_controller;
2212 #endif
2213         dev->change_mtu = b44_change_mtu;
2214         dev->irq = pdev->irq;
2215         SET_ETHTOOL_OPS(dev, &b44_ethtool_ops);
2216
2217         netif_carrier_off(dev);
2218
2219         err = b44_get_invariants(bp);
2220         if (err) {
2221                 dev_err(&pdev->dev,
2222                         "Problem fetching invariants of chip, aborting.\n");
2223                 goto err_out_iounmap;
2224         }
2225
2226         bp->mii_if.dev = dev;
2227         bp->mii_if.mdio_read = b44_mii_read;
2228         bp->mii_if.mdio_write = b44_mii_write;
2229         bp->mii_if.phy_id = bp->phy_addr;
2230         bp->mii_if.phy_id_mask = 0x1f;
2231         bp->mii_if.reg_num_mask = 0x1f;
2232
2233         /* By default, advertise all speed/duplex settings. */
2234         bp->flags |= (B44_FLAG_ADV_10HALF | B44_FLAG_ADV_10FULL |
2235                       B44_FLAG_ADV_100HALF | B44_FLAG_ADV_100FULL);
2236
2237         /* By default, auto-negotiate PAUSE. */
2238         bp->flags |= B44_FLAG_PAUSE_AUTO;
2239
2240         err = register_netdev(dev);
2241         if (err) {
2242                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
2243                 goto err_out_iounmap;
2244         }
2245
2246         pci_set_drvdata(pdev, dev);
2247
2248         pci_save_state(bp->pdev);
2249
2250         /* Chip reset provides power to the b44 MAC & PCI cores, which
2251          * is necessary for MAC register access.
2252          */
2253         b44_chip_reset(bp);
2254
2255         printk(KERN_INFO "%s: Broadcom 4400 10/100BaseT Ethernet ", dev->name);
2256         for (i = 0; i < 6; i++)
2257                 printk("%2.2x%c", dev->dev_addr[i],
2258                        i == 5 ? '\n' : ':');
2259
2260         return 0;
2261
2262 err_out_iounmap:
2263         iounmap(bp->regs);
2264
2265 err_out_free_dev:
2266         free_netdev(dev);
2267
2268 err_out_free_res:
2269         pci_release_regions(pdev);
2270
2271 err_out_disable_pdev:
2272         pci_disable_device(pdev);
2273         pci_set_drvdata(pdev, NULL);
2274         return err;
2275 }
2276
2277 static void __devexit b44_remove_one(struct pci_dev *pdev)
2278 {
2279         struct net_device *dev = pci_get_drvdata(pdev);
2280         struct b44 *bp = netdev_priv(dev);
2281
2282         unregister_netdev(dev);
2283         iounmap(bp->regs);
2284         free_netdev(dev);
2285         pci_release_regions(pdev);
2286         pci_disable_device(pdev);
2287         pci_set_drvdata(pdev, NULL);
2288 }
2289
2290 static int b44_suspend(struct pci_dev *pdev, pm_message_t state)
2291 {
2292         struct net_device *dev = pci_get_drvdata(pdev);
2293         struct b44 *bp = netdev_priv(dev);
2294
2295         if (!netif_running(dev))
2296                  return 0;
2297
2298         del_timer_sync(&bp->timer);
2299
2300         spin_lock_irq(&bp->lock);
2301
2302         b44_halt(bp);
2303         netif_carrier_off(bp->dev);
2304         netif_device_detach(bp->dev);
2305         b44_free_rings(bp);
2306
2307         spin_unlock_irq(&bp->lock);
2308
2309         free_irq(dev->irq, dev);
2310         if (bp->flags & B44_FLAG_WOL_ENABLE) {
2311                 b44_init_hw(bp, B44_PARTIAL_RESET);
2312                 b44_setup_wol(bp);
2313         }
2314         pci_disable_device(pdev);
2315         return 0;
2316 }
2317
2318 static int b44_resume(struct pci_dev *pdev)
2319 {
2320         struct net_device *dev = pci_get_drvdata(pdev);
2321         struct b44 *bp = netdev_priv(dev);
2322         int rc = 0;
2323
2324         pci_restore_state(pdev);
2325         rc = pci_enable_device(pdev);
2326         if (rc) {
2327                 printk(KERN_ERR PFX "%s: pci_enable_device failed\n",
2328                         dev->name);
2329                 return rc;
2330         }
2331
2332         pci_set_master(pdev);
2333
2334         if (!netif_running(dev))
2335                 return 0;
2336
2337         rc = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
2338         if (rc) {
2339                 printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
2340                 pci_disable_device(pdev);
2341                 return rc;
2342         }
2343
2344         spin_lock_irq(&bp->lock);
2345
2346         b44_init_rings(bp);
2347         b44_init_hw(bp, B44_FULL_RESET);
2348         netif_device_attach(bp->dev);
2349         spin_unlock_irq(&bp->lock);
2350
2351         bp->timer.expires = jiffies + HZ;
2352         add_timer(&bp->timer);
2353
2354         b44_enable_ints(bp);
2355         netif_wake_queue(dev);
2356         return 0;
2357 }
2358
2359 static struct pci_driver b44_driver = {
2360         .name           = DRV_MODULE_NAME,
2361         .id_table       = b44_pci_tbl,
2362         .probe          = b44_init_one,
2363         .remove         = __devexit_p(b44_remove_one),
2364         .suspend        = b44_suspend,
2365         .resume         = b44_resume,
2366 };
2367
2368 static int __init b44_init(void)
2369 {
2370         unsigned int dma_desc_align_size = dma_get_cache_alignment();
2371
2372         /* Setup paramaters for syncing RX/TX DMA descriptors */
2373         dma_desc_align_mask = ~(dma_desc_align_size - 1);
2374         dma_desc_sync_size = max_t(unsigned int, dma_desc_align_size, sizeof(struct dma_desc));
2375
2376         return pci_register_driver(&b44_driver);
2377 }
2378
2379 static void __exit b44_cleanup(void)
2380 {
2381         pci_unregister_driver(&b44_driver);
2382 }
2383
2384 module_init(b44_init);
2385 module_exit(b44_cleanup);
2386