← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/broadcom/b44.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

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