?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'v3.3.7' into 3.3/master
[zen-stable.git] / drivers / net / ethernet / broadcom / b44.c
blobcab87456a34a33a54a328d48fefd9086eb936b6d
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 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