#define DRV_MODULE_NAME "b44"
#define PFX DRV_MODULE_NAME ": "
-#define DRV_MODULE_VERSION "1.01"
-#define DRV_MODULE_RELDATE "Jun 16, 2006"
+#define DRV_MODULE_VERSION "1.00"
+#define DRV_MODULE_RELDATE "Apr 7, 2006"
#define B44_DEF_MSG_ENABLE \
(NETIF_MSG_DRV | \
/* minimum number of free TX descriptors required to wake up TX process */
#define B44_TX_WAKEUP_THRESH (B44_TX_RING_SIZE / 4)
-/* b44 internal pattern match filter info */
-#define B44_PATTERN_BASE 0x400
-#define B44_PATTERN_SIZE 0x80
-#define B44_PMASK_BASE 0x600
-#define B44_PMASK_SIZE 0x10
-#define B44_MAX_PATTERNS 16
-#define B44_ETHIPV6UDP_HLEN 62
-#define B44_ETHIPV4UDP_HLEN 42
-
static char version[] __devinitdata =
DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
static void b44_halt(struct b44 *);
static void b44_init_rings(struct b44 *);
-static void b44_init_hw(struct b44 *, int);
+static void b44_init_hw(struct b44 *);
static int dma_desc_align_mask;
static int dma_desc_sync_size;
spin_lock_irq(&bp->lock);
b44_halt(bp);
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
netif_wake_queue(bp->dev);
spin_unlock_irq(&bp->lock);
done = 1;
b44_halt(bp);
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
spin_unlock_irq(&bp->lock);
b44_halt(bp);
dev->mtu = new_mtu;
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
spin_unlock_irq(&bp->lock);
b44_enable_ints(bp);
* packet processing. Invoked with bp->lock held.
*/
static void __b44_set_rx_mode(struct net_device *);
-static void b44_init_hw(struct b44 *bp, int full_reset)
+static void b44_init_hw(struct b44 *bp)
{
u32 val;
b44_chip_reset(bp);
- if (full_reset) {
- b44_phy_reset(bp);
- b44_setup_phy(bp);
- }
+ b44_phy_reset(bp);
+ b44_setup_phy(bp);
/* Enable CRC32, set proper LED modes and power on PHY */
bw32(bp, B44_MAC_CTRL, MAC_CTRL_CRC32_ENAB | MAC_CTRL_PHY_LEDCTRL);
bw32(bp, B44_TXMAXLEN, bp->dev->mtu + ETH_HLEN + 8 + RX_HEADER_LEN);
bw32(bp, B44_TX_WMARK, 56); /* XXX magic */
- if (full_reset) {
- bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
- bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset);
- bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
- (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
- bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset);
+ bw32(bp, B44_DMATX_CTRL, DMATX_CTRL_ENABLE);
+ bw32(bp, B44_DMATX_ADDR, bp->tx_ring_dma + bp->dma_offset);
+ bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
+ (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
+ bw32(bp, B44_DMARX_ADDR, bp->rx_ring_dma + bp->dma_offset);
- bw32(bp, B44_DMARX_PTR, bp->rx_pending);
- bp->rx_prod = bp->rx_pending;
+ bw32(bp, B44_DMARX_PTR, bp->rx_pending);
+ bp->rx_prod = bp->rx_pending;
- bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
- } else {
- bw32(bp, B44_DMARX_CTRL, (DMARX_CTRL_ENABLE |
- (bp->rx_offset << DMARX_CTRL_ROSHIFT)));
- }
+ bw32(bp, B44_MIB_CTRL, MIB_CTRL_CLR_ON_READ);
val = br32(bp, B44_ENET_CTRL);
bw32(bp, B44_ENET_CTRL, (val | ENET_CTRL_ENABLE));
goto out;
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
b44_check_phy(bp);
- err = request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev);
+ err = request_irq(dev->irq, b44_interrupt, SA_SHIRQ, dev->name, dev);
if (unlikely(err < 0)) {
b44_chip_reset(bp);
b44_free_rings(bp);
}
#endif
-static void bwfilter_table(struct b44 *bp, u8 *pp, u32 bytes, u32 table_offset)
-{
- u32 i;
- u32 *pattern = (u32 *) pp;
-
- for (i = 0; i < bytes; i += sizeof(u32)) {
- bw32(bp, B44_FILT_ADDR, table_offset + i);
- bw32(bp, B44_FILT_DATA, pattern[i / sizeof(u32)]);
- }
-}
-
-static int b44_magic_pattern(u8 *macaddr, u8 *ppattern, u8 *pmask, int offset)
-{
- int magicsync = 6;
- int k, j, len = offset;
- int ethaddr_bytes = ETH_ALEN;
-
- memset(ppattern + offset, 0xff, magicsync);
- for (j = 0; j < magicsync; j++)
- set_bit(len++, (unsigned long *) pmask);
-
- for (j = 0; j < B44_MAX_PATTERNS; j++) {
- if ((B44_PATTERN_SIZE - len) >= ETH_ALEN)
- ethaddr_bytes = ETH_ALEN;
- else
- ethaddr_bytes = B44_PATTERN_SIZE - len;
- if (ethaddr_bytes <=0)
- break;
- for (k = 0; k< ethaddr_bytes; k++) {
- ppattern[offset + magicsync +
- (j * ETH_ALEN) + k] = macaddr[k];
- len++;
- set_bit(len, (unsigned long *) pmask);
- }
- }
- return len - 1;
-}
-
-/* Setup magic packet patterns in the b44 WOL
- * pattern matching filter.
- */
-static void b44_setup_pseudo_magicp(struct b44 *bp)
-{
-
- u32 val;
- int plen0, plen1, plen2;
- u8 *pwol_pattern;
- u8 pwol_mask[B44_PMASK_SIZE];
-
- pwol_pattern = kmalloc(B44_PATTERN_SIZE, GFP_KERNEL);
- if (!pwol_pattern) {
- printk(KERN_ERR PFX "Memory not available for WOL\n");
- return;
- }
-
- /* Ipv4 magic packet pattern - pattern 0.*/
- memset(pwol_pattern, 0, B44_PATTERN_SIZE);
- memset(pwol_mask, 0, B44_PMASK_SIZE);
- plen0 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
- B44_ETHIPV4UDP_HLEN);
-
- bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE, B44_PATTERN_BASE);
- bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE, B44_PMASK_BASE);
-
- /* Raw ethernet II magic packet pattern - pattern 1 */
- memset(pwol_pattern, 0, B44_PATTERN_SIZE);
- memset(pwol_mask, 0, B44_PMASK_SIZE);
- plen1 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
- ETH_HLEN);
-
- bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
- B44_PATTERN_BASE + B44_PATTERN_SIZE);
- bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
- B44_PMASK_BASE + B44_PMASK_SIZE);
-
- /* Ipv6 magic packet pattern - pattern 2 */
- memset(pwol_pattern, 0, B44_PATTERN_SIZE);
- memset(pwol_mask, 0, B44_PMASK_SIZE);
- plen2 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
- B44_ETHIPV6UDP_HLEN);
-
- bwfilter_table(bp, pwol_pattern, B44_PATTERN_SIZE,
- B44_PATTERN_BASE + B44_PATTERN_SIZE + B44_PATTERN_SIZE);
- bwfilter_table(bp, pwol_mask, B44_PMASK_SIZE,
- B44_PMASK_BASE + B44_PMASK_SIZE + B44_PMASK_SIZE);
-
- kfree(pwol_pattern);
-
- /* set these pattern's lengths: one less than each real length */
- val = plen0 | (plen1 << 8) | (plen2 << 16) | WKUP_LEN_ENABLE_THREE;
- bw32(bp, B44_WKUP_LEN, val);
-
- /* enable wakeup pattern matching */
- val = br32(bp, B44_DEVCTRL);
- bw32(bp, B44_DEVCTRL, val | DEVCTRL_PFE);
-
-}
-
-static void b44_setup_wol(struct b44 *bp)
-{
- u32 val;
- u16 pmval;
-
- bw32(bp, B44_RXCONFIG, RXCONFIG_ALLMULTI);
-
- if (bp->flags & B44_FLAG_B0_ANDLATER) {
-
- bw32(bp, B44_WKUP_LEN, WKUP_LEN_DISABLE);
-
- val = bp->dev->dev_addr[2] << 24 |
- bp->dev->dev_addr[3] << 16 |
- bp->dev->dev_addr[4] << 8 |
- bp->dev->dev_addr[5];
- bw32(bp, B44_ADDR_LO, val);
-
- val = bp->dev->dev_addr[0] << 8 |
- bp->dev->dev_addr[1];
- bw32(bp, B44_ADDR_HI, val);
-
- val = br32(bp, B44_DEVCTRL);
- bw32(bp, B44_DEVCTRL, val | DEVCTRL_MPM | DEVCTRL_PFE);
-
- } else {
- b44_setup_pseudo_magicp(bp);
- }
-
- val = br32(bp, B44_SBTMSLOW);
- bw32(bp, B44_SBTMSLOW, val | SBTMSLOW_PE);
-
- pci_read_config_word(bp->pdev, SSB_PMCSR, &pmval);
- pci_write_config_word(bp->pdev, SSB_PMCSR, pmval | SSB_PE);
-
-}
-
static int b44_close(struct net_device *dev)
{
struct b44 *bp = netdev_priv(dev);
netif_poll_enable(dev);
- if (bp->flags & B44_FLAG_WOL_ENABLE) {
- b44_init_hw(bp, 0);
- b44_setup_wol(bp);
- }
-
b44_free_consistent(bp);
return 0;
{
struct b44 *bp = netdev_priv(dev);
+ if (!netif_running(dev))
+ return -EAGAIN;
cmd->supported = (SUPPORTED_Autoneg);
cmd->supported |= (SUPPORTED_100baseT_Half |
SUPPORTED_100baseT_Full |
XCVR_INTERNAL : XCVR_EXTERNAL;
cmd->autoneg = (bp->flags & B44_FLAG_FORCE_LINK) ?
AUTONEG_DISABLE : AUTONEG_ENABLE;
- if (cmd->autoneg == AUTONEG_ENABLE)
- cmd->advertising |= ADVERTISED_Autoneg;
- if (!netif_running(dev)){
- cmd->speed = 0;
- cmd->duplex = 0xff;
- }
cmd->maxtxpkt = 0;
cmd->maxrxpkt = 0;
return 0;
{
struct b44 *bp = netdev_priv(dev);
+ if (!netif_running(dev))
+ return -EAGAIN;
+
/* We do not support gigabit. */
if (cmd->autoneg == AUTONEG_ENABLE) {
if (cmd->advertising &
spin_lock_irq(&bp->lock);
if (cmd->autoneg == AUTONEG_ENABLE) {
- bp->flags &= ~(B44_FLAG_FORCE_LINK |
- B44_FLAG_100_BASE_T |
- B44_FLAG_FULL_DUPLEX |
- B44_FLAG_ADV_10HALF |
+ bp->flags &= ~B44_FLAG_FORCE_LINK;
+ bp->flags &= ~(B44_FLAG_ADV_10HALF |
B44_FLAG_ADV_10FULL |
B44_FLAG_ADV_100HALF |
B44_FLAG_ADV_100FULL);
- if (cmd->advertising == 0) {
- bp->flags |= (B44_FLAG_ADV_10HALF |
- B44_FLAG_ADV_10FULL |
- B44_FLAG_ADV_100HALF |
- B44_FLAG_ADV_100FULL);
- } else {
- if (cmd->advertising & ADVERTISED_10baseT_Half)
- bp->flags |= B44_FLAG_ADV_10HALF;
- if (cmd->advertising & ADVERTISED_10baseT_Full)
- bp->flags |= B44_FLAG_ADV_10FULL;
- if (cmd->advertising & ADVERTISED_100baseT_Half)
- bp->flags |= B44_FLAG_ADV_100HALF;
- if (cmd->advertising & ADVERTISED_100baseT_Full)
- bp->flags |= B44_FLAG_ADV_100FULL;
- }
+ if (cmd->advertising & ADVERTISE_10HALF)
+ bp->flags |= B44_FLAG_ADV_10HALF;
+ if (cmd->advertising & ADVERTISE_10FULL)
+ bp->flags |= B44_FLAG_ADV_10FULL;
+ if (cmd->advertising & ADVERTISE_100HALF)
+ bp->flags |= B44_FLAG_ADV_100HALF;
+ if (cmd->advertising & ADVERTISE_100FULL)
+ bp->flags |= B44_FLAG_ADV_100FULL;
} else {
bp->flags |= B44_FLAG_FORCE_LINK;
- bp->flags &= ~(B44_FLAG_100_BASE_T | B44_FLAG_FULL_DUPLEX);
if (cmd->speed == SPEED_100)
bp->flags |= B44_FLAG_100_BASE_T;
if (cmd->duplex == DUPLEX_FULL)
bp->flags |= B44_FLAG_FULL_DUPLEX;
}
- if (netif_running(dev))
- b44_setup_phy(bp);
+ b44_setup_phy(bp);
spin_unlock_irq(&bp->lock);
b44_halt(bp);
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
netif_wake_queue(bp->dev);
spin_unlock_irq(&bp->lock);
if (bp->flags & B44_FLAG_PAUSE_AUTO) {
b44_halt(bp);
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
} else {
__b44_set_flow_ctrl(bp, bp->flags);
}
spin_unlock_irq(&bp->lock);
}
-static void b44_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
-{
- struct b44 *bp = netdev_priv(dev);
-
- wol->supported = WAKE_MAGIC;
- if (bp->flags & B44_FLAG_WOL_ENABLE)
- wol->wolopts = WAKE_MAGIC;
- else
- wol->wolopts = 0;
- memset(&wol->sopass, 0, sizeof(wol->sopass));
-}
-
-static int b44_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
-{
- struct b44 *bp = netdev_priv(dev);
-
- spin_lock_irq(&bp->lock);
- if (wol->wolopts & WAKE_MAGIC)
- bp->flags |= B44_FLAG_WOL_ENABLE;
- else
- bp->flags &= ~B44_FLAG_WOL_ENABLE;
- spin_unlock_irq(&bp->lock);
-
- return 0;
-}
-
static struct ethtool_ops b44_ethtool_ops = {
.get_drvinfo = b44_get_drvinfo,
.get_settings = b44_get_settings,
.set_settings = b44_set_settings,
.nway_reset = b44_nway_reset,
.get_link = ethtool_op_get_link,
- .get_wol = b44_get_wol,
- .set_wol = b44_set_wol,
.get_ringparam = b44_get_ringparam,
.set_ringparam = b44_set_ringparam,
.get_pauseparam = b44_get_pauseparam,
/* XXX - really required?
bp->flags |= B44_FLAG_BUGGY_TXPTR;
*/
-
- if (ssb_get_core_rev(bp) >= 7)
- bp->flags |= B44_FLAG_B0_ANDLATER;
-
out:
return err;
}
err = pci_enable_device(pdev);
if (err) {
- dev_err(&pdev->dev, "Cannot enable PCI device, "
+ printk(KERN_ERR PFX "Cannot enable PCI device, "
"aborting.\n");
return err;
}
if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
- dev_err(&pdev->dev,
- "Cannot find proper PCI device "
+ printk(KERN_ERR PFX "Cannot find proper PCI device "
"base address, aborting.\n");
err = -ENODEV;
goto err_out_disable_pdev;
err = pci_request_regions(pdev, DRV_MODULE_NAME);
if (err) {
- dev_err(&pdev->dev,
- "Cannot obtain PCI resources, aborting.\n");
+ printk(KERN_ERR PFX "Cannot obtain PCI resources, "
+ "aborting.\n");
goto err_out_disable_pdev;
}
err = pci_set_dma_mask(pdev, (u64) B44_DMA_MASK);
if (err) {
- dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n");
+ printk(KERN_ERR PFX "No usable DMA configuration, "
+ "aborting.\n");
goto err_out_free_res;
}
err = pci_set_consistent_dma_mask(pdev, (u64) B44_DMA_MASK);
if (err) {
- dev_err(&pdev->dev, "No usable DMA configuration, aborting.\n");
+ printk(KERN_ERR PFX "No usable DMA configuration, "
+ "aborting.\n");
goto err_out_free_res;
}
dev = alloc_etherdev(sizeof(*bp));
if (!dev) {
- dev_err(&pdev->dev, "Etherdev alloc failed, aborting.\n");
+ printk(KERN_ERR PFX "Etherdev alloc failed, aborting.\n");
err = -ENOMEM;
goto err_out_free_res;
}
bp->regs = ioremap(b44reg_base, b44reg_len);
if (bp->regs == 0UL) {
- dev_err(&pdev->dev, "Cannot map device registers, aborting.\n");
+ printk(KERN_ERR PFX "Cannot map device registers, "
+ "aborting.\n");
err = -ENOMEM;
goto err_out_free_dev;
}
err = b44_get_invariants(bp);
if (err) {
- dev_err(&pdev->dev,
- "Problem fetching invariants of chip, aborting.\n");
+ printk(KERN_ERR PFX "Problem fetching invariants of chip, "
+ "aborting.\n");
goto err_out_iounmap;
}
err = register_netdev(dev);
if (err) {
- dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
+ printk(KERN_ERR PFX "Cannot register net device, "
+ "aborting.\n");
goto err_out_iounmap;
}
spin_unlock_irq(&bp->lock);
free_irq(dev->irq, dev);
- if (bp->flags & B44_FLAG_WOL_ENABLE) {
- b44_init_hw(bp, 0);
- b44_setup_wol(bp);
- }
pci_disable_device(pdev);
return 0;
}
if (!netif_running(dev))
return 0;
- if (request_irq(dev->irq, b44_interrupt, IRQF_SHARED, dev->name, dev))
+ if (request_irq(dev->irq, b44_interrupt, SA_SHIRQ, dev->name, dev))
printk(KERN_ERR PFX "%s: request_irq failed\n", dev->name);
spin_lock_irq(&bp->lock);
b44_init_rings(bp);
- b44_init_hw(bp, 1);
+ b44_init_hw(bp);
netif_device_attach(bp->dev);
spin_unlock_irq(&bp->lock);