diff -urN linux-2.5.7/drivers/net/3c501.c linux/drivers/net/3c501.c
--- linux-2.5.7/drivers/net/3c501.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/3c501.c Thu Mar 21 14:52:58 2002
@@ -419,7 +419,8 @@
if (el_debug > 2)
printk("%s: Doing el_open()...", dev->name);
- if ((retval = request_irq(dev->irq, &el_interrupt, 0, dev->name, dev)))
+ if ((retval = request_irq(dev->irq, &el_interrupt,
+ SA_NET_RANDOM, dev->name, dev)))
return retval;
spin_lock_irqsave(&lp->lock, flags);
diff -urN linux-2.5.7/drivers/net/3c503.c linux/drivers/net/3c503.c
--- linux-2.5.7/drivers/net/3c503.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/3c503.c Thu Mar 21 14:52:58 2002
@@ -348,7 +348,7 @@
outb_p(0x00, E33G_IDCFR);
if (*irqp == probe_irq_off(cookie) /* It's a good IRQ line! */
&& ((retval = request_irq(dev->irq = *irqp,
- ei_interrupt, 0, dev->name, dev)) == 0))
+ ei_interrupt, SA_NET_RANDOM, dev->name, dev)) == 0))
break;
}
} while (*++irqp);
@@ -357,7 +357,7 @@
return retval;
}
} else {
- if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM, dev->name, dev))) {
return retval;
}
}
diff -urN linux-2.5.7/drivers/net/3c505.c linux/drivers/net/3c505.c
--- linux-2.5.7/drivers/net/3c505.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/3c505.c Thu Mar 21 14:52:58 2002
@@ -906,7 +906,8 @@
/*
* install our interrupt service routine
*/
- if ((retval = request_irq(dev->irq, &elp_interrupt, 0, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, &elp_interrupt,
+ SA_NET_RANDOM, dev->name, dev))) {
printk(KERN_ERR "%s: could not allocate IRQ%d\n", dev->name, dev->irq);
return retval;
}
diff -urN linux-2.5.7/drivers/net/3c507.c linux/drivers/net/3c507.c
--- linux-2.5.7/drivers/net/3c507.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/3c507.c Thu Mar 21 14:52:58 2002
@@ -373,7 +373,8 @@
irq = inb(ioaddr + IRQ_CONFIG) & 0x0f;
- irqval = request_irq(irq, &el16_interrupt, 0, dev->name, dev);
+ irqval = request_irq(irq, &el16_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (irqval) {
printk ("unable to get IRQ %d (irqval=%d).\n", irq, irqval);
retval = -EAGAIN;
diff -urN linux-2.5.7/drivers/net/3c509.c linux/drivers/net/3c509.c
--- linux-2.5.7/drivers/net/3c509.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/3c509.c Thu Mar 21 14:52:58 2002
@@ -573,7 +573,8 @@
outw(RxReset, ioaddr + EL3_CMD);
outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
- i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
+ i = request_irq(dev->irq, &el3_interrupt,
+ SA_NET_RANDOM, dev->name, dev);
if (i) return i;
EL3WINDOW(0);
diff -urN linux-2.5.7/drivers/net/3c515.c linux/drivers/net/3c515.c
--- linux-2.5.7/drivers/net/3c515.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/3c515.c Thu Mar 21 14:52:58 2002
@@ -803,11 +803,13 @@
/* Corkscrew: Cannot share ISA resources. */
if (dev->irq == 0
|| dev->dma == 0
- || request_irq(dev->irq, &corkscrew_interrupt, 0,
- vp->product_name, dev)) return -EAGAIN;
+ || request_irq(dev->irq, &corkscrew_interrupt,
+ SA_NET_RANDOM,
+ vp->product_name, dev)) return -EAGAIN;
enable_dma(dev->dma);
set_dma_mode(dev->dma, DMA_MODE_CASCADE);
- } else if (request_irq(dev->irq, &corkscrew_interrupt, SA_SHIRQ,
+ } else if (request_irq(dev->irq, &corkscrew_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM,
vp->product_name, dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/3c523.c linux/drivers/net/3c523.c
--- linux-2.5.7/drivers/net/3c523.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/3c523.c Thu Mar 21 14:52:58 2002
@@ -289,8 +289,8 @@
elmc_id_attn586(); /* disable interrupts */
- ret = request_irq(dev->irq, &elmc_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM,
- dev->name, dev);
+ ret = request_irq(dev->irq, &elmc_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret) {
printk(KERN_ERR "%s: couldn't get irq %d\n", dev->name, dev->irq);
elmc_id_reset586();
diff -urN linux-2.5.7/drivers/net/3c527.c linux/drivers/net/3c527.c
--- linux-2.5.7/drivers/net/3c527.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/3c527.c Thu Mar 21 14:52:58 2002
@@ -409,7 +409,7 @@
* Grab the IRQ
*/
- i = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &mc32_interrupt, SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) {
release_region(dev->base_addr, MC32_IO_EXTENT);
printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
diff -urN linux-2.5.7/drivers/net/3c59x.c linux/drivers/net/3c59x.c
--- linux-2.5.7/drivers/net/3c59x.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/3c59x.c Thu Mar 21 14:52:58 2002
@@ -1578,7 +1578,8 @@
/* Use the now-standard shared IRQ implementation. */
if ((retval = request_irq(dev->irq, vp->full_bus_master_rx ?
- &boomerang_interrupt : &vortex_interrupt, SA_SHIRQ, dev->name, dev))) {
+ &boomerang_interrupt : &vortex_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev))) {
printk(KERN_ERR "%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
goto out;
}
diff -urN linux-2.5.7/drivers/net/7990.c linux/drivers/net/7990.c
--- linux-2.5.7/drivers/net/7990.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/7990.c Thu Mar 21 14:52:58 2002
@@ -464,7 +464,7 @@
DECLARE_LL;
/* Install the Interrupt handler. Or we could shunt this out to specific drivers? */
- if (request_irq(lp->irq, lance_interrupt, 0, lp->name, dev))
+ if (request_irq(lp->irq, lance_interrupt, SA_NET_RANDOM, lp->name, dev))
return -EAGAIN;
res = lance_reset(dev);
diff -urN linux-2.5.7/drivers/net/8139cp.c linux/drivers/net/8139cp.c
--- linux-2.5.7/drivers/net/8139cp.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/8139cp.c Thu Mar 21 14:52:58 2002
@@ -1043,7 +1043,8 @@
cp_init_hw(cp);
- rc = request_irq(dev->irq, cp_interrupt, SA_SHIRQ, dev->name, dev);
+ rc = request_irq(dev->irq, cp_interrupt,
+ SA_NET_RANDOM | SA_SHIRQ, dev->name, dev);
if (rc)
goto err_out_hw;
diff -urN linux-2.5.7/drivers/net/8139too.c linux/drivers/net/8139too.c
--- linux-2.5.7/drivers/net/8139too.c Mon Mar 18 15:37:01 2002
+++ linux/drivers/net/8139too.c Thu Mar 21 14:52:58 2002
@@ -1258,7 +1258,8 @@
void *ioaddr = tp->mmio_addr;
#endif
- retval = request_irq (dev->irq, rtl8139_interrupt, SA_SHIRQ, dev->name, dev);
+ retval = request_irq (dev->irq, rtl8139_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (retval)
return retval;
diff -urN linux-2.5.7/drivers/net/82596.c linux/drivers/net/82596.c
--- linux-2.5.7/drivers/net/82596.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/82596.c Thu Mar 21 14:52:58 2002
@@ -973,7 +973,8 @@
DEB(DEB_OPEN,printk("%s: i596_open() irq %d.\n", dev->name, dev->irq));
- if (request_irq(dev->irq, &i596_interrupt, 0, "i82596", dev)) {
+ if (request_irq(dev->irq, &i596_interrupt, SA_NET_RANDOM,
+ "i82596", dev)) {
printk("%s: IRQ %d not free\n", dev->name, dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/\ linux/drivers/net/\
--- linux-2.5.7/drivers/net/\ Wed Dec 31 19:00:00 1969
+++ linux/drivers/net/\ Thu Mar 21 14:52:58 2002
@@ -0,0 +1,2241 @@
+/* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
+/*
+ Copyright 2001 Jeff Garzik <jgarzik@mandrakesoft.com>
+
+ Copyright 1994, 1995 Digital Equipment Corporation. [de4x5.c]
+ Written/copyright 1994-2001 by Donald Becker. [tulip.c]
+
+ This software may be used and distributed according to the terms of
+ the GNU General Public License (GPL), incorporated herein by reference.
+ Drivers based on or derived from this code fall under the GPL and must
+ retain the authorship, copyright and license notice. This file is not
+ a complete program and may only be used when the entire operating
+ system is licensed under the GPL.
+
+ See the file COPYING in this distribution for more information.
+
+ TODO, in rough priority order:
+ * Support forcing media type with a module parameter,
+ like dl2k.c/sundance.c
+ * Constants (module parms?) for Rx work limit
+ * Complete reset on PciErr
+ * Jumbo frames / dev->change_mtu
+ * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
+ * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
+ * Implement Tx software interrupt mitigation via
+ Tx descriptor bit
+
+ */
+
+#define DRV_NAME "de2104x"
+#define DRV_VERSION "0.5.4"
+#define DRV_RELDATE "Jan 1, 2002"
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/ethtool.h>
+#include <linux/compiler.h>
+#include <linux/sched.h>
+#include <linux/rtnetlink.h>
+#include <linux/crc32.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include <asm/unaligned.h>
+
+/* These identify the driver base version and may not be removed. */
+static char version[] __initdata =
+KERN_INFO DRV_NAME " PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
+
+MODULE_AUTHOR("Jeff Garzik <jgarzik@mandrakesoft.com>");
+MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
+MODULE_LICENSE("GPL");
+
+static int debug = -1;
+MODULE_PARM (debug, "i");
+MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
+
+/* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
+#if defined(__alpha__) || defined(__arm__) || defined(__hppa__) \
+ || defined(__sparc_) || defined(__ia64__) \
+ || defined(__sh__) || defined(__mips__)
+static int rx_copybreak = 1518;
+#else
+static int rx_copybreak = 100;
+#endif
+MODULE_PARM (rx_copybreak, "i");
+MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
+
+#define PFX DRV_NAME ": "
+
+#define DE_DEF_MSG_ENABLE (NETIF_MSG_DRV | \
+ NETIF_MSG_PROBE | \
+ NETIF_MSG_LINK | \
+ NETIF_MSG_TIMER | \
+ NETIF_MSG_IFDOWN | \
+ NETIF_MSG_IFUP | \
+ NETIF_MSG_RX_ERR | \
+ NETIF_MSG_TX_ERR)
+
+#define DE_RX_RING_SIZE 64
+#define DE_TX_RING_SIZE 64
+#define DE_RING_BYTES \
+ ((sizeof(struct de_desc) * DE_RX_RING_SIZE) + \
+ (sizeof(struct de_desc) * DE_TX_RING_SIZE))
+#define NEXT_TX(N) (((N) + 1) & (DE_TX_RING_SIZE - 1))
+#define NEXT_RX(N) (((N) + 1) & (DE_RX_RING_SIZE - 1))
+#define TX_BUFFS_AVAIL(CP) \
+ (((CP)->tx_tail <= (CP)->tx_head) ? \
+ (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head : \
+ (CP)->tx_tail - (CP)->tx_head - 1)
+
+#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
+#define RX_OFFSET 2
+
+#define DE_SETUP_SKB ((struct sk_buff *) 1)
+#define DE_DUMMY_SKB ((struct sk_buff *) 2)
+#define DE_SETUP_FRAME_WORDS 96
+#define DE_EEPROM_WORDS 256
+#define DE_EEPROM_SIZE (DE_EEPROM_WORDS * sizeof(u16))
+#define DE_MAX_MEDIA 5
+
+#define DE_MEDIA_TP_AUTO 0
+#define DE_MEDIA_BNC 1
+#define DE_MEDIA_AUI 2
+#define DE_MEDIA_TP 3
+#define DE_MEDIA_TP_FD 4
+#define DE_MEDIA_INVALID DE_MAX_MEDIA
+#define DE_MEDIA_FIRST 0
+#define DE_MEDIA_LAST (DE_MAX_MEDIA - 1)
+#define DE_AUI_BNC (SUPPORTED_AUI | SUPPORTED_BNC)
+
+#define DE_TIMER_LINK (60 * HZ)
+#define DE_TIMER_NO_LINK (5 * HZ)
+
+#define DE_NUM_REGS 16
+#define DE_REGS_SIZE (DE_NUM_REGS * sizeof(u32))
+#define DE_REGS_VER 1
+
+/* Time in jiffies before concluding the transmitter is hung. */
+#define TX_TIMEOUT (6*HZ)
+
+#define DE_UNALIGNED_16(a) (u16)(get_unaligned((u16 *)(a)))
+
+/* This is a mysterious value that can be written to CSR11 in the 21040 (only)
+ to support a pre-NWay full-duplex signaling mechanism using short frames.
+ No one knows what it should be, but if left at its default value some
+ 10base2(!) packets trigger a full-duplex-request interrupt. */
+#define FULL_DUPLEX_MAGIC 0x6969
+
+enum {
+ /* NIC registers */
+ BusMode = 0x00,
+ TxPoll = 0x08,
+ RxPoll = 0x10,
+ RxRingAddr = 0x18,
+ TxRingAddr = 0x20,
+ MacStatus = 0x28,
+ MacMode = 0x30,
+ IntrMask = 0x38,
+ RxMissed = 0x40,
+ ROMCmd = 0x48,
+ CSR11 = 0x58,
+ SIAStatus = 0x60,
+ CSR13 = 0x68,
+ CSR14 = 0x70,
+ CSR15 = 0x78,
+ PCIPM = 0x40,
+
+ /* BusMode bits */
+ CmdReset = (1 << 0),
+ CacheAlign16 = 0x00008000,
+ BurstLen4 = 0x00000400,
+
+ /* Rx/TxPoll bits */
+ NormalTxPoll = (1 << 0),
+ NormalRxPoll = (1 << 0),
+
+ /* Tx/Rx descriptor status bits */
+ DescOwn = (1 << 31),
+ RxError = (1 << 15),
+ RxErrLong = (1 << 7),
+ RxErrCRC = (1 << 1),
+ RxErrFIFO = (1 << 0),
+ RxErrRunt = (1 << 11),
+ RxErrFrame = (1 << 14),
+ RingEnd = (1 << 25),
+ FirstFrag = (1 << 29),
+ LastFrag = (1 << 30),
+ TxError = (1 << 15),
+ TxFIFOUnder = (1 << 1),
+ TxLinkFail = (1 << 2) | (1 << 10) | (1 << 11),
+ TxMaxCol = (1 << 8),
+ TxOWC = (1 << 9),
+ TxJabber = (1 << 14),
+ SetupFrame = (1 << 27),
+ TxSwInt = (1 << 31),
+
+ /* MacStatus bits */
+ IntrOK = (1 << 16),
+ IntrErr = (1 << 15),
+ RxIntr = (1 << 6),
+ RxEmpty = (1 << 7),
+ TxIntr = (1 << 0),
+ TxEmpty = (1 << 2),
+ PciErr = (1 << 13),
+ TxState = (1 << 22) | (1 << 21) | (1 << 20),
+ RxState = (1 << 19) | (1 << 18) | (1 << 17),
+ LinkFail = (1 << 12),
+ LinkPass = (1 << 4),
+ RxStopped = (1 << 8),
+ TxStopped = (1 << 1),
+
+ /* MacMode bits */
+ TxEnable = (1 << 13),
+ RxEnable = (1 << 1),
+ RxTx = TxEnable | RxEnable,
+ FullDuplex = (1 << 9),
+ AcceptAllMulticast = (1 << 7),
+ AcceptAllPhys = (1 << 6),
+ BOCnt = (1 << 5),
+ MacModeClear = (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
+ RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
+
+ /* ROMCmd bits */
+ EE_SHIFT_CLK = 0x02, /* EEPROM shift clock. */
+ EE_CS = 0x01, /* EEPROM chip select. */
+ EE_DATA_WRITE = 0x04, /* Data from the Tulip to EEPROM. */
+ EE_WRITE_0 = 0x01,
+ EE_WRITE_1 = 0x05,
+ EE_DATA_READ = 0x08, /* Data from the EEPROM chip. */
+ EE_ENB = (0x4800 | EE_CS),
+
+ /* The EEPROM commands include the alway-set leading bit. */
+ EE_READ_CMD = 6,
+
+ /* RxMissed bits */
+ RxMissedOver = (1 << 16),
+ RxMissedMask = 0xffff,
+
+ /* SROM-related bits */
+ SROMC0InfoLeaf = 27,
+ MediaBlockMask = 0x3f,
+ MediaCustomCSRs = (1 << 6),
+
+ /* PCIPM bits */
+ PM_Sleep = (1 << 31),
+ PM_Snooze = (1 << 30),
+ PM_Mask = PM_Sleep | PM_Snooze,
+
+ /* SIAStatus bits */
+ NWayState = (1 << 14) | (1 << 13) | (1 << 12),
+ NWayRestart = (1 << 12),
+ NonselPortActive = (1 << 9),
+ LinkFailStatus = (1 << 2),
+ NetCxnErr = (1 << 1),
+};
+
+static const u32 de_intr_mask =
+ IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
+ LinkPass | LinkFail | PciErr;
+
+/*
+ * Set the programmable burst length to 4 longwords for all:
+ * DMA errors result without these values. Cache align 16 long.
+ */
+static const u32 de_bus_mode = CacheAlign16 | BurstLen4;
+
+struct de_srom_media_block {
+ u8 opts;
+ u16 csr13;
+ u16 csr14;
+ u16 csr15;
+} __attribute__((packed));
+
+struct de_srom_info_leaf {
+ u16 default_media;
+ u8 n_blocks;
+ u8 unused;
+} __attribute__((packed));
+
+struct de_desc {
+ u32 opts1;
+ u32 opts2;
+ u32 addr1;
+ u32 addr2;
+};
+
+struct media_info {
+ u16 type; /* DE_MEDIA_xxx */
+ u16 csr13;
+ u16 csr14;
+ u16 csr15;
+};
+
+struct ring_info {
+ struct sk_buff *skb;
+ dma_addr_t mapping;
+};
+
+struct de_private {
+ unsigned tx_head;
+ unsigned tx_tail;
+ unsigned rx_tail;
+
+ void *regs;
+ struct net_device *dev;
+ spinlock_t lock;
+
+ struct de_desc *rx_ring;
+ struct de_desc *tx_ring;
+ struct ring_info tx_skb[DE_TX_RING_SIZE];
+ struct ring_info rx_skb[DE_RX_RING_SIZE];
+ unsigned rx_buf_sz;
+ dma_addr_t ring_dma;
+
+ u32 msg_enable;
+
+ struct net_device_stats net_stats;
+
+ struct pci_dev *pdev;
+ u32 macmode;
+
+ u16 setup_frame[DE_SETUP_FRAME_WORDS];
+
+ u32 media_type;
+ u32 media_supported;
+ u32 media_advertise;
+ struct media_info media[DE_MAX_MEDIA];
+ struct timer_list media_timer;
+
+ u8 *ee_data;
+ unsigned board_idx;
+ unsigned de21040 : 1;
+ unsigned media_lock : 1;
+};
+
+
+static void de_set_rx_mode (struct net_device *dev);
+static void de_tx (struct de_private *de);
+static void de_clean_rings (struct de_private *de);
+static void de_media_interrupt (struct de_private *de, u32 status);
+static void de21040_media_timer (unsigned long data);
+static void de21041_media_timer (unsigned long data);
+static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
+
+
+static struct pci_device_id de_pci_tbl[] __initdata = {
+ { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+ { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
+ { },
+};
+MODULE_DEVICE_TABLE(pci, de_pci_tbl);
+
+static const char * const media_name[DE_MAX_MEDIA] = {
+ "10baseT auto",
+ "BNC",
+ "AUI",
+ "10baseT-HD",
+ "10baseT-FD"
+};
+
+/* 21040 transceiver register settings:
+ * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
+static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
+static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
+static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
+
+/* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
+static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
+static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x6F3F, 0x6F3D, };
+static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
+
+
+static inline unsigned long
+msec_to_jiffies(unsigned long ms)
+{
+ return (((ms)*HZ+999)/1000);
+}
+
+
+#define dr32(reg) readl(de->regs + (reg))
+#define dw32(reg,val) writel((val), de->regs + (reg))
+
+
+static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
+ u32 status, u32 len)
+{
+ if (netif_msg_rx_err (de))
+ printk (KERN_DEBUG
+ "%s: rx err, slot %d status 0x%x len %d\n",
+ de->dev->name, rx_tail, status, len);
+
+ if ((status & 0x38000300) != 0x0300) {
+ /* Ingore earlier buffers. */
+ if ((status & 0xffff) != 0x7fff) {
+ if (netif_msg_rx_err(de))
+ printk(KERN_WARNING "%s: Oversized Ethernet frame "
+ "spanned multiple buffers, status %8.8x!\n",
+ de->dev->name, status);
+ de->net_stats.rx_length_errors++;
+ }
+ } else if (status & RxError) {
+ /* There was a fatal error. */
+ de->net_stats.rx_errors++; /* end of a packet.*/
+ if (status & 0x0890) de->net_stats.rx_length_errors++;
+ if (status & RxErrCRC) de->net_stats.rx_crc_errors++;
+ if (status & RxErrFIFO) de->net_stats.rx_fifo_errors++;
+ }
+}
+
+static void de_rx (struct de_private *de)
+{
+ unsigned rx_tail = de->rx_tail;
+ unsigned rx_work = DE_RX_RING_SIZE;
+ unsigned drop = 0;
+ int rc;
+
+ while (rx_work--) {
+ u32 status, len;
+ dma_addr_t mapping;
+ struct sk_buff *skb, *copy_skb;
+ unsigned copying_skb, buflen;
+
+ skb = de->rx_skb[rx_tail].skb;
+ if (!skb)
+ BUG();
+ rmb();
+ status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
+ if (status & DescOwn)
+ break;
+
+ len = ((status >> 16) & 0x7ff) - 4;
+ mapping = de->rx_skb[rx_tail].mapping;
+
+ if (unlikely(drop)) {
+ de->net_stats.rx_dropped++;
+ goto rx_next;
+ }
+
+ if (unlikely((status & 0x38008300) != 0x0300)) {
+ de_rx_err_acct(de, rx_tail, status, len);
+ goto rx_next;
+ }
+
+ copying_skb = (len <= rx_copybreak);
+
+ if (unlikely(netif_msg_rx_status(de)))
+ printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d copying? %d\n",
+ de->dev->name, rx_tail, status, len,
+ copying_skb);
+
+ buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
+ copy_skb = dev_alloc_skb (buflen);
+ if (unlikely(!copy_skb)) {
+ de->net_stats.rx_dropped++;
+ drop = 1;
+ rx_work = 100;
+ goto rx_next;
+ }
+ copy_skb->dev = de->dev;
+
+ if (!copying_skb) {
+ pci_unmap_single(de->pdev, mapping,
+ buflen, PCI_DMA_FROMDEVICE);
+ skb_put(skb, len);
+
+ mapping =
+ de->rx_skb[rx_tail].mapping =
+ pci_map_single(de->pdev, copy_skb->tail,
+ buflen, PCI_DMA_FROMDEVICE);
+ de->rx_skb[rx_tail].skb = copy_skb;
+ } else {
+ pci_dma_sync_single(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
+ skb_reserve(copy_skb, RX_OFFSET);
+ memcpy(skb_put(copy_skb, len), skb->tail, len);
+
+ /* We'll reuse the original ring buffer. */
+ skb = copy_skb;
+ }
+
+ skb->protocol = eth_type_trans (skb, de->dev);
+
+ de->net_stats.rx_packets++;
+ de->net_stats.rx_bytes += skb->len;
+ de->dev->last_rx = jiffies;
+ rc = netif_rx (skb);
+ if (rc == NET_RX_DROP)
+ drop = 1;
+
+rx_next:
+ de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
+ if (rx_tail == (DE_RX_RING_SIZE - 1))
+ de->rx_ring[rx_tail].opts2 =
+ cpu_to_le32(RingEnd | de->rx_buf_sz);
+ else
+ de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
+ de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
+ rx_tail = NEXT_RX(rx_tail);
+ }
+
+ if (!rx_work)
+ printk(KERN_WARNING "%s: rx work limit reached\n", de->dev->name);
+
+ de->rx_tail = rx_tail;
+}
+
+static void de_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
+{
+ struct net_device *dev = dev_instance;
+ struct de_private *de = dev->priv;
+ u32 status;
+
+ status = dr32(MacStatus);
+ if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
+ return;
+
+ if (netif_msg_intr(de))
+ printk(KERN_DEBUG "%s: intr, status %08x mode %08x desc %u/%u/%u\n",
+ dev->name, status, dr32(MacMode), de->rx_tail, de->tx_head, de->tx_tail);
+
+ dw32(MacStatus, status);
+
+ if (status & (RxIntr | RxEmpty)) {
+ de_rx(de);
+ if (status & RxEmpty)
+ dw32(RxPoll, NormalRxPoll);
+ }
+
+ spin_lock(&de->lock);
+
+ if (status & (TxIntr | TxEmpty))
+ de_tx(de);
+
+ if (status & (LinkPass | LinkFail))
+ de_media_interrupt(de, status);
+
+ spin_unlock(&de->lock);
+
+ if (status & PciErr) {
+ u16 pci_status;
+
+ pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
+ pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
+ printk(KERN_ERR "%s: PCI bus error, status=%08x, PCI status=%04x\n",
+ dev->name, status, pci_status);
+ }
+}
+
+static void de_tx (struct de_private *de)
+{
+ unsigned tx_head = de->tx_head;
+ unsigned tx_tail = de->tx_tail;
+
+ while (tx_tail != tx_head) {
+ struct sk_buff *skb;
+ u32 status;
+
+ rmb();
+ status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
+ if (status & DescOwn)
+ break;
+
+ skb = de->tx_skb[tx_tail].skb;
+ if (!skb)
+ BUG();
+ if (unlikely(skb == DE_DUMMY_SKB))
+ goto next;
+
+ if (unlikely(skb == DE_SETUP_SKB)) {
+ pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
+ sizeof(de->setup_frame), PCI_DMA_TODEVICE);
+ goto next;
+ }
+
+ pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
+ skb->len, PCI_DMA_TODEVICE);
+
+ if (status & LastFrag) {
+ if (status & TxError) {
+ if (netif_msg_tx_err(de))
+ printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
+ de->dev->name, status);
+ de->net_stats.tx_errors++;
+ if (status & TxOWC)
+ de->net_stats.tx_window_errors++;
+ if (status & TxMaxCol)
+ de->net_stats.tx_aborted_errors++;
+ if (status & TxLinkFail)
+ de->net_stats.tx_carrier_errors++;
+ if (status & TxFIFOUnder)
+ de->net_stats.tx_fifo_errors++;
+ } else {
+ de->net_stats.tx_packets++;
+ de->net_stats.tx_bytes += skb->len;
+ if (netif_msg_tx_done(de))
+ printk(KERN_DEBUG "%s: tx done, slot %d\n", de->dev->name, tx_tail);
+ }
+ dev_kfree_skb_irq(skb);
+ }
+
+next:
+ de->tx_skb[tx_tail].skb = NULL;
+
+ tx_tail = NEXT_TX(tx_tail);
+ }
+
+ de->tx_tail = tx_tail;
+
+ if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
+ netif_wake_queue(de->dev);
+}
+
+static int de_start_xmit (struct sk_buff *skb, struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ unsigned int entry, tx_free;
+ u32 mapping, len, flags = FirstFrag | LastFrag;
+ struct de_desc *txd;
+
+ spin_lock_irq(&de->lock);
+
+ tx_free = TX_BUFFS_AVAIL(de);
+ if (tx_free == 0) {
+ netif_stop_queue(dev);
+ spin_unlock_irq(&de->lock);
+ return 1;
+ }
+ tx_free--;
+
+ entry = de->tx_head;
+
+ txd = &de->tx_ring[entry];
+
+ len = skb->len;
+ mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
+ if (entry == (DE_TX_RING_SIZE - 1))
+ flags |= RingEnd;
+ if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
+ flags |= TxSwInt;
+ flags |= len;
+ txd->opts2 = cpu_to_le32(flags);
+ txd->addr1 = cpu_to_le32(mapping);
+
+ de->tx_skb[entry].skb = skb;
+ de->tx_skb[entry].mapping = mapping;
+ wmb();
+
+ txd->opts1 = cpu_to_le32(DescOwn);
+ wmb();
+
+ de->tx_head = NEXT_TX(entry);
+ if (netif_msg_tx_queued(de))
+ printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
+ dev->name, entry, skb->len);
+
+ if (tx_free == 0)
+ netif_stop_queue(dev);
+
+ spin_unlock_irq(&de->lock);
+
+ /* Trigger an immediate transmit demand. */
+ dw32(TxPoll, NormalTxPoll);
+ dev->trans_start = jiffies;
+
+ return 0;
+}
+
+/* Set or clear the multicast filter for this adaptor.
+ Note that we only use exclusion around actually queueing the
+ new frame, not around filling de->setup_frame. This is non-deterministic
+ when re-entered but still correct. */
+
+#undef set_bit_le
+#define set_bit_le(i,p) do { ((char *)(p))[(i)/8] |= (1<<((i)%8)); } while(0)
+
+static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ u16 hash_table[32];
+ struct dev_mc_list *mclist;
+ int i;
+ u16 *eaddrs;
+
+ memset(hash_table, 0, sizeof(hash_table));
+ set_bit_le(255, hash_table); /* Broadcast entry */
+ /* This should work on big-endian machines as well. */
+ for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
+ i++, mclist = mclist->next) {
+ int index = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
+
+ set_bit_le(index, hash_table);
+
+ for (i = 0; i < 32; i++) {
+ *setup_frm++ = hash_table[i];
+ *setup_frm++ = hash_table[i];
+ }
+ setup_frm = &de->setup_frame[13*6];
+ }
+
+ /* Fill the final entry with our physical address. */
+ eaddrs = (u16 *)dev->dev_addr;
+ *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
+ *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
+ *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
+}
+
+static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ struct dev_mc_list *mclist;
+ int i;
+ u16 *eaddrs;
+
+ /* We have <= 14 addresses so we can use the wonderful
+ 16 address perfect filtering of the Tulip. */
+ for (i = 0, mclist = dev->mc_list; i < dev->mc_count;
+ i++, mclist = mclist->next) {
+ eaddrs = (u16 *)mclist->dmi_addr;
+ *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
+ *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
+ *setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
+ }
+ /* Fill the unused entries with the broadcast address. */
+ memset(setup_frm, 0xff, (15-i)*12);
+ setup_frm = &de->setup_frame[15*6];
+
+ /* Fill the final entry with our physical address. */
+ eaddrs = (u16 *)dev->dev_addr;
+ *setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
+ *setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
+ *setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
+}
+
+
+static void __de_set_rx_mode (struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ u32 macmode;
+ unsigned int entry;
+ u32 mapping;
+ struct de_desc *txd;
+ struct de_desc *dummy_txd = NULL;
+
+ macmode = de->macmode & ~(AcceptAllMulticast | AcceptAllPhys);
+
+ if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
+ macmode |= AcceptAllMulticast | AcceptAllPhys;
+ goto out;
+ }
+
+ if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
+ /* Too many to filter well -- accept all multicasts. */
+ macmode |= AcceptAllMulticast;
+ goto out;
+ }
+
+ /* Note that only the low-address shortword of setup_frame is valid!
+ The values are doubled for big-endian architectures. */
+ if (dev->mc_count > 14) /* Must use a multicast hash table. */
+ build_setup_frame_hash (de->setup_frame, dev);
+ else
+ build_setup_frame_perfect (de->setup_frame, dev);
+
+ /*
+ * Now add this frame to the Tx list.
+ */
+
+ entry = de->tx_head;
+
+ /* Avoid a chip errata by prefixing a dummy entry. */
+ if (entry != 0) {
+ de->tx_skb[entry].skb = DE_DUMMY_SKB;
+
+ dummy_txd = &de->tx_ring[entry];
+ dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
+ cpu_to_le32(RingEnd) : 0;
+ dummy_txd->addr1 = 0;
+
+ /* Must set DescOwned later to avoid race with chip */
+
+ entry = NEXT_TX(entry);
+ }
+
+ de->tx_skb[entry].skb = DE_SETUP_SKB;
+ de->tx_skb[entry].mapping = mapping =
+ pci_map_single (de->pdev, de->setup_frame,
+ sizeof (de->setup_frame), PCI_DMA_TODEVICE);
+
+ /* Put the setup frame on the Tx list. */
+ txd = &de->tx_ring[entry];
+ if (entry == (DE_TX_RING_SIZE - 1))
+ txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
+ else
+ txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
+ txd->addr1 = cpu_to_le32(mapping);
+ wmb();
+
+ txd->opts1 = cpu_to_le32(DescOwn);
+ wmb();
+
+ if (dummy_txd) {
+ dummy_txd->opts1 = cpu_to_le32(DescOwn);
+ wmb();
+ }
+
+ de->tx_head = NEXT_TX(entry);
+
+ if (TX_BUFFS_AVAIL(de) < 0)
+ BUG();
+ if (TX_BUFFS_AVAIL(de) == 0)
+ netif_stop_queue(dev);
+
+ /* Trigger an immediate transmit demand. */
+ dw32(TxPoll, NormalTxPoll);
+
+out:
+ if (macmode != de->macmode) {
+ dw32 (MacMode, macmode);
+ de->macmode = macmode;
+ }
+}
+
+static void de_set_rx_mode (struct net_device *dev)
+{
+ unsigned long flags;
+ struct de_private *de = dev->priv;
+
+ spin_lock_irqsave (&de->lock, flags);
+ __de_set_rx_mode(dev);
+ spin_unlock_irqrestore (&de->lock, flags);
+}
+
+static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
+{
+ if (unlikely(rx_missed & RxMissedOver))
+ de->net_stats.rx_missed_errors += RxMissedMask;
+ else
+ de->net_stats.rx_missed_errors += (rx_missed & RxMissedMask);
+}
+
+static void __de_get_stats(struct de_private *de)
+{
+ u32 tmp = dr32(RxMissed); /* self-clearing */
+
+ de_rx_missed(de, tmp);
+}
+
+static struct net_device_stats *de_get_stats(struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+
+ /* The chip only need report frame silently dropped. */
+ spin_lock_irq(&de->lock);
+ if (netif_running(dev) && netif_device_present(dev))
+ __de_get_stats(de);
+ spin_unlock_irq(&de->lock);
+
+ return &de->net_stats;
+}
+
+static inline int de_is_running (struct de_private *de)
+{
+ return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
+}
+
+static void de_stop_rxtx (struct de_private *de)
+{
+ u32 macmode;
+ unsigned int work = 1000;
+
+ macmode = dr32(MacMode);
+ if (macmode & RxTx) {
+ dw32(MacMode, macmode & ~RxTx);
+ dr32(MacMode);
+ }
+
+ while (--work > 0) {
+ if (!de_is_running(de))
+ return;
+ cpu_relax();
+ }
+
+ printk(KERN_WARNING "%s: timeout expired stopping DMA\n", de->dev->name);
+}
+
+static inline void de_start_rxtx (struct de_private *de)
+{
+ u32 macmode;
+
+ macmode = dr32(MacMode);
+ if ((macmode & RxTx) != RxTx) {
+ dw32(MacMode, macmode | RxTx);
+ dr32(MacMode);
+ }
+}
+
+static void de_stop_hw (struct de_private *de)
+{
+
+ udelay(5);
+ dw32(IntrMask, 0);
+
+ de_stop_rxtx(de);
+
+ dw32(MacStatus, dr32(MacStatus));
+
+ udelay(10);
+
+ de->rx_tail = 0;
+ de->tx_head = de->tx_tail = 0;
+}
+
+static void de_link_up(struct de_private *de)
+{
+ if (!netif_carrier_ok(de->dev)) {
+ netif_carrier_on(de->dev);
+ if (netif_msg_link(de))
+ printk(KERN_INFO "%s: link up, media %s\n",
+ de->dev->name, media_name[de->media_type]);
+ }
+}
+
+static void de_link_down(struct de_private *de)
+{
+ if (netif_carrier_ok(de->dev)) {
+ netif_carrier_off(de->dev);
+ if (netif_msg_link(de))
+ printk(KERN_INFO "%s: link down\n", de->dev->name);
+ }
+}
+
+static void de_set_media (struct de_private *de)
+{
+ unsigned media = de->media_type;
+
+ if (de_is_running(de))
+ BUG();
+
+ if (de->de21040)
+ dw32(CSR11, FULL_DUPLEX_MAGIC);
+ dw32(CSR13, 0); /* Reset phy */
+ dw32(CSR14, de->media[media].csr14);
+ dw32(CSR15, de->media[media].csr15);
+ dw32(CSR13, de->media[media].csr13);
+
+ /* must delay 10ms before writing to other registers,
+ * especially CSR6
+ */
+ mdelay(10);
+
+ if (media == DE_MEDIA_TP_FD)
+ de->macmode |= FullDuplex;
+ else
+ de->macmode &= ~FullDuplex;
+
+ if (netif_msg_link(de)) {
+ printk(KERN_INFO "%s: set link %s\n"
+ KERN_INFO "%s: mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n"
+ KERN_INFO "%s: set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
+ de->dev->name, media_name[media],
+ de->dev->name, dr32(MacMode), dr32(SIAStatus),
+ dr32(CSR13), dr32(CSR14), dr32(CSR15),
+ de->dev->name, de->macmode, de->media[media].csr13,
+ de->media[media].csr14, de->media[media].csr15);
+ }
+}
+
+static void de_next_media (struct de_private *de, u32 *media,
+ unsigned int n_media)
+{
+ unsigned int i;
+
+ for (i = 0; i < n_media; i++) {
+ if (de_ok_to_advertise(de, media[i])) {
+ de->media_type = media[i];
+ return;
+ }
+ }
+}
+
+static void de21040_media_timer (unsigned long data)
+{
+ struct de_private *de = (struct de_private *) data;
+ struct net_device *dev = de->dev;
+ u32 status = dr32(SIAStatus);
+ unsigned int carrier;
+ unsigned long flags;
+
+ carrier = (status & NetCxnErr) ? 0 : 1;
+
+ if (carrier) {
+ if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
+ goto no_link_yet;
+
+ de->media_timer.expires = jiffies + DE_TIMER_LINK;
+ add_timer(&de->media_timer);
+ if (!netif_carrier_ok(dev))
+ de_link_up(de);
+ else
+ if (netif_msg_timer(de))
+ printk(KERN_INFO "%s: %s link ok, status %x\n",
+ dev->name, media_name[de->media_type],
+ status);
+ return;
+ }
+
+ de_link_down(de);
+
+ if (de->media_lock)
+ return;
+
+ if (de->media_type == DE_MEDIA_AUI) {
+ u32 next_state = DE_MEDIA_TP;
+ de_next_media(de, &next_state, 1);
+ } else {
+ u32 next_state = DE_MEDIA_AUI;
+ de_next_media(de, &next_state, 1);
+ }
+
+ spin_lock_irqsave(&de->lock, flags);
+ de_stop_rxtx(de);
+ spin_unlock_irqrestore(&de->lock, flags);
+ de_set_media(de);
+ de_start_rxtx(de);
+
+no_link_yet:
+ de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
+ add_timer(&de->media_timer);
+
+ if (netif_msg_timer(de))
+ printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
+ dev->name, media_name[de->media_type], status);
+}
+
+static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
+{
+ switch (new_media) {
+ case DE_MEDIA_TP_AUTO:
+ if (!(de->media_advertise & ADVERTISED_Autoneg))
+ return 0;
+ if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
+ return 0;
+ break;
+ case DE_MEDIA_BNC:
+ if (!(de->media_advertise & ADVERTISED_BNC))
+ return 0;
+ break;
+ case DE_MEDIA_AUI:
+ if (!(de->media_advertise & ADVERTISED_AUI))
+ return 0;
+ break;
+ case DE_MEDIA_TP:
+ if (!(de->media_advertise & ADVERTISED_10baseT_Half))
+ return 0;
+ break;
+ case DE_MEDIA_TP_FD:
+ if (!(de->media_advertise & ADVERTISED_10baseT_Full))
+ return 0;
+ break;
+ }
+
+ return 1;
+}
+
+static void de21041_media_timer (unsigned long data)
+{
+ struct de_private *de = (struct de_private *) data;
+ struct net_device *dev = de->dev;
+ u32 status = dr32(SIAStatus);
+ unsigned int carrier;
+ unsigned long flags;
+
+ carrier = (status & NetCxnErr) ? 0 : 1;
+
+ if (carrier) {
+ if ((de->media_type == DE_MEDIA_TP_AUTO ||
+ de->media_type == DE_MEDIA_TP ||
+ de->media_type == DE_MEDIA_TP_FD) &&
+ (status & LinkFailStatus))
+ goto no_link_yet;
+
+ de->media_timer.expires = jiffies + DE_TIMER_LINK;
+ add_timer(&de->media_timer);
+ if (!netif_carrier_ok(dev))
+ de_link_up(de);
+ else
+ if (netif_msg_timer(de))
+ printk(KERN_INFO "%s: %s link ok, mode %x status %x\n",
+ dev->name, media_name[de->media_type],
+ dr32(MacMode), status);
+ return;
+ }
+
+ de_link_down(de);
+
+ /* if media type locked, don't switch media */
+ if (de->media_lock)
+ goto set_media;
+
+ /* if activity detected, use that as hint for new media type */
+ if (status & NonselPortActive) {
+ unsigned int have_media = 1;
+
+ /* if AUI/BNC selected, then activity is on TP port */
+ if (de->media_type == DE_MEDIA_AUI ||
+ de->media_type == DE_MEDIA_BNC) {
+ if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
+ de->media_type = DE_MEDIA_TP_AUTO;
+ else
+ have_media = 0;
+ }
+
+ /* TP selected. If there is only TP and BNC, then it's BNC */
+ else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
+ de_ok_to_advertise(de, DE_MEDIA_BNC))
+ de->media_type = DE_MEDIA_BNC;
+
+ /* TP selected. If there is only TP and AUI, then it's AUI */
+ else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
+ de_ok_to_advertise(de, DE_MEDIA_AUI))
+ de->media_type = DE_MEDIA_AUI;
+
+ /* otherwise, ignore the hint */
+ else
+ have_media = 0;
+
+ if (have_media)
+ goto set_media;
+ }
+
+ /*
+ * Absent or ambiguous activity hint, move to next advertised
+ * media state. If de->media_type is left unchanged, this
+ * simply resets the PHY and reloads the current media settings.
+ */
+ if (de->media_type == DE_MEDIA_AUI) {
+ u32 next_states[] = { DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
+ de_next_media(de, next_states, ARRAY_SIZE(next_states));
+ } else if (de->media_type == DE_MEDIA_BNC) {
+ u32 next_states[] = { DE_MEDIA_TP_AUTO, DE_MEDIA_AUI };
+ de_next_media(de, next_states, ARRAY_SIZE(next_states));
+ } else {
+ u32 next_states[] = { DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO };
+ de_next_media(de, next_states, ARRAY_SIZE(next_states));
+ }
+
+set_media:
+ spin_lock_irqsave(&de->lock, flags);
+ de_stop_rxtx(de);
+ spin_unlock_irqrestore(&de->lock, flags);
+ de_set_media(de);
+ de_start_rxtx(de);
+
+no_link_yet:
+ de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
+ add_timer(&de->media_timer);
+
+ if (netif_msg_timer(de))
+ printk(KERN_INFO "%s: no link, trying media %s, status %x\n",
+ dev->name, media_name[de->media_type], status);
+}
+
+static void de_media_interrupt (struct de_private *de, u32 status)
+{
+ if (status & LinkPass) {
+ de_link_up(de);
+ mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
+ return;
+ }
+
+ if (!(status & LinkFail))
+ BUG();
+
+ if (netif_carrier_ok(de->dev)) {
+ de_link_down(de);
+ mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
+ }
+}
+
+static int de_reset_mac (struct de_private *de)
+{
+ u32 status, tmp;
+
+ /*
+ * Reset MAC. Copied from de4x5.c.
+ */
+
+ tmp = dr32 (BusMode);
+ if (tmp == 0xffffffff)
+ return -ENODEV;
+ mdelay (1);
+
+ dw32 (BusMode, tmp | CmdReset);
+ mdelay (1);
+
+ dw32 (BusMode, tmp);
+ mdelay (1);
+
+ for (tmp = 0; tmp < 5; tmp++) {
+ dr32 (BusMode);
+ mdelay (1);
+ }
+
+ mdelay (1);
+
+ status = dr32(MacStatus);
+ if (status & (RxState | TxState))
+ return -EBUSY;
+ if (status == 0xffffffff)
+ return -ENODEV;
+ return 0;
+}
+
+static void de_adapter_wake (struct de_private *de)
+{
+ u32 pmctl;
+
+ if (de->de21040)
+ return;
+
+ pci_read_config_dword(de->pdev, PCIPM, &pmctl);
+ if (pmctl & PM_Mask) {
+ pmctl &= ~PM_Mask;
+ pci_write_config_dword(de->pdev, PCIPM, pmctl);
+
+ /* de4x5.c delays, so we do too */
+ current->state = TASK_UNINTERRUPTIBLE;
+ schedule_timeout(msec_to_jiffies(10));
+ }
+}
+
+static void de_adapter_sleep (struct de_private *de)
+{
+ u32 pmctl;
+
+ if (de->de21040)
+ return;
+
+ pci_read_config_dword(de->pdev, PCIPM, &pmctl);
+ pmctl |= PM_Sleep;
+ pci_write_config_dword(de->pdev, PCIPM, pmctl);
+}
+
+static int de_init_hw (struct de_private *de)
+{
+ struct net_device *dev = de->dev;
+ int rc;
+
+ de_adapter_wake(de);
+
+ de->macmode = dr32(MacMode) & ~MacModeClear;
+
+ rc = de_reset_mac(de);
+ if (rc)
+ return rc;
+
+ de_set_media(de); /* reset phy */
+
+ dw32(RxRingAddr, de->ring_dma);
+ dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
+
+ dw32(MacMode, RxTx | de->macmode);
+
+ dr32(RxMissed); /* self-clearing */
+
+ dw32(IntrMask, de_intr_mask);
+
+ de_set_rx_mode(dev);
+
+ return 0;
+}
+
+static int de_refill_rx (struct de_private *de)
+{
+ unsigned i;
+
+ for (i = 0; i < DE_RX_RING_SIZE; i++) {
+ struct sk_buff *skb;
+
+ skb = dev_alloc_skb(de->rx_buf_sz);
+ if (!skb)
+ goto err_out;
+
+ skb->dev = de->dev;
+
+ de->rx_skb[i].mapping = pci_map_single(de->pdev,
+ skb->tail, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
+ de->rx_skb[i].skb = skb;
+
+ de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
+ if (i == (DE_RX_RING_SIZE - 1))
+ de->rx_ring[i].opts2 =
+ cpu_to_le32(RingEnd | de->rx_buf_sz);
+ else
+ de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
+ de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
+ de->rx_ring[i].addr2 = 0;
+ }
+
+ return 0;
+
+err_out:
+ de_clean_rings(de);
+ return -ENOMEM;
+}
+
+static int de_init_rings (struct de_private *de)
+{
+ memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
+ de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
+
+ de->rx_tail = 0;
+ de->tx_head = de->tx_tail = 0;
+
+ return de_refill_rx (de);
+}
+
+static int de_alloc_rings (struct de_private *de)
+{
+ de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
+ if (!de->rx_ring)
+ return -ENOMEM;
+ de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
+ return de_init_rings(de);
+}
+
+static void de_clean_rings (struct de_private *de)
+{
+ unsigned i;
+
+ memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
+ de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
+ wmb();
+ memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
+ de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
+ wmb();
+
+ for (i = 0; i < DE_RX_RING_SIZE; i++) {
+ if (de->rx_skb[i].skb) {
+ pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
+ de->rx_buf_sz, PCI_DMA_FROMDEVICE);
+ dev_kfree_skb(de->rx_skb[i].skb);
+ }
+ }
+
+ for (i = 0; i < DE_TX_RING_SIZE; i++) {
+ struct sk_buff *skb = de->tx_skb[i].skb;
+ if ((skb) && (skb != DE_DUMMY_SKB)) {
+ if (skb != DE_SETUP_SKB) {
+ dev_kfree_skb(skb);
+ de->net_stats.tx_dropped++;
+ pci_unmap_single(de->pdev,
+ de->tx_skb[i].mapping,
+ skb->len, PCI_DMA_TODEVICE);
+ } else {
+ pci_unmap_single(de->pdev,
+ de->tx_skb[i].mapping,
+ sizeof(de->setup_frame),
+ PCI_DMA_TODEVICE);
+ }
+ }
+ }
+
+ memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
+ memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
+}
+
+static void de_free_rings (struct de_private *de)
+{
+ de_clean_rings(de);
+ pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
+ de->rx_ring = NULL;
+ de->tx_ring = NULL;
+}
+
+static int de_open (struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ int rc;
+ unsigned long flags;
+
+ if (netif_msg_ifup(de))
+ printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
+
+ de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
+
+ rc = de_alloc_rings(de);
+ if (rc) {
+ printk(KERN_ERR "%s: ring allocation failure, err=%d\n",
+ dev->name, rc);
+ return rc;
+ }
+
+ rc = de_init_hw(de);
+ if (rc) {
+ printk(KERN_ERR "%s: h/w init failure, err=%d\n",
+ dev->name, rc);
+ goto err_out_free;
+ }
+
+ rc = request_irq(dev->irq, de_interrupt, SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev);
+ if (rc) {
+ printk(KERN_ERR "%s: IRQ %d request failure, err=%d\n",
+ dev->name, dev->irq, rc);
+ goto err_out_hw;
+ }
+
+ netif_start_queue(dev);
+ mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
+
+ return 0;
+
+err_out_hw:
+ spin_lock_irqsave(&de->lock, flags);
+ de_stop_hw(de);
+ spin_unlock_irqrestore(&de->lock, flags);
+
+err_out_free:
+ de_free_rings(de);
+ return rc;
+}
+
+static int de_close (struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+ unsigned long flags;
+
+ if (netif_msg_ifdown(de))
+ printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
+
+ del_timer_sync(&de->media_timer);
+
+ spin_lock_irqsave(&de->lock, flags);
+ de_stop_hw(de);
+ netif_stop_queue(dev);
+ netif_carrier_off(dev);
+ spin_unlock_irqrestore(&de->lock, flags);
+
+ free_irq(dev->irq, dev);
+
+ de_free_rings(de);
+ de_adapter_sleep(de);
+ pci_disable_device(de->pdev);
+ return 0;
+}
+
+static void de_tx_timeout (struct net_device *dev)
+{
+ struct de_private *de = dev->priv;
+
+ printk(KERN_DEBUG "%s: NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
+ dev->name, dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
+ de->rx_tail, de->tx_head, de->tx_tail);
+
+ del_timer_sync(&de->media_timer);
+
+ disable_irq(dev->irq);
+ spin_lock_irq(&de->lock);
+
+ de_stop_hw(de);
+ netif_stop_queue(dev);
+ netif_carrier_off(dev);
+
+ spin_unlock_irq(&de->lock);
+ enable_irq(dev->irq);
+
+ /* Update the error counts. */
+ __de_get_stats(de);
+
+ synchronize_irq();
+ de_clean_rings(de);
+
+ de_init_hw(de);
+
+ netif_wake_queue(dev);
+}
+
+static int de_get_regs(struct de_private *de, u8 *buf)
+{
+ int i;
+ u32 *rbuf = (u32 *)buf;
+
+ /* read all CSRs */
+ for (i = 0; i < DE_NUM_REGS; i++)
+ rbuf[i] = dr32(i * 8);
+
+ /* handle self-clearing RxMissed counter, CSR8 */
+ de_rx_missed(de, rbuf[8]);
+
+ return 0;
+}
+
+static int de_ethtool_gset(struct de_private *de, struct ethtool_cmd *ecmd)
+{
+ ecmd->supported = de->media_supported;
+ ecmd->transceiver = XCVR_INTERNAL;
+ ecmd->phy_address = 0;
+ ecmd->advertising = de->media_advertise;
+
+ switch (de->media_type) {
+ case DE_MEDIA_AUI:
+ ecmd->port = PORT_AUI;
+ ecmd->speed = 5;
+ break;
+ case DE_MEDIA_BNC:
+ ecmd->port = PORT_BNC;
+ ecmd->speed = 2;
+ break;
+ default:
+ ecmd->port = PORT_TP;
+ ecmd->speed = SPEED_10;
+ break;
+ }
+
+ if (de->macmode & FullDuplex)
+ ecmd->duplex = DUPLEX_FULL;
+ else
+ ecmd->duplex = DUPLEX_HALF;
+
+ if (de->media_lock)
+ ecmd->autoneg = AUTONEG_DISABLE;
+ else
+ ecmd->autoneg = AUTONEG_ENABLE;
+
+ /* ignore maxtxpkt, maxrxpkt for now */
+
+ return 0;
+}
+
+static int de_ethtool_sset(struct de_private *de, struct ethtool_cmd *ecmd)
+{
+ u32 new_media;
+ unsigned int media_lock;
+
+ if (ecmd->speed != SPEED_10 && ecmd->speed != 5 && ecmd->speed != 2)
+ return -EINVAL;
+ if (de->de21040 && ecmd->speed == 2)
+ return -EINVAL;
+ if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
+ return -EINVAL;
+ if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI && ecmd->port != PORT_BNC)
+ return -EINVAL;
+ if (de->de21040 && ecmd->port == PORT_BNC)
+ return -EINVAL;
+ if (ecmd->transceiver != XCVR_INTERNAL)
+ return -EINVAL;
+ if (ecmd->autoneg != AUTONEG_DISABLE && ecmd->autoneg != AUTONEG_ENABLE)
+ return -EINVAL;
+ if (ecmd->advertising & ~de->media_supported)
+ return -EINVAL;
+ if (ecmd->autoneg == AUTONEG_ENABLE &&
+ (!(ecmd->advertising & ADVERTISED_Autoneg)))
+ return -EINVAL;
+
+ switch (ecmd->port) {
+ case PORT_AUI:
+ new_media = DE_MEDIA_AUI;
+ if (!(ecmd->advertising & ADVERTISED_AUI))
+ return -EINVAL;
+ break;
+ case PORT_BNC:
+ new_media = DE_MEDIA_BNC;
+ if (!(ecmd->advertising & ADVERTISED_BNC))
+ return -EINVAL;
+ break;
+ default:
+ if (ecmd->autoneg == AUTONEG_ENABLE)
+ new_media = DE_MEDIA_TP_AUTO;
+ else if (ecmd->duplex == DUPLEX_FULL)
+ new_media = DE_MEDIA_TP_FD;
+ else
+ new_media = DE_MEDIA_TP;
+ if (!(ecmd->advertising & ADVERTISED_TP))
+ return -EINVAL;
+ if (!(ecmd->advertising & (ADVERTISED_10baseT_Full | ADVERTISED_10baseT_Half)))
+ return -EINVAL;
+ break;
+ }
+
+ media_lock = (ecmd->autoneg == AUTONEG_ENABLE) ? 0 : 1;
+
+ if ((new_media == de->media_type) &&
+ (media_lock == de->media_lock) &&
+ (ecmd->advertising == de->media_advertise))
+ return 0; /* nothing to change */
+
+ de_link_down(de);
+ de_stop_rxtx(de);
+
+ de->media_type = new_media;
+ de->media_lock = media_lock;
+ de->media_advertise = ecmd->advertising;
+ de_set_media(de);
+
+ return 0;
+}
+
+static int de_ethtool_ioctl (struct de_private *de, void *useraddr)
+{
+ u32 ethcmd;
+
+ /* dev_ioctl() in ../../net/core/dev.c has already checked
+ capable(CAP_NET_ADMIN), so don't bother with that here. */
+
+ if (get_user(ethcmd, (u32 *)useraddr))
+ return -EFAULT;
+
+ switch (ethcmd) {
+
+ case ETHTOOL_GDRVINFO: {
+ struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
+ strcpy (info.driver, DRV_NAME);
+ strcpy (info.version, DRV_VERSION);
+ strcpy (info.bus_info, de->pdev->slot_name);
+ info.eedump_len = DE_EEPROM_SIZE;
+ info.regdump_len = DE_REGS_SIZE;
+ if (copy_to_user (useraddr, &info, sizeof (info)))
+ return -EFAULT;
+ return 0;
+ }
+
+ /* get settings */
+ case ETHTOOL_GSET: {
+ struct ethtool_cmd ecmd = { ETHTOOL_GSET };
+ spin_lock_irq(&de->lock);
+ de_ethtool_gset(de, &ecmd);
+ spin_unlock_irq(&de->lock);
+ if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
+ return -EFAULT;
+ return 0;
+ }
+ /* set settings */
+ case ETHTOOL_SSET: {
+ struct ethtool_cmd ecmd;
+ int r;
+ if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
+ return -EFAULT;
+ spin_lock_irq(&de->lock);
+ r = de_ethtool_sset(de, &ecmd);
+ spin_unlock_irq(&de->lock);
+ return r;
+ }
+
+ /* restart autonegotiation */
+ case ETHTOOL_NWAY_RST: {
+ u32 status;
+
+ if (de->media_type != DE_MEDIA_TP_AUTO)
+ return -EINVAL;
+ if (netif_carrier_ok(de->dev))
+ de_link_down(de);
+
+ status = dr32(SIAStatus);
+ dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
+ if (netif_msg_link(de))
+ printk(KERN_INFO "%s: link nway restart, status %x,%x\n",
+ de->dev->name, status, dr32(SIAStatus));
+ return 0;
+ }
+
+ /* get link status */
+ case ETHTOOL_GLINK: {
+ struct ethtool_value edata = {ETHTOOL_GLINK};
+ edata.data = (netif_carrier_ok(de->dev)) ? 1 : 0;
+ if (copy_to_user(useraddr, &edata, sizeof(edata)))
+ return -EFAULT;
+ return 0;
+ }
+
+ /* get message-level */
+ case ETHTOOL_GMSGLVL: {
+ struct ethtool_value edata = {ETHTOOL_GMSGLVL};
+ edata.data = de->msg_enable;
+ if (copy_to_user(useraddr, &edata, sizeof(edata)))
+ return -EFAULT;
+ return 0;
+ }
+ /* set message-level */
+ case ETHTOOL_SMSGLVL: {
+ struct ethtool_value edata;
+ if (copy_from_user(&edata, useraddr, sizeof(edata)))
+ return -EFAULT;
+ de->msg_enable = edata.data;
+ return 0;
+ }
+
+ /* get registers */
+ case ETHTOOL_GREGS: {
+ struct ethtool_regs regs;
+ u8 regbuf[DE_REGS_SIZE];
+ int r;
+
+ if (copy_from_user(®s, useraddr, sizeof(regs)))
+ return -EFAULT;
+
+ if (regs.len > DE_REGS_SIZE) {
+ regs.len = DE_REGS_SIZE;
+ }
+ regs.version = (DE_REGS_VER << 2) | de->de21040;
+ if (copy_to_user(useraddr, ®s, sizeof(regs)))
+ return -EFAULT;
+
+ useraddr += offsetof(struct ethtool_regs, data);
+
+ spin_lock_irq(&de->lock);
+ r = de_get_regs(de, regbuf);
+ spin_unlock_irq(&de->lock);
+
+ if (r)
+ return r;
+ if (copy_to_user(useraddr, regbuf, regs.len))
+ return -EFAULT;
+ return 0;
+ }
+
+ /* get SROM dump */
+ case ETHTOOL_GEEPROM: {
+ struct ethtool_eeprom eeprom;
+
+ if (!de->ee_data)
+ break;
+ if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
+ return -EFAULT;
+ if ((eeprom.offset != 0) || (eeprom.magic != 0) ||
+ (eeprom.len != DE_EEPROM_SIZE))
+ return -EINVAL;
+
+ useraddr += offsetof(struct ethtool_regs, data);
+ if (copy_to_user(useraddr, de->ee_data, DE_EEPROM_SIZE))
+ return -EFAULT;
+ }
+
+ default:
+ break;
+ }
+
+ return -EOPNOTSUPP;
+}
+
+
+static int de_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
+{
+ struct de_private *de = dev->priv;
+ int rc = 0;
+
+ if (!netif_running(dev))
+ return -EINVAL;
+
+ switch (cmd) {
+ case SIOCETHTOOL:
+ return de_ethtool_ioctl(de, (void *) rq->ifr_data);
+
+ default:
+ rc = -EOPNOTSUPP;
+ break;
+ }
+
+ return rc;
+}
+
+static void __init de21040_get_mac_address (struct de_private *de)
+{
+ unsigned i;
+
+ dw32 (ROMCmd, 0); /* Reset the pointer with a dummy write. */
+
+ for (i = 0; i < 6; i++) {
+ int value, boguscnt = 100000;
+ do
+ value = dr32(ROMCmd);
+ while (value < 0 && --boguscnt > 0);
+ de->dev->dev_addr[i] = value;
+ if (boguscnt <= 0)
+ printk(KERN_WARNING PFX "timeout reading 21040 MAC address byte %u\n", i);
+ }
+}
+
+static void __init de21040_get_media_info(struct de_private *de)
+{
+ unsigned int i;
+
+ de->media_type = DE_MEDIA_TP;
+ de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
+ SUPPORTED_10baseT_Half | SUPPORTED_AUI;
+ de->media_advertise = de->media_supported;
+
+ for (i = 0; i < DE_MAX_MEDIA; i++) {
+ switch (i) {
+ case DE_MEDIA_AUI:
+ case DE_MEDIA_TP:
+ case DE_MEDIA_TP_FD:
+ de->media[i].type = i;
+ de->media[i].csr13 = t21040_csr13[i];
+ de->media[i].csr14 = t21040_csr14[i];
+ de->media[i].csr15 = t21040_csr15[i];
+ break;
+ default:
+ de->media[i].type = DE_MEDIA_INVALID;
+ break;
+ }
+ }
+}
+
+/* Note: this routine returns extra data bits for size detection. */
+static unsigned __init tulip_read_eeprom(void *regs, int location, int addr_len)
+{
+ int i;
+ unsigned retval = 0;
+ void *ee_addr = regs + ROMCmd;
+ int read_cmd = location | (EE_READ_CMD << addr_len);
+
+ writel(EE_ENB & ~EE_CS, ee_addr);
+ writel(EE_ENB, ee_addr);
+
+ /* Shift the read command bits out. */
+ for (i = 4 + addr_len; i >= 0; i--) {
+ short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
+ writel(EE_ENB | dataval, ee_addr);
+ readl(ee_addr);
+ writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
+ readl(ee_addr);
+ retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
+ }
+ writel(EE_ENB, ee_addr);
+ readl(ee_addr);
+
+ for (i = 16; i > 0; i--) {
+ writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
+ readl(ee_addr);
+ retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
+ writel(EE_ENB, ee_addr);
+ readl(ee_addr);
+ }
+
+ /* Terminate the EEPROM access. */
+ writel(EE_ENB & ~EE_CS, ee_addr);
+ return retval;
+}
+
+static void __init de21041_get_srom_info (struct de_private *de)
+{
+ unsigned i, sa_offset = 0, ofs;
+ u8 ee_data[DE_EEPROM_SIZE + 6] = {};
+ unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
+ struct de_srom_info_leaf *il;
+ void *bufp;
+
+ /* download entire eeprom */
+ for (i = 0; i < DE_EEPROM_WORDS; i++)
+ ((u16 *)ee_data)[i] =
+ le16_to_cpu(tulip_read_eeprom(de->regs, i, ee_addr_size));
+
+ /* DEC now has a specification but early board makers
+ just put the address in the first EEPROM locations. */
+ /* This does memcmp(eedata, eedata+16, 8) */
+ for (i = 0; i < 8; i ++)
+ if (ee_data[i] != ee_data[16+i])
+ sa_offset = 20;
+
+ /* store MAC address */
+ for (i = 0; i < 6; i ++)
+ de->dev->dev_addr[i] = ee_data[i + sa_offset];
+
+ /* get offset of controller 0 info leaf. ignore 2nd byte. */
+ ofs = ee_data[SROMC0InfoLeaf];
+ if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
+ goto bad_srom;
+
+ /* get pointer to info leaf */
+ il = (struct de_srom_info_leaf *) &ee_data[ofs];
+
+ /* paranoia checks */
+ if (il->n_blocks == 0)
+ goto bad_srom;
+ if ((sizeof(ee_data) - ofs) <
+ (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
+ goto bad_srom;
+
+ /* get default media type */
+ switch (DE_UNALIGNED_16(&il->default_media)) {
+ case 0x0001: de->media_type = DE_MEDIA_BNC; break;
+ case 0x0002: de->media_type = DE_MEDIA_AUI; break;
+ case 0x0204: de->media_type = DE_MEDIA_TP_FD; break;
+ default: de->media_type = DE_MEDIA_TP_AUTO; break;
+ }
+
+ if (netif_msg_probe(de))
+ printk(KERN_INFO "de%d: SROM leaf offset %u, default media %s\n",
+ de->board_idx, ofs,
+ media_name[de->media_type]);
+
+ /* init SIA register values to defaults */
+ for (i = 0; i < DE_MAX_MEDIA; i++) {
+ de->media[i].type = DE_MEDIA_INVALID;
+ de->media[i].csr13 = 0xffff;
+ de->media[i].csr14 = 0xffff;
+ de->media[i].csr15 = 0xffff;
+ }
+
+ /* parse media blocks to see what medias are supported,
+ * and if any custom CSR values are provided
+ */
+ bufp = ((void *)il) + sizeof(*il);
+ for (i = 0; i < il->n_blocks; i++) {
+ struct de_srom_media_block *ib = bufp;
+ unsigned idx;
+
+ /* index based on media type in media block */
+ switch(ib->opts & MediaBlockMask) {
+ case 0: /* 10baseT */
+ de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
+ | SUPPORTED_Autoneg;
+ idx = DE_MEDIA_TP;
+ de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
+ break;
+ case 1: /* BNC */
+ de->media_supported |= SUPPORTED_BNC;
+ idx = DE_MEDIA_BNC;
+ break;
+ case 2: /* AUI */
+ de->media_supported |= SUPPORTED_AUI;
+ idx = DE_MEDIA_AUI;
+ break;
+ case 4: /* 10baseT-FD */
+ de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
+ | SUPPORTED_Autoneg;
+ idx = DE_MEDIA_TP_FD;
+ de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
+ break;
+ default:
+ goto bad_srom;
+ }
+
+ de->media[idx].type = idx;
+
+ if (netif_msg_probe(de))
+ printk(KERN_INFO "de%d: media block #%u: %s",
+ de->board_idx, i,
+ media_name[de->media[idx].type]);
+
+ bufp += sizeof (ib->opts);
+
+ if (ib->opts & MediaCustomCSRs) {
+ de->media[idx].csr13 = DE_UNALIGNED_16(&ib->csr13);
+ de->media[idx].csr14 = DE_UNALIGNED_16(&ib->csr14);
+ de->media[idx].csr15 = DE_UNALIGNED_16(&ib->csr15);
+ bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
+ sizeof(ib->csr15);
+
+ if (netif_msg_probe(de))
+ printk(" (%x,%x,%x)\n",
+ de->media[idx].csr13,
+ de->media[idx].csr14,
+ de->media[idx].csr15);
+
+ } else if (netif_msg_probe(de))
+ printk("\n");
+
+ if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
+ break;
+ }
+
+ de->media_advertise = de->media_supported;
+
+fill_defaults:
+ /* fill in defaults, for cases where custom CSRs not used */
+ for (i = 0; i < DE_MAX_MEDIA; i++) {
+ if (de->media[i].csr13 == 0xffff)
+ de->media[i].csr13 = t21041_csr13[i];
+ if (de->media[i].csr14 == 0xffff)
+ de->media[i].csr14 = t21041_csr14[i];
+ if (de->media[i].csr15 == 0xffff)
+ de->media[i].csr15 = t21041_csr15[i];
+ }
+
+ de->ee_data = kmalloc(DE_EEPROM_SIZE, GFP_KERNEL);
+ if (de->ee_data)
+ memcpy(de->ee_data, &ee_data[0], DE_EEPROM_SIZE);
+
+ return;
+
+bad_srom:
+ /* for error cases, it's ok to assume we support all these */
+ for (i = 0; i < DE_MAX_MEDIA; i++)
+ de->media[i].type = i;
+ de->media_supported =
+ SUPPORTED_10baseT_Half |
+ SUPPORTED_10baseT_Full |
+ SUPPORTED_Autoneg |
+ SUPPORTED_TP |
+ SUPPORTED_AUI |
+ SUPPORTED_BNC;
+ goto fill_defaults;
+}
+
+static int __init de_init_one (struct pci_dev *pdev,
+ const struct pci_device_id *ent)
+{
+ struct net_device *dev;
+ struct de_private *de;
+ int rc;
+ void *regs;
+ long pciaddr;
+ static int board_idx = -1;
+
+ board_idx++;
+
+#ifndef MODULE
+ if (board_idx == 0)
+ printk("%s", version);
+#endif
+
+ /* allocate a new ethernet device structure, and fill in defaults */
+ dev = alloc_etherdev(sizeof(struct de_private));
+ if (!dev)
+ return -ENOMEM;
+
+ SET_MODULE_OWNER(dev);
+ dev->open = de_open;
+ dev->stop = de_close;
+ dev->set_multicast_list = de_set_rx_mode;
+ dev->hard_start_xmit = de_start_xmit;
+ dev->get_stats = de_get_stats;
+ dev->do_ioctl = de_ioctl;
+ dev->tx_timeout = de_tx_timeout;
+ dev->watchdog_timeo = TX_TIMEOUT;
+
+ dev->irq = pdev->irq;
+
+ de = dev->priv;
+ de->de21040 = ent->driver_data == 0 ? 1 : 0;
+ de->pdev = pdev;
+ de->dev = dev;
+ de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
+ de->board_idx = board_idx;
+ spin_lock_init (&de->lock);
+ init_timer(&de->media_timer);
+ if (de->de21040)
+ de->media_timer.function = de21040_media_timer;
+ else
+ de->media_timer.function = de21041_media_timer;
+ de->media_timer.data = (unsigned long) de;
+
+ netif_carrier_off(dev);
+ netif_stop_queue(dev);
+
+ /* wake up device, assign resources */
+ rc = pci_enable_device(pdev);
+ if (rc)
+ goto err_out_free;
+
+ /* reserve PCI resources to ensure driver atomicity */
+ rc = pci_request_regions(pdev, DRV_NAME);
+ if (rc)
+ goto err_out_disable;
+
+ /* check for invalid IRQ value */
+ if (pdev->irq < 2) {
+ rc = -EIO;
+ printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
+ pdev->irq, pdev->slot_name);
+ goto err_out_res;
+ }
+
+ /* obtain and check validity of PCI I/O address */
+ pciaddr = pci_resource_start(pdev, 1);
+ if (!pciaddr) {
+ rc = -EIO;
+ printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
+ pdev->slot_name);
+ goto err_out_res;
+ }
+ if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
+ rc = -EIO;
+ printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
+ pci_resource_len(pdev, 1), pdev->slot_name);
+ goto err_out_res;
+ }
+
+ /* remap CSR registers */
+ regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
+ if (!regs) {
+ rc = -EIO;
+ printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
+ pci_resource_len(pdev, 1), pciaddr, pdev->slot_name);
+ goto err_out_res;
+ }
+ dev->base_addr = (unsigned long) regs;
+ de->regs = regs;
+
+ de_adapter_wake(de);
+
+ /* make sure hardware is not running */
+ rc = de_reset_mac(de);
+ if (rc) {
+ printk(KERN_ERR PFX "Cannot reset MAC, pci dev %s\n",
+ pdev->slot_name);
+ goto err_out_iomap;
+ }
+
+ /* get MAC address, initialize default media type and
+ * get list of supported media
+ */
+ if (de->de21040) {
+ de21040_get_mac_address(de);
+ de21040_get_media_info(de);
+ } else {
+ de21041_get_srom_info(de);
+ }
+
+ /* register new network interface with kernel */
+ rc = register_netdev(dev);
+ if (rc)
+ goto err_out_iomap;
+
+ /* print info about board and interface just registered */
+ printk (KERN_INFO "%s: %s at 0x%lx, "
+ "%02x:%02x:%02x:%02x:%02x:%02x, "
+ "IRQ %d\n",
+ dev->name,
+ de->de21040 ? "21040" : "21041",
+ dev->base_addr,
+ dev->dev_addr[0], dev->dev_addr[1],
+ dev->dev_addr[2], dev->dev_addr[3],
+ dev->dev_addr[4], dev->dev_addr[5],
+ dev->irq);
+
+ pci_set_drvdata(pdev, dev);
+
+ /* enable busmastering */
+ pci_set_master(pdev);
+
+ /* put adapter to sleep */
+ de_adapter_sleep(de);
+
+ return 0;
+
+err_out_iomap:
+ if (de->ee_data)
+ kfree(de->ee_data);
+ iounmap(regs);
+err_out_res:
+ pci_release_regions(pdev);
+err_out_disable:
+ pci_disable_device(pdev);
+err_out_free:
+ kfree(dev);
+ return rc;
+}
+
+static void __exit de_remove_one (struct pci_dev *pdev)
+{
+ struct net_device *dev = pci_get_drvdata(pdev);
+ struct de_private *de = dev->priv;
+
+ if (!dev)
+ BUG();
+ unregister_netdev(dev);
+ if (de->ee_data)
+ kfree(de->ee_data);
+ iounmap(de->regs);
+ pci_release_regions(pdev);
+ pci_disable_device(pdev);
+ pci_set_drvdata(pdev, NULL);
+ kfree(dev);
+}
+
+#ifdef CONFIG_PM
+
+static int de_suspend (struct pci_dev *pdev, u32 state)
+{
+ struct net_device *dev = pci_get_drvdata (pdev);
+ struct de_private *de = dev->priv;
+
+ rtnl_lock();
+ if (netif_running (dev)) {
+ del_timer_sync(&de->media_timer);
+
+ disable_irq(dev->irq);
+ spin_lock_irq(&de->lock);
+
+ de_stop_hw(de);
+ netif_stop_queue(dev);
+ netif_device_detach(dev);
+ netif_carrier_off(dev);
+
+ spin_unlock_irq(&de->lock);
+ enable_irq(dev->irq);
+
+ /* Update the error counts. */
+ __de_get_stats(de);
+
+ synchronize_irq();
+ de_clean_rings(de);
+
+ de_adapter_sleep(de);
+ pci_disable_device(pdev);
+ } else {
+ netif_device_detach(dev);
+ }
+ rtnl_unlock();
+ return 0;
+}
+
+static int de_resume (struct pci_dev *pdev)
+{
+ struct net_device *dev = pci_get_drvdata (pdev);
+ struct de_private *de = dev->priv;
+
+ rtnl_lock();
+ if (netif_device_present(dev))
+ goto out;
+ if (netif_running(dev)) {
+ pci_enable_device(pdev);
+ de_init_hw(de);
+ netif_device_attach(dev);
+ } else {
+ netif_device_attach(dev);
+ }
+out:
+ rtnl_unlock();
+ return 0;
+}
+
+#endif /* CONFIG_PM */
+
+static struct pci_driver de_driver = {
+ name: DRV_NAME,
+ id_table: de_pci_tbl,
+ probe: de_init_one,
+ remove: de_remove_one,
+#ifdef CONFIG_PM
+ suspend: de_suspend,
+ resume: de_resume,
+#endif
+};
+
+static int __init de_init (void)
+{
+#ifdef MODULE
+ printk("%s", version);
+#endif
+ return pci_module_init (&de_driver);
+}
+
+static void __exit de_exit (void)
+{
+ pci_unregister_driver (&de_driver);
+}
+
+module_init(de_init);
+module_exit(de_exit);
diff -urN linux-2.5.7/drivers/net/a2065.c linux/drivers/net/a2065.c
--- linux-2.5.7/drivers/net/a2065.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/a2065.c Thu Mar 21 14:52:58 2002
@@ -497,8 +497,8 @@
last_dev = dev;
/* Install the Interrupt handler */
- ret = request_irq(IRQ_AMIGA_PORTS, lance_interrupt, SA_SHIRQ,
- dev->name, dev);
+ ret = request_irq(IRQ_AMIGA_PORTS, lance_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret) return ret;
/* Stop the Lance */
diff -urN linux-2.5.7/drivers/net/ac3200.c linux/drivers/net/ac3200.c
--- linux-2.5.7/drivers/net/ac3200.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/ac3200.c Thu Mar 21 14:52:58 2002
@@ -173,7 +173,8 @@
printk(", assigning");
}
- retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (retval) {
printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
goto out1;
diff -urN linux-2.5.7/drivers/net/acenic.c linux/drivers/net/acenic.c
--- linux-2.5.7/drivers/net/acenic.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/acenic.c Thu Mar 21 14:53:36 2002
@@ -1402,7 +1402,7 @@
goto init_error;
}
- ecode = request_irq(pdev->irq, ace_interrupt, SA_SHIRQ,
+ ecode = request_irq(pdev->irq, ace_interrupt, SA_SHIRQ | SA_NET_RANDOM,
dev->name, dev);
if (ecode) {
printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
diff -urN linux-2.5.7/drivers/net/aironet4500_card.c linux/drivers/net/aironet4500_card.c
--- linux-2.5.7/drivers/net/aironet4500_card.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/aironet4500_card.c Thu Mar 21 14:52:58 2002
@@ -213,7 +213,7 @@
dev->watchdog_timeo = AWC_TX_TIMEOUT;
- i = request_irq(dev->irq,awc_interrupt, SA_SHIRQ | SA_INTERRUPT, dev->name, dev);
+ i = request_irq(dev->irq,awc_interrupt, SA_SHIRQ | SA_INTERRUPT | SA_NET_RANDOM, dev->name, dev);
if (i) {
kfree(dev->priv);
dev->priv = NULL;
diff -urN linux-2.5.7/drivers/net/am79c961a.c linux/drivers/net/am79c961a.c
--- linux-2.5.7/drivers/net/am79c961a.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/am79c961a.c Thu Mar 21 14:52:58 2002
@@ -268,7 +268,8 @@
memset (&priv->stats, 0, sizeof (priv->stats));
- ret = request_irq(dev->irq, am79c961_interrupt, 0, dev->name, dev);
+ ret = request_irq(dev->irq, am79c961_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret)
return ret;
diff -urN linux-2.5.7/drivers/net/apne.c linux/drivers/net/apne.c
--- linux-2.5.7/drivers/net/apne.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/apne.c Thu Mar 21 14:52:58 2002
@@ -287,7 +287,8 @@
dev->base_addr = ioaddr;
/* Install the Interrupt handler */
- i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) return i;
/* Allocate dev->priv and fill in 8390 specific dev fields. */
diff -urN linux-2.5.7/drivers/net/appletalk/cops.c linux/drivers/net/appletalk/cops.c
--- linux-2.5.7/drivers/net/appletalk/cops.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/appletalk/cops.c Thu Mar 21 14:52:58 2002
@@ -304,7 +304,8 @@
/* Reserve any actual interrupt. */
if(dev->irq) {
- retval = request_irq(dev->irq, &cops_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, &cops_interrupt,
+ SA_NET_RANDOM, dev->name, dev);
if (retval)
goto err_out;
}
diff -urN linux-2.5.7/drivers/net/appletalk/ltpc.c linux/drivers/net/appletalk/ltpc.c
--- linux-2.5.7/drivers/net/appletalk/ltpc.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/appletalk/ltpc.c Thu Mar 21 14:52:58 2002
@@ -1200,7 +1200,8 @@
if (irq) {
/* grab it and don't let go :-) */
- (void) request_irq( irq, <pc_interrupt, 0, "ltpc", dev);
+ (void) request_irq(irq, <pc_interrupt,
+ SA_NET_RANDOM, "ltpc", dev);
(void) inb_p(io+7); /* enable interrupts from board */
(void) inb_p(io+7); /* and reset irq line */
} else {
diff -urN linux-2.5.7/drivers/net/arcnet/arc-rimi.c linux/drivers/net/arcnet/arc-rimi.c
--- linux-2.5.7/drivers/net/arcnet/arc-rimi.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/arcnet/arc-rimi.c Thu Mar 21 14:52:58 2002
@@ -121,7 +121,8 @@
int mirror_size;
/* reserve the irq */ {
- if (request_irq(dev->irq, &arcnet_interrupt, 0, "arcnet (RIM I)", dev))
+ if (request_irq(dev->irq, &arcnet_interrupt,
+ SA_NET_RANDOM, "arcnet (RIM I)", dev))
BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", dev->irq);
return -ENODEV;
}
diff -urN linux-2.5.7/drivers/net/arcnet/com20020.c linux/drivers/net/arcnet/com20020.c
--- linux-2.5.7/drivers/net/arcnet/com20020.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/arcnet/com20020.c Thu Mar 21 14:52:58 2002
@@ -196,7 +196,8 @@
outb(dev->dev_addr[0], _XREG);
/* reserve the irq */
- if (request_irq(dev->irq, &arcnet_interrupt, shared,
+ if (request_irq(dev->irq, &arcnet_interrupt,
+ shared | SA_NET_RANDOM,
"arcnet (COM20020)", dev)) {
BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", dev->irq);
return -ENODEV;
diff -urN linux-2.5.7/drivers/net/arcnet/com90io.c linux/drivers/net/arcnet/com90io.c
--- linux-2.5.7/drivers/net/arcnet/com90io.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/arcnet/com90io.c Thu Mar 21 14:52:58 2002
@@ -236,7 +236,8 @@
int ioaddr = dev->base_addr;
/* Reserve the irq */
- if (request_irq(dev->irq, &arcnet_interrupt, 0, "arcnet (COM90xx-IO)", dev)) {
+ if (request_irq(dev->irq, &arcnet_interrupt,
+ SA_NET_RANDOM, "arcnet (COM90xx-IO)", dev)) {
BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", dev->irq);
return -ENODEV;
}
diff -urN linux-2.5.7/drivers/net/arcnet/com90xx.c linux/drivers/net/arcnet/com90xx.c
--- linux-2.5.7/drivers/net/arcnet/com90xx.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/arcnet/com90xx.c Thu Mar 21 14:52:58 2002
@@ -472,7 +472,8 @@
dev->dev_addr[0] = readb(lp->mem_start + 1);
/* reserve the irq */
- if (request_irq(airq, &arcnet_interrupt, 0, "arcnet (90xx)", dev)) {
+ if (request_irq(airq, &arcnet_interrupt, SA_NET_RANDOM,
+ "arcnet (90xx)", dev)) {
BUGMSG(D_NORMAL, "Can't get IRQ %d!\n", airq);
goto err_unmap;
}
diff -urN linux-2.5.7/drivers/net/ariadne.c linux/drivers/net/ariadne.c
--- linux-2.5.7/drivers/net/ariadne.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/ariadne.c Thu Mar 21 14:52:58 2002
@@ -313,8 +313,8 @@
netif_start_queue(dev);
- i = request_irq(IRQ_AMIGA_PORTS, ariadne_interrupt, SA_SHIRQ,
- dev->name, dev);
+ i = request_irq(IRQ_AMIGA_PORTS, ariadne_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) return i;
lance->RAP = CSR0; /* PCnet-ISA Controller Status */
diff -urN linux-2.5.7/drivers/net/ariadne2.c linux/drivers/net/ariadne2.c
--- linux-2.5.7/drivers/net/ariadne2.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/ariadne2.c Thu Mar 21 14:52:58 2002
@@ -194,7 +194,8 @@
dev->irq = IRQ_AMIGA_PORTS;
/* Install the Interrupt handler */
- i = request_irq(IRQ_AMIGA_PORTS, ei_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(IRQ_AMIGA_PORTS, ei_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) return i;
/* Allocate dev->priv and fill in 8390 specific dev fields. */
diff -urN linux-2.5.7/drivers/net/arlan.c linux/drivers/net/arlan.c
--- linux-2.5.7/drivers/net/arlan.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/arlan.c Thu Mar 21 14:52:58 2002
@@ -1299,7 +1299,8 @@
return ret;
arlan = ((struct arlan_private *) dev->priv)->card;
- ret = request_irq(dev->irq, &arlan_interrupt, 0, dev->name, dev);
+ ret = request_irq(dev->irq, &arlan_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret)
{
printk(KERN_ERR "%s: unable to get IRQ %d .\n",
diff -urN linux-2.5.7/drivers/net/at1700.c linux/drivers/net/at1700.c
--- linux-2.5.7/drivers/net/at1700.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/at1700.c Thu Mar 21 14:52:58 2002
@@ -440,7 +440,8 @@
lp->jumpered = is_fmv18x;
lp->mca_slot = slot;
/* Snarf the interrupt vector now. */
- ret = request_irq(irq, &net_interrupt, 0, dev->name, dev);
+ ret = request_irq(irq, &net_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret) {
printk (" AT1700 at %#3x is unusable due to a conflict on"
"IRQ %d.\n", ioaddr, irq);
diff -urN linux-2.5.7/drivers/net/atarilance.c linux/drivers/net/atarilance.c
--- linux-2.5.7/drivers/net/atarilance.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/atarilance.c Thu Mar 21 14:52:58 2002
@@ -546,7 +546,8 @@
if (lp->cardtype == PAM_CARD ||
memaddr == (unsigned short *)0xffe00000) {
/* PAMs card and Riebl on ST use level 5 autovector */
- request_irq(IRQ_AUTO_5, lance_interrupt, IRQ_TYPE_PRIO,
+ request_irq(IRQ_AUTO_5, lance_interrupt,
+ IRQ_TYPE_PRIO | SA_NET_RANDOM,
"PAM/Riebl-ST Ethernet", dev);
dev->irq = (unsigned short)IRQ_AUTO_5;
}
@@ -560,7 +561,8 @@
printk( "Lance: request for VME interrupt failed\n" );
return( 0 );
}
- request_irq(irq, lance_interrupt, IRQ_TYPE_PRIO,
+ request_irq(irq, lance_interrupt,
+ IRQ_TYPE_PRIO | SA_NET_RANDOM,
"Riebl-VME Ethernet", dev);
dev->irq = irq;
}
diff -urN linux-2.5.7/drivers/net/atp.c linux/drivers/net/atp.c
--- linux-2.5.7/drivers/net/atp.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/atp.c Thu Mar 21 14:52:58 2002
@@ -439,7 +439,8 @@
/* The interrupt line is turned off (tri-stated) when the device isn't in
use. That's especially important for "attached" interfaces where the
port or interrupt may be shared. */
- ret = request_irq(dev->irq, &atp_interrupt, 0, dev->name, dev);
+ ret = request_irq(dev->irq, &atp_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret)
return ret;
diff -urN linux-2.5.7/drivers/net/au1000_eth.c linux/drivers/net/au1000_eth.c
--- linux-2.5.7/drivers/net/au1000_eth.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/au1000_eth.c Thu Mar 21 14:52:58 2002
@@ -820,7 +820,8 @@
}
netif_start_queue(dev);
- if ((retval = request_irq(dev->irq, &au1000_interrupt, 0, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, &au1000_interrupt,
+ SA_NET_RANDOM, dev->name, dev))) {
printk(KERN_ERR "%s: unable to get IRQ %d\n", dev->name, dev->irq);
MOD_DEC_USE_COUNT;
return retval;
diff -urN linux-2.5.7/drivers/net/bagetlance.c linux/drivers/net/bagetlance.c
--- linux-2.5.7/drivers/net/bagetlance.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/bagetlance.c Thu Mar 21 14:52:58 2002
@@ -622,7 +622,8 @@
if (lp->cardtype == PAM_CARD ||
memaddr == (unsigned short *)0xffe00000) {
/* PAMs card and Riebl on ST use level 5 autovector */
- request_irq(BAGET_LANCE_IRQ, lance_interrupt, IRQ_TYPE_PRIO,
+ request_irq(BAGET_LANCE_IRQ, lance_interrupt,
+ IRQ_TYPE_PRIO | SA_NET_RANDOM,
"PAM/Riebl-ST Ethernet", dev);
dev->irq = (unsigned short)BAGET_LANCE_IRQ;
}
diff -urN linux-2.5.7/drivers/net/bmac.c linux/drivers/net/bmac.c
--- linux-2.5.7/drivers/net/bmac.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/bmac.c Thu Mar 21 14:52:58 2002
@@ -1406,17 +1406,20 @@
/* init_timer(&bp->tx_timeout); */
/* bp->timeout_active = 0; */
- ret = request_irq(dev->irq, bmac_misc_intr, 0, "BMAC-misc", dev);
+ ret = request_irq(dev->irq, bmac_misc_intr, SA_NET_RANDOM,
+ "BMAC-misc", dev);
if (ret) {
printk(KERN_ERR "BMAC: can't get irq %d\n", dev->irq);
goto err_out_iounmap_rx;
}
- ret = request_irq(bmac->intrs[1].line, bmac_txdma_intr, 0, "BMAC-txdma", dev);
+ ret = request_irq(bmac->intrs[1].line, bmac_txdma_intr,
+ SA_NET_RANDOM, "BMAC-txdma", dev);
if (ret) {
printk(KERN_ERR "BMAC: can't get irq %d\n", bmac->intrs[1].line);
goto err_out_irq0;
}
- ret = request_irq(bmac->intrs[2].line, bmac_rxdma_intr, 0, "BMAC-rxdma", dev);
+ ret = request_irq(bmac->intrs[2].line, bmac_rxdma_intr,
+ SA_NET_RANDOM, "BMAC-rxdma", dev);
if (ret) {
printk(KERN_ERR "BMAC: can't get irq %d\n", bmac->intrs[2].line);
goto err_out_irq1;
diff -urN linux-2.5.7/drivers/net/cs89x0.c linux/drivers/net/cs89x0.c
--- linux-2.5.7/drivers/net/cs89x0.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/cs89x0.c Thu Mar 21 14:52:58 2002
@@ -1057,7 +1057,7 @@
for (i = 2; i < CS8920_NO_INTS; i++) {
if ((1 << dev->irq) & lp->irq_map) {
- if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
+ if (request_irq(i, net_interrupt, SA_NET_RANDOM, dev->name, dev) == 0) {
dev->irq = i;
write_irq(dev, lp->chip_type, i);
/* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
@@ -1086,7 +1086,8 @@
writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
#endif
write_irq(dev, lp->chip_type, dev->irq);
- ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
+ ret = request_irq(dev->irq, &net_interrupt,
+ SA_NET_RANDOM, dev->name, dev);
if (ret) {
if (net_debug)
printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
diff -urN linux-2.5.7/drivers/net/daynaport.c linux/drivers/net/daynaport.c
--- linux-2.5.7/drivers/net/daynaport.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/daynaport.c Thu Mar 21 14:52:58 2002
@@ -643,7 +643,8 @@
/* - funaho@jurai.org (1999-05-17) */
/* Non-slow interrupt, works around issues with the SONIC driver */
- ret = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ ret = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret) {
printk ("%s: unable to get IRQ %d.\n", dev->name, dev->irq);
return ret;
diff -urN linux-2.5.7/drivers/net/de600.c linux/drivers/net/de600.c
--- linux-2.5.7/drivers/net/de600.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/de600.c Thu Mar 21 14:52:58 2002
@@ -344,7 +344,8 @@
static int
de600_open(struct net_device *dev)
{
- int ret = request_irq(DE600_IRQ, de600_interrupt, 0, dev->name, dev);
+ int ret = request_irq(DE600_IRQ, de600_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret) {
printk ("%s: unable to get IRQ %d\n", dev->name, DE600_IRQ);
return ret;
diff -urN linux-2.5.7/drivers/net/de620.c linux/drivers/net/de620.c
--- linux-2.5.7/drivers/net/de620.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/de620.c Thu Mar 21 14:52:58 2002
@@ -443,7 +443,8 @@
*/
static int de620_open(struct net_device *dev)
{
- int ret = request_irq(dev->irq, de620_interrupt, 0, dev->name, dev);
+ int ret = request_irq(dev->irq, de620_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (ret) {
printk (KERN_ERR "%s: unable to get IRQ %d\n", dev->name, dev->irq);
return ret;
diff -urN linux-2.5.7/drivers/net/declance.c linux/drivers/net/declance.c
--- linux-2.5.7/drivers/net/declance.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/declance.c Thu Mar 21 14:52:58 2002
@@ -798,7 +798,8 @@
netif_start_queue(dev);
/* Associate IRQ with lance_interrupt */
- if (request_irq(dev->irq, &lance_interrupt, 0, lp->name, dev)) {
+ if (request_irq(dev->irq, &lance_interrupt, SA_NET_RANDOM,
+ lp->name, dev)) {
printk("Lance: Can't get irq %d\n", dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/defxx.c linux/drivers/net/defxx.c
--- linux-2.5.7/drivers/net/defxx.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/defxx.c Thu Mar 21 14:52:58 2002
@@ -1220,7 +1220,8 @@
/* Register IRQ - support shared interrupts by passing device ptr */
- ret = request_irq(dev->irq, (void *)dfx_interrupt, SA_SHIRQ, dev->name, dev);
+ ret = request_irq(dev->irq, (void *)dfx_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret) {
printk(KERN_ERR "%s: Requested IRQ %d is busy\n", dev->name, dev->irq);
return ret;
diff -urN linux-2.5.7/drivers/net/depca.c linux/drivers/net/depca.c
--- linux-2.5.7/drivers/net/depca.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/depca.c Thu Mar 21 14:52:58 2002
@@ -780,7 +780,8 @@
depca_dbg_open(dev);
- if (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name, dev)) {
+ if (request_irq(dev->irq, &depca_interrupt, SA_NET_RANDOM,
+ lp->adapter_name, dev)) {
printk("depca_open(): Requested IRQ%d is busy\n",dev->irq);
status = -EAGAIN;
} else {
diff -urN linux-2.5.7/drivers/net/dgrs.c linux/drivers/net/dgrs.c
--- linux-2.5.7/drivers/net/dgrs.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/dgrs.c Thu Mar 21 14:52:58 2002
@@ -1178,7 +1178,8 @@
*/
if (priv->plxreg)
OUTL(dev->base_addr + PLX_LCL2PCI_DOORBELL, 1);
- rc = request_irq(dev->irq, &dgrs_intr, SA_SHIRQ, "RightSwitch", dev);
+ rc = request_irq(dev->irq, &dgrs_intr, SA_SHIRQ | SA_NET_RANDOM,
+ "RightSwitch", dev);
if (rc)
return (rc);
diff -urN linux-2.5.7/drivers/net/dl2k.c linux/drivers/net/dl2k.c
--- linux-2.5.7/drivers/net/dl2k.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/dl2k.c Thu Mar 21 14:52:58 2002
@@ -399,7 +399,8 @@
long ioaddr = dev->base_addr;
int i;
- i = request_irq (dev->irq, &rio_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq (dev->irq, &rio_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i)
return i;
/* DebugCtrl bit 4, 5, 9 must set */
diff -urN linux-2.5.7/drivers/net/donkey linux/drivers/net/donkey
--- linux-2.5.7/drivers/net/donkey Wed Dec 31 19:00:00 1969
+++ linux/drivers/net/donkey Thu Mar 21 14:52:58 2002
@@ -0,0 +1,14 @@
+--- dog Sun Mar 10 13:17:04 2002
+-e100/e100_main.c
+-e1000/e1000_main.c
+-jazzsonic.c
+-pcmcia/ray_cs.c
+-tg3.c
+-tokenring/3c359.c
+-tulip/de4x5.c
+-tulip/xircom_tulip_cb.c
+-tulip/winbond-840.c
+-tulip/de2104x.c
+-tulip/xircom_cb.c
+-tulip/dmfe.c
+-wireless/wavelan.c
diff -urN linux-2.5.7/drivers/net/e100/e100_main.c linux/drivers/net/e100/e100_main.c
--- linux-2.5.7/drivers/net/e100/e100_main.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/e100/e100_main.c Thu Mar 21 14:52:58 2002
@@ -981,7 +981,7 @@
netif_start_queue(dev);
e100_start_ru(bdp);
- if ((rc = request_irq(dev->irq, &e100intr, SA_SHIRQ,
+ if ((rc = request_irq(dev->irq, &e100intr, SA_SHIRQ | SA_NET_RANDOM,
e100_short_driver_name, dev)) != 0) {
del_timer_sync(&bdp->watchdog_timer);
goto err_exit;
diff -urN linux-2.5.7/drivers/net/e1000/e1000_main.c linux/drivers/net/e1000/e1000_main.c
--- linux-2.5.7/drivers/net/e1000/e1000_main.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/e1000/e1000_main.c Thu Mar 21 14:52:58 2002
@@ -236,7 +236,7 @@
{
struct net_device *netdev = adapter->netdev;
- if(request_irq(netdev->irq, &e1000_intr, SA_SHIRQ,
+ if(request_irq(netdev->irq, &e1000_intr, SA_SHIRQ | SA_NET_RANDOM,
netdev->name, netdev))
return -1;
diff -urN linux-2.5.7/drivers/net/e2100.c linux/drivers/net/e2100.c
--- linux-2.5.7/drivers/net/e2100.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/e2100.c Thu Mar 21 14:52:58 2002
@@ -261,7 +261,8 @@
short ioaddr = dev->base_addr;
int retval;
- if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev)))
+ if ((retval = request_irq(dev->irq, ei_interrupt,
+ SA_NET_RANDOM, dev->name, dev)))
return retval;
/* Set the interrupt line and memory base on the hardware. */
diff -urN linux-2.5.7/drivers/net/eepro.c linux/drivers/net/eepro.c
--- linux-2.5.7/drivers/net/eepro.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/eepro.c Thu Mar 21 14:52:58 2002
@@ -962,7 +962,7 @@
return -EAGAIN;
}
- if (request_irq(dev->irq , &eepro_interrupt, 0, dev->name, dev)) {
+ if (request_irq(dev->irq , &eepro_interrupt, SA_NET_RANDOM, dev->name, dev)) {
printk(KERN_ERR "%s: unable to get IRQ %d.\n", dev->name, dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/eepro100.c linux/drivers/net/eepro100.c
--- linux-2.5.7/drivers/net/eepro100.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/eepro100.c Thu Mar 21 14:52:58 2002
@@ -940,7 +940,8 @@
sp->in_interrupt = 0;
/* .. we can safely take handler calls during init. */
- retval = request_irq(dev->irq, &speedo_interrupt, SA_SHIRQ, dev->name, dev);
+ retval = request_irq(dev->irq, &speedo_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (retval) {
MOD_DEC_USE_COUNT;
return retval;
diff -urN linux-2.5.7/drivers/net/eexpress.c linux/drivers/net/eexpress.c
--- linux-2.5.7/drivers/net/eexpress.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/eexpress.c Thu Mar 21 14:52:58 2002
@@ -433,7 +433,8 @@
if (!dev->irq || !irqrmap[dev->irq])
return -ENXIO;
- ret = request_irq(dev->irq,&eexp_irq,0,dev->name,dev);
+ ret = request_irq(dev->irq,&eexp_irq,SA_NET_RANDOM,
+ dev->name,dev);
if (ret) return ret;
request_region(ioaddr, EEXP_IO_EXTENT, "EtherExpress");
diff -urN linux-2.5.7/drivers/net/epic100.c linux/drivers/net/epic100.c
--- linux-2.5.7/drivers/net/epic100.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/epic100.c Thu Mar 21 14:52:58 2002
@@ -664,7 +664,8 @@
/* Soft reset the chip. */
outl(0x4001, ioaddr + GENCTL);
- if ((retval = request_irq(dev->irq, &epic_interrupt, SA_SHIRQ, dev->name, dev)))
+ if ((retval = request_irq(dev->irq, &epic_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev)))
return retval;
epic_init_ring(dev);
diff -urN linux-2.5.7/drivers/net/es3210.c linux/drivers/net/es3210.c
--- linux-2.5.7/drivers/net/es3210.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/es3210.c Thu Mar 21 14:52:58 2002
@@ -212,7 +212,8 @@
printk(" assigning IRQ %d", dev->irq);
}
- if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
+ if (request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ "es3210", dev)) {
printk (" unable to get IRQ %d.\n", dev->irq);
retval = -EAGAIN;
goto out;
diff -urN linux-2.5.7/drivers/net/eth16i.c linux/drivers/net/eth16i.c
--- linux-2.5.7/drivers/net/eth16i.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/eth16i.c Thu Mar 21 14:52:58 2002
@@ -521,7 +521,8 @@
/* Try to obtain interrupt vector */
- if ((retval = request_irq(dev->irq, (void *)ð16i_interrupt, 0, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, (void *)ð16i_interrupt,
+ SA_NET_RANDOM, dev->name, dev))) {
printk(KERN_WARNING "%s: %s at %#3x, but is unusable due conflicting IRQ %d.\n",
dev->name, cardname, ioaddr, dev->irq);
goto out;
diff -urN linux-2.5.7/drivers/net/ewrk3.c linux/drivers/net/ewrk3.c
--- linux-2.5.7/drivers/net/ewrk3.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/ewrk3.c Thu Mar 21 14:52:58 2002
@@ -639,7 +639,8 @@
STOP_EWRK3;
if (!lp->hard_strapped) {
- if (request_irq(dev->irq, (void *) ewrk3_interrupt, 0, "ewrk3", dev)) {
+ if (request_irq(dev->irq, (void *) ewrk3_interrupt,
+ SA_NET_RANDOM, "ewrk3", dev)) {
printk("ewrk3_open(): Requested IRQ%d is busy\n", dev->irq);
status = -EAGAIN;
} else {
diff -urN linux-2.5.7/drivers/net/fc/iph5526.c linux/drivers/net/fc/iph5526.c
--- linux-2.5.7/drivers/net/fc/iph5526.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/fc/iph5526.c Thu Mar 21 14:52:58 2002
@@ -3843,7 +3843,7 @@
int irqval = 0;
/* Found it, get IRQ.
*/
- irqval = request_irq(pci_irq_line, &tachyon_interrupt, pci_irq_line ? SA_SHIRQ : 0, fi->name, host);
+ irqval = request_irq(pci_irq_line, &tachyon_interrupt, pci_irq_line ? SA_SHIRQ : 0 | SA_NET_RANDOM, fi->name, host);
if (irqval) {
printk("iph5526.c : Unable to get IRQ %d (irqval = %d).\n", pci_irq_line, irqval);
scsi_unregister(host);
diff -urN linux-2.5.7/drivers/net/fealnx.c linux/drivers/net/fealnx.c
--- linux-2.5.7/drivers/net/fealnx.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/fealnx.c Thu Mar 21 14:52:58 2002
@@ -880,7 +880,8 @@
writel(0x00000001, ioaddr + BCR); /* Reset */
- if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev))
+ if (request_irq(dev->irq, &intr_handler,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev))
return -EAGAIN;
init_ring(dev);
diff -urN linux-2.5.7/drivers/net/fmv18x.c linux/drivers/net/fmv18x.c
--- linux-2.5.7/drivers/net/fmv18x.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/fmv18x.c Thu Mar 21 14:52:58 2002
@@ -200,7 +200,8 @@
}
/* Snarf the interrupt vector now. */
- retval = request_irq(irq, &net_interrupt, 0, dev->name, dev);
+ retval = request_irq(irq, &net_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (retval) {
printk ("FMV-18x found at %#3x, but it's unusable due to a conflict on"
"IRQ %d.\n", ioaddr, irq);
diff -urN linux-2.5.7/drivers/net/gt96100eth.c linux/drivers/net/gt96100eth.c
--- linux-2.5.7/drivers/net/gt96100eth.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/gt96100eth.c Thu Mar 21 14:52:58 2002
@@ -826,7 +826,8 @@
printk("%s: gt96100_open: dev=%p\n", dev->name, dev);
if ((retval = request_irq(dev->irq, >96100_interrupt,
- SA_SHIRQ, dev->name, dev))) {
+ SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev))) {
printk(KERN_ERR "%s: unable to get IRQ %d\n", dev->name,
dev->irq);
MOD_DEC_USE_COUNT;
diff -urN linux-2.5.7/drivers/net/hamachi.c linux/drivers/net/hamachi.c
--- linux-2.5.7/drivers/net/hamachi.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/hamachi.c Thu Mar 21 14:52:58 2002
@@ -849,7 +849,8 @@
u32 rx_int_var, tx_int_var;
u16 fifo_info;
- i = request_irq(dev->irq, &hamachi_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &hamachi_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i)
return i;
diff -urN linux-2.5.7/drivers/net/hamradio/baycom_ser_fdx.c linux/drivers/net/hamradio/baycom_ser_fdx.c
--- linux-2.5.7/drivers/net/hamradio/baycom_ser_fdx.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/hamradio/baycom_ser_fdx.c Thu Mar 21 14:52:58 2002
@@ -428,7 +428,8 @@
outb(0, FCR(dev->base_addr)); /* disable FIFOs */
outb(0x0d, MCR(dev->base_addr));
outb(0, IER(dev->base_addr));
- if (request_irq(dev->irq, ser12_interrupt, SA_INTERRUPT | SA_SHIRQ,
+ if (request_irq(dev->irq, ser12_interrupt,
+ SA_INTERRUPT | SA_SHIRQ | SA_NET_RANDOM,
"baycom_ser_fdx", dev))
return -EBUSY;
request_region(dev->base_addr, SER12_EXTENT, "baycom_ser_fdx");
diff -urN linux-2.5.7/drivers/net/hamradio/baycom_ser_hdx.c linux/drivers/net/hamradio/baycom_ser_hdx.c
--- linux-2.5.7/drivers/net/hamradio/baycom_ser_hdx.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/hamradio/baycom_ser_hdx.c Thu Mar 21 14:52:58 2002
@@ -485,7 +485,8 @@
outb(0, FCR(dev->base_addr)); /* disable FIFOs */
outb(0x0d, MCR(dev->base_addr));
outb(0, IER(dev->base_addr));
- if (request_irq(dev->irq, ser12_interrupt, SA_INTERRUPT | SA_SHIRQ,
+ if (request_irq(dev->irq, ser12_interrupt,
+ SA_INTERRUPT | SA_SHIRQ | SA_NET_RANDOM,
"baycom_ser12", dev))
return -EBUSY;
request_region(dev->base_addr, SER12_EXTENT, "baycom_ser12");
diff -urN linux-2.5.7/drivers/net/hamradio/dmascc.c linux/drivers/net/hamradio/dmascc.c
--- linux-2.5.7/drivers/net/hamradio/dmascc.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/hamradio/dmascc.c Thu Mar 21 14:52:58 2002
@@ -711,7 +711,7 @@
/* Request IRQ if not already used by other channel */
if (!info->irq_used) {
- if (request_irq(dev->irq, scc_isr, 0, "dmascc", info)) {
+ if (request_irq(dev->irq, scc_isr, SA_NET_RANDOM, "dmascc", info)) {
MOD_DEC_USE_COUNT;
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/hamradio/scc.c linux/drivers/net/hamradio/scc.c
--- linux-2.5.7/drivers/net/hamradio/scc.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/hamradio/scc.c Thu Mar 21 14:52:58 2002
@@ -1770,7 +1770,7 @@
if (!Ivec[hwcfg.irq].used && hwcfg.irq)
{
- if (request_irq(hwcfg.irq, scc_isr, SA_INTERRUPT, "AX.25 SCC", NULL))
+ if (request_irq(hwcfg.irq, scc_isr, SA_INTERRUPT | SA_NET_RANDOM, "AX.25 SCC", NULL))
printk(KERN_WARNING "z8530drv: warning, cannot get IRQ %d\n", hwcfg.irq);
else
Ivec[hwcfg.irq].used = 1;
diff -urN linux-2.5.7/drivers/net/hamradio/soundmodem/sm_sbc.c linux/drivers/net/hamradio/soundmodem/sm_sbc.c
--- linux-2.5.7/drivers/net/hamradio/soundmodem/sm_sbc.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/hamradio/soundmodem/sm_sbc.c Thu Mar 21 14:52:58 2002
@@ -436,7 +436,8 @@
kfree(sm->dma.obuf);
return -EBUSY;
}
- if (request_irq(dev->irq, sbc_interrupt, SA_INTERRUPT,
+ if (request_irq(dev->irq, sbc_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM,
sm->hwdrv->hw_name, dev)) {
free_dma(dev->dma);
kfree(sm->dma.obuf);
@@ -815,7 +816,8 @@
free_dma(dev->dma);
return -EBUSY;
}
- if (request_irq(dev->irq, sbcfdx_interrupt, SA_INTERRUPT,
+ if (request_irq(dev->irq, sbcfdx_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM,
sm->hwdrv->hw_name, dev)) {
kfree(sm->dma.ibuf);
kfree(sm->dma.obuf);
diff -urN linux-2.5.7/drivers/net/hamradio/soundmodem/sm_wss.c linux/drivers/net/hamradio/soundmodem/sm_wss.c
--- linux-2.5.7/drivers/net/hamradio/soundmodem/sm_wss.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/hamradio/soundmodem/sm_wss.c Thu Mar 21 14:52:58 2002
@@ -473,7 +473,8 @@
kfree(sm->dma.obuf);
return -EBUSY;
}
- if (request_irq(dev->irq, wss_interrupt, SA_INTERRUPT,
+ if (request_irq(dev->irq, wss_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM,
sm->hwdrv->hw_name, dev)) {
free_dma(dev->dma);
kfree(sm->dma.obuf);
@@ -827,7 +828,8 @@
free_dma(dev->dma);
return -EBUSY;
}
- if (request_irq(dev->irq, wssfdx_interrupt, SA_INTERRUPT,
+ if (request_irq(dev->irq, wssfdx_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM,
sm->hwdrv->hw_name, dev)) {
kfree(sm->dma.ibuf);
kfree(sm->dma.obuf);
diff -urN linux-2.5.7/drivers/net/hamradio/yam.c linux/drivers/net/hamradio/yam.c
--- linux-2.5.7/drivers/net/hamradio/yam.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/hamradio/yam.c Thu Mar 21 14:52:58 2002
@@ -862,7 +862,7 @@
return -EIO;
}
outb(0, IER(dev->base_addr));
- if (request_irq(dev->irq, yam_interrupt, SA_INTERRUPT | SA_SHIRQ, dev->name, dev)) {
+ if (request_irq(dev->irq, yam_interrupt, SA_INTERRUPT | SA_SHIRQ | SA_NET_RANDOM, dev->name, dev)) {
printk(KERN_ERR "%s: irq %d busy\n", dev->name, dev->irq);
return -EBUSY;
}
diff -urN linux-2.5.7/drivers/net/hp-plus.c linux/drivers/net/hp-plus.c
--- linux-2.5.7/drivers/net/hp-plus.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/hp-plus.c Thu Mar 21 14:52:58 2002
@@ -253,7 +253,8 @@
int option_reg;
int retval;
- if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, ei_interrupt,
+ SA_NET_RANDOM, dev->name, dev))) {
return retval;
}
diff -urN linux-2.5.7/drivers/net/hp.c linux/drivers/net/hp.c
--- linux-2.5.7/drivers/net/hp.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/hp.c Thu Mar 21 14:52:58 2002
@@ -157,8 +157,7 @@
/* Twinkle the interrupt, and check if it's seen. */
outb_p(irqmap[irq] | HP_RUN, ioaddr + HP_CONFIGURE);
outb_p( 0x00 | HP_RUN, ioaddr + HP_CONFIGURE);
- if (irq == probe_irq_off(cookie) /* It's a good IRQ line! */
- && request_irq (irq, ei_interrupt, 0, dev->name, dev) == 0) {
+ if (irq == probe_irq_off(cookie) /* It's a good IRQ line! */ && request_irq (irq, ei_interrupt, SA_NET_RANDOM, dev->name, dev) == 0) {
printk(" selecting IRQ %d.\n", irq);
dev->irq = *irqp;
break;
diff -urN linux-2.5.7/drivers/net/hp100.c linux/drivers/net/hp100.c
--- linux-2.5.7/drivers/net/hp100.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/hp100.c Thu Mar 21 14:52:58 2002
@@ -1150,8 +1150,9 @@
/* New: if bus is PCI or EISA, interrupts might be shared interrupts */
if (request_irq(dev->irq, hp100_interrupt,
- lp->bus == HP100_BUS_PCI || lp->bus ==
- HP100_BUS_EISA ? SA_SHIRQ : SA_INTERRUPT,
+ (lp->bus == HP100_BUS_PCI || lp->bus ==
+ HP100_BUS_EISA ? SA_SHIRQ : SA_INTERRUPT) |
+ SA_NET_RANDOM,
lp->id->name, dev)) {
printk("hp100: %s: unable to get IRQ %d\n", dev->name, dev->irq);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/hydra.c linux/drivers/net/hydra.c
--- linux-2.5.7/drivers/net/hydra.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/hydra.c Thu Mar 21 14:52:58 2002
@@ -129,8 +129,8 @@
dev->irq = IRQ_AMIGA_PORTS;
/* Install the Interrupt handler */
- if (request_irq(IRQ_AMIGA_PORTS, ei_interrupt, SA_SHIRQ, "Hydra Ethernet",
- dev))
+ if (request_irq(IRQ_AMIGA_PORTS, ei_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, "Hydra Ethernet", dev))
return -EAGAIN;
/* Allocate dev->priv and fill in 8390 specific dev fields. */
diff -urN linux-2.5.7/drivers/net/ibmlana.c linux/drivers/net/ibmlana.c
--- linux-2.5.7/drivers/net/ibmlana.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/ibmlana.c Thu Mar 21 14:52:58 2002
@@ -856,7 +856,7 @@
result =
request_irq(priv->realirq, irq_handler,
- SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (result != 0) {
printk("%s: failed to register irq %d\n", dev->name,
dev->irq);
diff -urN linux-2.5.7/drivers/net/ioc3-eth.c linux/drivers/net/ioc3-eth.c
--- linux-2.5.7/drivers/net/ioc3-eth.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/ioc3-eth.c Thu Mar 21 14:52:58 2002
@@ -1314,7 +1314,8 @@
{
struct ioc3_private *ip = dev->priv;
- if (request_irq(dev->irq, ioc3_interrupt, SA_SHIRQ, ioc3_str, dev)) {
+ if (request_irq(dev->irq, ioc3_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, ioc3_str, dev)) {
printk(KERN_ERR "%s: Can't get irq %d\n", dev->name, dev->irq);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/irda/ali-ircc.c linux/drivers/net/irda/ali-ircc.c
--- linux-2.5.7/drivers/net/irda/ali-ircc.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/irda/ali-ircc.c Thu Mar 21 14:52:58 2002
@@ -1357,7 +1357,8 @@
iobase = self->io.fir_base;
/* Request IRQ and install Interrupt Handler */
- if (request_irq(self->io.irq, ali_ircc_interrupt, 0, dev->name, dev))
+ if (request_irq(self->io.irq, ali_ircc_interrupt,
+ SA_NET_RANDOM, dev->name, dev))
{
WARNING("%s, unable to allocate irq=%d\n", driver_name,
self->io.irq);
diff -urN linux-2.5.7/drivers/net/irda/irport.c linux/drivers/net/irda/irport.c
--- linux-2.5.7/drivers/net/irda/irport.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/irda/irport.c Thu Mar 21 14:52:58 2002
@@ -782,8 +782,8 @@
iobase = self->io.sir_base;
- if (request_irq(self->io.irq, self->interrupt, 0, dev->name,
- (void *) dev)) {
+ if (request_irq(self->io.irq, self->interrupt,
+ SA_NET_RANDOM, dev->name, (void *) dev)) {
IRDA_DEBUG(0, __FUNCTION__ "(), unable to allocate irq=%d\n",
self->io.irq);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/irda/nsc-ircc.c linux/drivers/net/irda/nsc-ircc.c
--- linux-2.5.7/drivers/net/irda/nsc-ircc.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/irda/nsc-ircc.c Thu Mar 21 14:52:58 2002
@@ -1848,7 +1848,8 @@
iobase = self->io.fir_base;
- if (request_irq(self->io.irq, nsc_ircc_interrupt, 0, dev->name, dev)) {
+ if (request_irq(self->io.irq, nsc_ircc_interrupt,
+ SA_NET_RANDOM, dev->name, dev)) {
WARNING("%s, unable to allocate irq=%d\n", driver_name,
self->io.irq);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/irda/sa1100_ir.c linux/drivers/net/irda/sa1100_ir.c
--- linux-2.5.7/drivers/net/irda/sa1100_ir.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/irda/sa1100_ir.c Thu Mar 21 14:52:58 2002
@@ -864,7 +864,8 @@
si->speed = 9600;
- err = request_irq(dev->irq, sa1100_irda_irq, 0, dev->name, dev);
+ err = request_irq(dev->irq, sa1100_irda_irq,
+ SA_NET_RANDOM, dev->name, dev);
if (err)
goto err_irq;
diff -urN linux-2.5.7/drivers/net/irda/toshoboe.c linux/drivers/net/irda/toshoboe.c
--- linux-2.5.7/drivers/net/irda/toshoboe.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/irda/toshoboe.c Thu Mar 21 14:52:58 2002
@@ -527,7 +527,8 @@
return 0;
if (request_irq (self->io.irq, toshoboe_interrupt,
- SA_SHIRQ | SA_INTERRUPT, dev->name, (void *) self))
+ SA_SHIRQ | SA_INTERRUPT | SA_NET_RANDOM,
+ dev->name, (void *) self))
{
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/irda/vlsi_ir.c linux/drivers/net/irda/vlsi_ir.c
--- linux-2.5.7/drivers/net/irda/vlsi_ir.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/irda/vlsi_ir.c Thu Mar 21 14:52:58 2002
@@ -833,8 +833,8 @@
outb(IRINTR_INT_MASK, ndev->base_addr+VLSI_PIO_IRINTR);
- if (request_irq(ndev->irq, vlsi_interrupt, SA_SHIRQ,
- drivername, ndev)) {
+ if (request_irq(ndev->irq, vlsi_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, drivername, ndev)) {
printk(KERN_ERR "%s: couldn't get IRQ: %d\n",
__FUNCTION__, ndev->irq);
pci_release_regions(pdev);
diff -urN linux-2.5.7/drivers/net/irda/w83977af_ir.c linux/drivers/net/irda/w83977af_ir.c
--- linux-2.5.7/drivers/net/irda/w83977af_ir.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/irda/w83977af_ir.c Thu Mar 21 14:52:58 2002
@@ -1222,8 +1222,8 @@
iobase = self->io.fir_base;
- if (request_irq(self->io.irq, w83977af_interrupt, 0, dev->name,
- (void *) dev)) {
+ if (request_irq(self->io.irq, w83977af_interrupt,
+ SA_NET_RANDOM, dev->name, (void *) dev)) {
return -EAGAIN;
}
/*
diff -urN linux-2.5.7/drivers/net/isa-skeleton.c linux/drivers/net/isa-skeleton.c
--- linux-2.5.7/drivers/net/isa-skeleton.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/isa-skeleton.c Thu Mar 21 14:52:58 2002
@@ -216,7 +216,8 @@
dev->irq = 9;
{
- int irqval = request_irq(dev->irq, &net_interrupt, 0, cardname, dev);
+ int irqval = request_irq(dev->irq, &net_interrupt,
+ SA_NET_RANDOM, cardname, dev);
if (irqval) {
printk("%s: unable to get IRQ %d (irqval=%d).\n",
dev->name, dev->irq, irqval);
diff -urN linux-2.5.7/drivers/net/lance.c linux/drivers/net/lance.c
--- linux-2.5.7/drivers/net/lance.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/lance.c Thu Mar 21 14:52:58 2002
@@ -672,7 +672,8 @@
int i;
if (dev->irq == 0 ||
- request_irq(dev->irq, &lance_interrupt, 0, lp->name, dev)) {
+ request_irq(dev->irq, &lance_interrupt,
+ SA_NET_RANDOM, lp->name, dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/lasi_82596.c linux/drivers/net/lasi_82596.c
--- linux-2.5.7/drivers/net/lasi_82596.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/lasi_82596.c Thu Mar 21 14:52:58 2002
@@ -999,7 +999,8 @@
MOD_INC_USE_COUNT;
- if (request_irq(dev->irq, &i596_interrupt, 0, "i82596", dev)) {
+ if (request_irq(dev->irq, &i596_interrupt, SA_NET_RANDOM,
+ "i82596", dev)) {
printk("%s: IRQ %d not free\n", dev->name, dev->irq);
goto out;
}
diff -urN linux-2.5.7/drivers/net/lne390.c linux/drivers/net/lne390.c
--- linux-2.5.7/drivers/net/lne390.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/lne390.c Thu Mar 21 14:52:58 2002
@@ -197,7 +197,8 @@
}
printk(" IRQ %d,", dev->irq);
- if ((ret = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev))) {
+ if ((ret = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ dev->name, dev))) {
printk (" unable to get IRQ %d.\n", dev->irq);
kfree(dev->priv);
dev->priv = NULL;
diff -urN linux-2.5.7/drivers/net/lp486e.c linux/drivers/net/lp486e.c
--- linux-2.5.7/drivers/net/lp486e.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/lp486e.c Thu Mar 21 14:52:58 2002
@@ -845,7 +845,8 @@
i596_open(struct net_device *dev) {
int i;
- i = request_irq(dev->irq, &i596_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &i596_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) {
printk("%s: IRQ %d not free\n", dev->name, dev->irq);
return i;
diff -urN linux-2.5.7/drivers/net/mac89x0.c linux/drivers/net/mac89x0.c
--- linux-2.5.7/drivers/net/mac89x0.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/mac89x0.c Thu Mar 21 14:52:58 2002
@@ -329,7 +329,8 @@
writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
/* Grab the interrupt */
- if (request_irq(dev->irq, &net_interrupt, 0, "cs89x0", dev))
+ if (request_irq(dev->irq, &net_interrupt, SA_NET_RANDOM,
+ "cs89x0", dev))
return -EAGAIN;
/* Set up the IRQ - Apparently magic */
diff -urN linux-2.5.7/drivers/net/mace.c linux/drivers/net/mace.c
--- linux-2.5.7/drivers/net/mace.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/mace.c Thu Mar 21 14:52:58 2002
@@ -231,13 +231,14 @@
mace_reset(dev);
- if (request_irq(dev->irq, mace_interrupt, 0, "MACE", dev))
+ if (request_irq(dev->irq, mace_interrupt, SA_NET_RANDOM,
+ "MACE", dev))
printk(KERN_ERR "MACE: can't get irq %d\n", dev->irq);
- if (request_irq(mace->intrs[1].line, mace_txdma_intr, 0, "MACE-txdma",
- dev))
+ if (request_irq(mace->intrs[1].line, mace_txdma_intr,
+ SA_NET_RANDOM, "MACE-txdma", dev))
printk(KERN_ERR "MACE: can't get irq %d\n", mace->intrs[1].line);
- if (request_irq(mace->intrs[2].line, mace_rxdma_intr, 0, "MACE-rxdma",
- dev))
+ if (request_irq(mace->intrs[2].line, mace_rxdma_intr,
+ SA_NET_RANDOM, "MACE-rxdma", dev))
printk(KERN_ERR "MACE: can't get irq %d\n", mace->intrs[2].line);
mp->next_mace = mace_devs;
diff -urN linux-2.5.7/drivers/net/macmace.c linux/drivers/net/macmace.c
--- linux-2.5.7/drivers/net/macmace.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/macmace.c Thu Mar 21 14:52:58 2002
@@ -423,7 +423,8 @@
* The interrupt is fixed and comes off the PSC.
*/
- if (request_irq(dev->irq, mace68k_interrupt, 0, "68K MACE", dev))
+ if (request_irq(dev->irq, mace68k_interrupt,
+ SA_NET_RANDOM, "68K MACE", dev))
{
printk(KERN_ERR "MACE: can't get irq %d\n", dev->irq);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/myri_sbus.c linux/drivers/net/myri_sbus.c
--- linux-2.5.7/drivers/net/myri_sbus.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/myri_sbus.c Thu Mar 21 14:52:58 2002
@@ -1059,7 +1059,8 @@
/* Register interrupt handler now. */
DET(("Requesting MYRIcom IRQ line.\n"));
if (request_irq(dev->irq, &myri_interrupt,
- SA_SHIRQ, "MyriCOM Ethernet", (void *) dev)) {
+ SA_SHIRQ | SA_NET_RANDOM, "MyriCOM Ethernet",
+ (void *) dev)) {
printk("MyriCOM: Cannot register interrupt handler.\n");
goto err;
}
diff -urN linux-2.5.7/drivers/net/natsemi.c linux/drivers/net/natsemi.c
--- linux-2.5.7/drivers/net/natsemi.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/natsemi.c Thu Mar 21 14:52:58 2002
@@ -1025,7 +1025,8 @@
/* Reset the chip, just in case. */
natsemi_reset(dev);
- i = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &intr_handler,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) return i;
if (debug > 1)
diff -urN linux-2.5.7/drivers/net/ne.c linux/drivers/net/ne.c
--- linux-2.5.7/drivers/net/ne.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/ne.c Thu Mar 21 14:52:58 2002
@@ -430,7 +430,8 @@
/* Snarf the interrupt now. There's no point in waiting since we cannot
share and the board will usually be enabled. */
- ret = request_irq(dev->irq, ei_interrupt, 0, name, dev);
+ ret = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ name, dev);
if (ret) {
printk (" unable to get IRQ %d (errno=%d).\n", dev->irq, ret);
goto err_out_kfree;
diff -urN linux-2.5.7/drivers/net/ne2.c linux/drivers/net/ne2.c
--- linux-2.5.7/drivers/net/ne2.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/ne2.c Thu Mar 21 14:52:58 2002
@@ -439,7 +439,8 @@
/* Snarf the interrupt now. There's no point in waiting since we cannot
share and the board will usually be enabled. */
- retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (retval) {
printk (" unable to get IRQ %d (irqval=%d).\n",
dev->irq, retval);
diff -urN linux-2.5.7/drivers/net/ne2k-pci.c linux/drivers/net/ne2k-pci.c
--- linux-2.5.7/drivers/net/ne2k-pci.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/ne2k-pci.c Thu Mar 21 14:52:58 2002
@@ -389,7 +389,8 @@
static int ne2k_pci_open(struct net_device *dev)
{
- int ret = request_irq(dev->irq, ei_interrupt, SA_SHIRQ, dev->name, dev);
+ int ret = request_irq(dev->irq, ei_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret)
return ret;
diff -urN linux-2.5.7/drivers/net/ne3210.c linux/drivers/net/ne3210.c
--- linux-2.5.7/drivers/net/ne3210.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/ne3210.c Thu Mar 21 14:52:58 2002
@@ -189,7 +189,8 @@
}
printk(" IRQ %d,", dev->irq);
- retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, ei_interrupt,
+ SA_NET_RANDOM, dev->name, dev);
if (retval) {
printk (" unable to get IRQ %d.\n", dev->irq);
goto out1;
diff -urN linux-2.5.7/drivers/net/ni5010.c linux/drivers/net/ni5010.c
--- linux-2.5.7/drivers/net/ni5010.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/ni5010.c Thu Mar 21 14:52:58 2002
@@ -354,7 +354,8 @@
PRINTK2((KERN_DEBUG "%s: entering ni5010_open()\n", dev->name));
- if (request_irq(dev->irq, &ni5010_interrupt, 0, boardname, dev)) {
+ if (request_irq(dev->irq, &ni5010_interrupt, SA_NET_RANDOM,
+ boardname, dev)) {
printk(KERN_WARNING "%s: Cannot get irq %#2x\n", dev->name, dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/ni52.c linux/drivers/net/ni52.c
--- linux-2.5.7/drivers/net/ni52.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/ni52.c Thu Mar 21 14:52:58 2002
@@ -264,7 +264,8 @@
startrecv586(dev);
ni_enaint();
- ret = request_irq(dev->irq, &ni52_interrupt,0,dev->name,dev);
+ ret = request_irq(dev->irq, &ni52_interrupt,SA_NET_RANDOM,
+ dev->name,dev);
if (ret)
{
ni_reset586();
diff -urN linux-2.5.7/drivers/net/ni65.c linux/drivers/net/ni65.c
--- linux-2.5.7/drivers/net/ni65.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/ni65.c Thu Mar 21 14:52:58 2002
@@ -269,7 +269,7 @@
static int ni65_open(struct net_device *dev)
{
struct priv *p = (struct priv *) dev->priv;
- int irqval = request_irq(dev->irq, &ni65_interrupt,0,
+ int irqval = request_irq(dev->irq, &ni65_interrupt,SA_NET_RANDOM,
cards[p->cardno].cardname,dev);
if (irqval) {
printk ("%s: unable to get IRQ %d (irqval=%d).\n",
diff -urN linux-2.5.7/drivers/net/ns83820.c linux/drivers/net/ns83820.c
--- linux-2.5.7/drivers/net/ns83820.c Mon Mar 18 15:37:19 2002
+++ linux/drivers/net/ns83820.c Thu Mar 21 14:52:58 2002
@@ -1493,8 +1493,8 @@
setup_ee_mem_bitbanger(&dev->ee, (long)dev->base + MEAR, 3, 2, 1, 0,
0);
- err = request_irq(pci_dev->irq, ns83820_irq, SA_SHIRQ,
- dev->net_dev.name, dev);
+ err = request_irq(pci_dev->irq, ns83820_irq,
+ SA_SHIRQ | SA_NET_RANDOM, dev->net_dev.name, dev);
if (err) {
printk(KERN_INFO "ns83820: unable to register irq %d\n",
pci_dev->irq);
diff -urN linux-2.5.7/drivers/net/oaknet.c linux/drivers/net/oaknet.c
--- linux-2.5.7/drivers/net/oaknet.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/oaknet.c Thu Mar 21 14:52:58 2002
@@ -183,7 +183,8 @@
/* Attempt to get the interrupt line */
ret = -EAGAIN;
- if (request_irq(dev->irq, ei_interrupt, 0, name, dev)) {
+ if (request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ name, dev)) {
printk("%s: unable to request interrupt %d.\n",
dev->name, dev->irq);
goto out_priv;
diff -urN linux-2.5.7/drivers/net/pci-skeleton.c linux/drivers/net/pci-skeleton.c
--- linux-2.5.7/drivers/net/pci-skeleton.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/pci-skeleton.c Thu Mar 21 14:52:58 2002
@@ -1086,7 +1086,8 @@
DPRINTK ("ENTER\n");
- retval = request_irq (dev->irq, netdrv_interrupt, SA_SHIRQ, dev->name, dev);
+ retval = request_irq (dev->irq, netdrv_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (retval) {
DPRINTK ("EXIT, returning %d\n", retval);
return retval;
diff -urN linux-2.5.7/drivers/net/pcmcia/axnet_cs.c linux/drivers/net/pcmcia/axnet_cs.c
--- linux-2.5.7/drivers/net/pcmcia/axnet_cs.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/pcmcia/axnet_cs.c Thu Mar 21 14:52:58 2002
@@ -684,7 +684,8 @@
link->open++;
MOD_INC_USE_COUNT;
- request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
+ request_irq(dev->irq, ei_irq_wrapper,
+ SA_NET_RANDOM | SA_SHIRQ, dev_info, dev);
info->link_status = 0x00;
info->watchdog.function = &ei_watchdog;
diff -urN linux-2.5.7/drivers/net/pcmcia/pcnet_cs.c linux/drivers/net/pcmcia/pcnet_cs.c
--- linux-2.5.7/drivers/net/pcmcia/pcnet_cs.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/pcmcia/pcnet_cs.c Thu Mar 21 14:52:58 2002
@@ -1025,7 +1025,7 @@
MOD_INC_USE_COUNT;
set_misc_reg(dev);
- request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ, dev_info, dev);
+ request_irq(dev->irq, ei_irq_wrapper, SA_SHIRQ | SA_NET_RANDOM, dev_info, dev);
info->phy_id = info->eth_phy;
info->link_status = 0x00;
diff -urN linux-2.5.7/drivers/net/pcnet32.c linux/drivers/net/pcnet32.c
--- linux-2.5.7/drivers/net/pcnet32.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/pcnet32.c Thu Mar 21 14:52:58 2002
@@ -812,7 +812,8 @@
if (dev->irq == 0 ||
request_irq(dev->irq, &pcnet32_interrupt,
- lp->shared_irq ? SA_SHIRQ : 0, lp->name, (void *)dev)) {
+ lp->shared_irq ? SA_SHIRQ : 0 | SA_NET_RANDOM,
+ lp->name, (void *)dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/rcpci45.c linux/drivers/net/rcpci45.c
--- linux-2.5.7/drivers/net/rcpci45.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/rcpci45.c Thu Mar 21 14:52:59 2002
@@ -292,7 +292,8 @@
dprintk ("(rcpci45 driver:) RCopen\n");
/* Request a shared interrupt line. */
- error = request_irq (dev->irq, RCinterrupt, SA_SHIRQ, dev->name, dev);
+ error = request_irq (dev->irq, RCinterrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (error) {
printk (KERN_ERR "(rcpci45 driver:) %s: unable to get IRQ %d\n",
dev->name, dev->irq);
diff -urN linux-2.5.7/drivers/net/rrunner.c linux/drivers/net/rrunner.c
--- linux-2.5.7/drivers/net/rrunner.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/rrunner.c Thu Mar 21 14:52:59 2002
@@ -1229,7 +1229,8 @@
writel(readl(®s->HostCtrl)|HALT_NIC|RR_CLEAR_INT, ®s->HostCtrl);
spin_unlock_irqrestore(&rrpriv->lock, flags);
- if (request_irq(dev->irq, rr_interrupt, SA_SHIRQ, rrpriv->name, dev))
+ if (request_irq(dev->irq, rr_interrupt, SA_SHIRQ | SA_NET_RANDOM,
+ rrpriv->name, dev))
{
printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
dev->name, dev->irq);
diff -urN linux-2.5.7/drivers/net/saa9730.c linux/drivers/net/saa9730.c
--- linux-2.5.7/drivers/net/saa9730.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/saa9730.c Thu Mar 21 14:52:59 2002
@@ -787,8 +787,8 @@
(struct lan_saa9730_private *) dev->priv;
/* Associate IRQ with lan_saa9730_interrupt */
- if (request_irq(dev->irq, &lan_saa9730_interrupt, 0, "SAA9730 Eth",
- dev)) {
+ if (request_irq(dev->irq, &lan_saa9730_interrupt, SA_NET_RANDOM,
+ "SAA9730 Eth", dev)) {
printk("lan_saa9730_open: Can't get irq %d\n", dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/sb1000.c linux/drivers/net/sb1000.c
--- linux-2.5.7/drivers/net/sb1000.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/sb1000.c Thu Mar 21 14:52:59 2002
@@ -992,7 +992,8 @@
lp->rx_frame_id[1] = 0;
lp->rx_frame_id[2] = 0;
lp->rx_frame_id[3] = 0;
- if (request_irq(dev->irq, &sb1000_interrupt, 0, "sb1000", dev)) {
+ if (request_irq(dev->irq, &sb1000_interrupt, SA_NET_RANDOM,
+ "sb1000", dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/seeq8005.c linux/drivers/net/seeq8005.c
--- linux-2.5.7/drivers/net/seeq8005.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/seeq8005.c Thu Mar 21 14:52:59 2002
@@ -347,7 +347,7 @@
struct net_local *lp = (struct net_local *)dev->priv;
{
- int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
+ int irqval = request_irq(dev->irq, &seeq8005_interrupt, SA_NET_RANDOM, "seeq8005", dev);
if (irqval) {
printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
dev->irq, irqval);
diff -urN linux-2.5.7/drivers/net/sgiseeq.c linux/drivers/net/sgiseeq.c
--- linux-2.5.7/drivers/net/sgiseeq.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/sgiseeq.c Thu Mar 21 14:52:59 2002
@@ -451,7 +451,8 @@
int err;
save_flags(flags); cli();
- if (request_irq(dev->irq, sgiseeq_interrupt, 0, sgiseeqstr, (void *) dev)) {
+ if (request_irq(dev->irq, sgiseeq_interrupt, SA_NET_RANDOM,
+ sgiseeqstr, (void *) dev)) {
printk("Seeq8003: Can't get irq %d\n", dev->irq);
restore_flags(flags);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/sis900.c linux/drivers/net/sis900.c
--- linux-2.5.7/drivers/net/sis900.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/sis900.c Thu Mar 21 14:52:59 2002
@@ -865,7 +865,9 @@
pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
sis630_set_eq(net_dev, revision);
- ret = request_irq(net_dev->irq, &sis900_interrupt, SA_SHIRQ, net_dev->name, net_dev);
+ ret = request_irq(net_dev->irq, &sis900_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM,
+ net_dev->name, net_dev);
if (ret)
return ret;
diff -urN linux-2.5.7/drivers/net/sk98lin/skge.c linux/drivers/net/sk98lin/skge.c
--- linux-2.5.7/drivers/net/sk98lin/skge.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/sk98lin/skge.c Thu Mar 21 14:52:59 2002
@@ -909,10 +909,11 @@
spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
if (pAC->GIni.GIMacsFound == 2) {
- Ret = request_irq(dev->irq, SkGeIsr, SA_SHIRQ, pAC->Name, dev);
+ Ret = request_irq(dev->irq, SkGeIsr,
+ SA_SHIRQ | SA_NET_RANDOM, pAC->Name, dev);
} else if (pAC->GIni.GIMacsFound == 1) {
- Ret = request_irq(dev->irq, SkGeIsrOnePort, SA_SHIRQ,
- pAC->Name, dev);
+ Ret = request_irq(dev->irq, SkGeIsrOnePort,
+ SA_SHIRQ | SA_NET_RANDOM, pAC->Name, dev);
} else {
printk(KERN_WARNING "%s: illegal number of ports: %d\n",
dev->name, pAC->GIni.GIMacsFound);
diff -urN linux-2.5.7/drivers/net/sk_g16.c linux/drivers/net/sk_g16.c
--- linux-2.5.7/drivers/net/sk_g16.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/sk_g16.c Thu Mar 21 14:52:59 2002
@@ -947,7 +947,8 @@
do
{
- irqval = request_irq(irqtab[i], &SK_interrupt, 0, "sk_g16", dev);
+ irqval = request_irq(irqtab[i], &SK_interrupt, SA_NET_RANDOM,
+ "sk_g16", dev);
i++;
} while (irqval && irqtab[i]);
@@ -964,7 +965,7 @@
}
else if (dev->irq == 2) /* IRQ2 is always IRQ9 */
{
- if (request_irq(9, &SK_interrupt, 0, "sk_g16", dev))
+ if (request_irq(9, &SK_interrupt, SA_NET_RANDOM, "sk_g16", dev))
{
printk("%s: unable to get IRQ 9\n", dev->name);
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/sk_mca.c linux/drivers/net/sk_mca.c
--- linux-2.5.7/drivers/net/sk_mca.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/sk_mca.c Thu Mar 21 14:52:59 2002
@@ -861,7 +861,7 @@
/* register resources - only necessary for IRQ */
result =
request_irq(priv->realirq, irq_handler,
- SA_SHIRQ | SA_SAMPLE_RANDOM, "sk_mca", dev);
+ SA_SHIRQ | SA_NET_RANDOM, "sk_mca", dev);
if (result != 0) {
printk("%s: failed to register irq %d\n", dev->name,
dev->irq);
diff -urN linux-2.5.7/drivers/net/skfp/skfddi.c linux/drivers/net/skfp/skfddi.c
--- linux-2.5.7/drivers/net/skfp/skfddi.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/skfp/skfddi.c Thu Mar 21 14:52:59 2002
@@ -774,8 +774,8 @@
PRINTK(KERN_INFO "entering skfp_open\n");
/* Register IRQ - support shared interrupts by passing device ptr */
- if (request_irq(dev->irq, (void *) skfp_interrupt, SA_SHIRQ,
- dev->name, dev)) {
+ if (request_irq(dev->irq, (void *) skfp_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev)) {
printk("%s: Requested IRQ %d is busy\n", dev->name, dev->irq);
return (-EAGAIN);
}
diff -urN linux-2.5.7/drivers/net/smc-mca.c linux/drivers/net/smc-mca.c
--- linux-2.5.7/drivers/net/smc-mca.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/smc-mca.c Thu Mar 21 14:52:59 2002
@@ -325,7 +325,8 @@
int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
int retval;
- if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev)))
+ if ((retval = request_irq(dev->irq, ei_interrupt,
+ SA_NET_RANDOM, dev->name, dev)))
return retval;
outb(ULTRA_MEMENB, ioaddr); /* Enable memory */
diff -urN linux-2.5.7/drivers/net/smc-ultra.c linux/drivers/net/smc-ultra.c
--- linux-2.5.7/drivers/net/smc-ultra.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/smc-ultra.c Thu Mar 21 14:52:59 2002
@@ -329,7 +329,8 @@
unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
- retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM,
+ dev->name, dev);
if (retval)
return retval;
diff -urN linux-2.5.7/drivers/net/smc-ultra32.c linux/drivers/net/smc-ultra32.c
--- linux-2.5.7/drivers/net/smc-ultra32.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/smc-ultra32.c Thu Mar 21 14:52:59 2002
@@ -256,6 +256,8 @@
int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : SA_SHIRQ;
int retval;
+ irq_flags |= SA_NET_RANDOM;
+
retval = request_irq(dev->irq, ei_interrupt, irq_flags, dev->name, dev);
if (retval)
return retval;
diff -urN linux-2.5.7/drivers/net/smc9194.c linux/drivers/net/smc9194.c
--- linux-2.5.7/drivers/net/smc9194.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/smc9194.c Thu Mar 21 14:52:59 2002
@@ -988,7 +988,7 @@
ether_setup(dev);
/* Grab the IRQ */
- retval = request_irq(dev->irq, &smc_interrupt, 0, dev->name, dev);
+ retval = request_irq(dev->irq, &smc_interrupt, SA_NET_RANDOM, dev->name, dev);
if (retval) {
printk("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
dev->irq, retval);
diff -urN linux-2.5.7/drivers/net/sonic.c linux/drivers/net/sonic.c
--- linux-2.5.7/drivers/net/sonic.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/sonic.c Thu Mar 21 14:52:59 2002
@@ -42,8 +42,8 @@
* this glue works ok under all situations.
*/
// if (sonic_request_irq(dev->irq, &sonic_interrupt, 0, "sonic", dev)) {
- if (sonic_request_irq(dev->irq, &sonic_interrupt, SA_INTERRUPT,
- "sonic", dev)) {
+ if (sonic_request_irq(dev->irq, &sonic_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM, "sonic", dev)) {
printk("\n%s: unable to get IRQ %d .\n", dev->name, dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/starfire.c linux/drivers/net/starfire.c
--- linux-2.5.7/drivers/net/starfire.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/starfire.c Thu Mar 21 14:52:59 2002
@@ -856,7 +856,8 @@
COMPAT_MOD_INC_USE_COUNT;
- retval = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
+ retval = request_irq(dev->irq, &intr_handler,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (retval) {
COMPAT_MOD_DEC_USE_COUNT;
return retval;
diff -urN linux-2.5.7/drivers/net/stnic.c linux/drivers/net/stnic.c
--- linux-2.5.7/drivers/net/stnic.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/stnic.c Thu Mar 21 14:52:59 2002
@@ -135,7 +135,7 @@
/* Snarf the interrupt now. There's no point in waiting since we cannot
share and the board will usually be enabled. */
- i = request_irq (dev->irq, ei_interrupt, 0, dev->name, dev);
+ i = request_irq(dev->irq, ei_interrupt, SA_NET_RANDOM, dev->name, dev);
if (i) {
printk (KERN_EMERG " unable to get IRQ %d.\n", dev->irq);
unregister_netdev(dev);
diff -urN linux-2.5.7/drivers/net/sun3lance.c linux/drivers/net/sun3lance.c
--- linux-2.5.7/drivers/net/sun3lance.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/sun3lance.c Thu Mar 21 14:52:59 2002
@@ -318,7 +318,8 @@
REGA(CSR0) = CSR0_STOP;
- request_irq(LANCE_IRQ, lance_interrupt, 0, "SUN3 Lance", dev);
+ request_irq(LANCE_IRQ, lance_interrupt, SA_NET_RANDOM,
+ "SUN3 Lance", dev);
dev->irq = (unsigned short)LANCE_IRQ;
diff -urN linux-2.5.7/drivers/net/sunbmac.c linux/drivers/net/sunbmac.c
--- linux-2.5.7/drivers/net/sunbmac.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/sunbmac.c Thu Mar 21 14:52:59 2002
@@ -905,7 +905,8 @@
struct bigmac *bp = (struct bigmac *) dev->priv;
int ret;
- ret = request_irq(dev->irq, &bigmac_interrupt, SA_SHIRQ, dev->name, bp);
+ ret = request_irq(dev->irq, &bigmac_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, bp);
if (ret) {
printk(KERN_ERR "BIGMAC: Can't order irq %d to go.\n", dev->irq);
return ret;
diff -urN linux-2.5.7/drivers/net/sundance.c linux/drivers/net/sundance.c
--- linux-2.5.7/drivers/net/sundance.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/sundance.c Thu Mar 21 14:52:59 2002
@@ -751,7 +751,8 @@
/* Do we need to reset the chip??? */
- i = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &intr_handler,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i)
return i;
diff -urN linux-2.5.7/drivers/net/sungem.c linux/drivers/net/sungem.c
--- linux-2.5.7/drivers/net/sungem.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/sungem.c Thu Mar 21 14:52:59 2002
@@ -2168,7 +2168,7 @@
* on the controller
*/
if (request_irq(gp->pdev->irq, gem_interrupt,
- SA_SHIRQ, dev->name, (void *)dev)) {
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, (void *)dev)) {
printk(KERN_ERR "%s: failed to request irq !\n", gp->dev->name);
#ifdef CONFIG_ALL_PPC
if (!hw_was_up && gp->pdev->vendor == PCI_VENDOR_ID_APPLE)
diff -urN linux-2.5.7/drivers/net/sunhme.c linux/drivers/net/sunhme.c
--- linux-2.5.7/drivers/net/sunhme.c Mon Mar 18 15:37:11 2002
+++ linux/drivers/net/sunhme.c Thu Mar 21 14:52:59 2002
@@ -2207,7 +2207,8 @@
*/
if ((hp->happy_flags & (HFLAG_QUATTRO|HFLAG_PCI)) != HFLAG_QUATTRO) {
if (request_irq(dev->irq, &happy_meal_interrupt,
- SA_SHIRQ, "HAPPY MEAL", (void *)dev)) {
+ SA_SHIRQ | SA_NET_RANDOM,
+ "HAPPY MEAL", (void *)dev)) {
HMD(("EAGAIN\n"));
#ifdef __sparc__
printk(KERN_ERR "happy_meal(SBUS): Can't order irq %s to go.\n",
diff -urN linux-2.5.7/drivers/net/sunlance.c linux/drivers/net/sunlance.c
--- linux-2.5.7/drivers/net/sunlance.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/sunlance.c Thu Mar 21 14:52:59 2002
@@ -926,7 +926,8 @@
STOP_LANCE(lp);
- if (request_irq(dev->irq, &lance_interrupt, SA_SHIRQ,
+ if (request_irq(dev->irq, &lance_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM,
lancestr, (void *) dev)) {
printk(KERN_ERR "Lance: Can't get irq %s\n", __irq_itoa(dev->irq));
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/sunqe.c linux/drivers/net/sunqe.c
--- linux-2.5.7/drivers/net/sunqe.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/sunqe.c Thu Mar 21 14:52:59 2002
@@ -883,7 +883,8 @@
* for it now.
*/
if (request_irq(sdev->irqs[0], &qec_interrupt,
- SA_SHIRQ, "QuadEther", (void *) qecp)) {
+ SA_SHIRQ | SA_NET_RANDOM,
+ "QuadEther", (void *) qecp)) {
printk(KERN_ERR "QuadEther: Can't register QEC master irq handler.\n");
res = EAGAIN;
goto qec_free_devs;
diff -urN linux-2.5.7/drivers/net/tg3.c linux/drivers/net/tg3.c
--- linux-2.5.7/drivers/net/tg3.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/tg3.c Thu Mar 21 14:52:59 2002
@@ -3797,10 +3797,10 @@
if (tp->tg3_flags & TG3_FLAG_TAGGED_IRQ_STATUS)
err = request_irq(dev->irq, tg3_interrupt_tagged,
- SA_SHIRQ, dev->name, dev);
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
else
err = request_irq(dev->irq, tg3_interrupt,
- SA_SHIRQ, dev->name, dev);
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (err) {
tg3_free_consistent(tp);
diff -urN linux-2.5.7/drivers/net/tlan.c linux/drivers/net/tlan.c
--- linux-2.5.7/drivers/net/tlan.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/tlan.c Thu Mar 21 14:52:59 2002
@@ -872,7 +872,8 @@
int err;
priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
- err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, TLanSignature, dev );
+ err = request_irq( dev->irq, TLan_HandleInterrupt,
+ SA_SHIRQ | SA_NET_RANDOM, TLanSignature, dev );
if ( err ) {
printk(KERN_ERR "TLAN: Cannot open %s because IRQ %d is already in use.\n", dev->name, dev->irq );
diff -urN linux-2.5.7/drivers/net/tokenring/3c359.c linux/drivers/net/tokenring/3c359.c
--- linux-2.5.7/drivers/net/tokenring/3c359.c Mon Mar 18 15:37:19 2002
+++ linux/drivers/net/tokenring/3c359.c Thu Mar 21 14:52:59 2002
@@ -578,7 +578,8 @@
u16 switchsettings, switchsettings_eeprom ;
- if(request_irq(dev->irq, &xl_interrupt, SA_SHIRQ , "3c359", dev)) {
+ if(request_irq(dev->irq, &xl_interrupt, SA_SHIRQ | SA_NET_RANDOM,
+ "3c359", dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/tokenring/abyss.c linux/drivers/net/tokenring/abyss.c
--- linux-2.5.7/drivers/net/tokenring/abyss.c Mon Mar 18 15:37:09 2002
+++ linux/drivers/net/tokenring/abyss.c Thu Mar 21 14:52:59 2002
@@ -123,8 +123,8 @@
goto err_out_trdev;
}
- ret = request_irq(pdev->irq, tms380tr_interrupt, SA_SHIRQ,
- dev->name, dev);
+ ret = request_irq(pdev->irq, tms380tr_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret)
goto err_out_region;
diff -urN linux-2.5.7/drivers/net/tokenring/ibmtr.c linux/drivers/net/tokenring/ibmtr.c
--- linux-2.5.7/drivers/net/tokenring/ibmtr.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/tokenring/ibmtr.c Thu Mar 21 14:52:59 2002
@@ -671,7 +671,8 @@
/* The PCMCIA has already got the interrupt line and the io port,
so no chance of anybody else getting it - MLP */
- if (request_irq(dev->irq = irq, &tok_interrupt, 0, "ibmtr", dev) != 0) {
+ if (request_irq(dev->irq = irq, &tok_interrupt,
+ SA_NET_RANDOM, "ibmtr", dev) != 0) {
DPRINTK("Could not grab irq %d. Halting Token Ring driver.\n",
irq);
iounmap(t_mmio);
diff -urN linux-2.5.7/drivers/net/tokenring/lanstreamer.c linux/drivers/net/tokenring/lanstreamer.c
--- linux-2.5.7/drivers/net/tokenring/lanstreamer.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/tokenring/lanstreamer.c Thu Mar 21 14:52:59 2002
@@ -582,7 +582,8 @@
rc=streamer_reset(dev);
}
- if (request_irq(dev->irq, &streamer_interrupt, SA_SHIRQ, "lanstreamer", dev)) {
+ if (request_irq(dev->irq, &streamer_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, "lanstreamer", dev)) {
return -EAGAIN;
}
#if STREAMER_DEBUG
diff -urN linux-2.5.7/drivers/net/tokenring/madgemc.c linux/drivers/net/tokenring/madgemc.c
--- linux-2.5.7/drivers/net/tokenring/madgemc.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/tokenring/madgemc.c Thu Mar 21 14:52:59 2002
@@ -331,8 +331,9 @@
*/
outb(0, dev->base_addr + MC_CONTROL_REG0); /* sanity */
madgemc_setsifsel(dev, 1);
- if(request_irq(dev->irq, madgemc_interrupt, SA_SHIRQ,
- "madgemc", dev))
+ if(request_irq(dev->irq, madgemc_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM,
+ "madgemc", dev))
goto getout;
madgemc_chipset_init(dev); /* enables interrupts! */
diff -urN linux-2.5.7/drivers/net/tokenring/olympic.c linux/drivers/net/tokenring/olympic.c
--- linux-2.5.7/drivers/net/tokenring/olympic.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/tokenring/olympic.c Thu Mar 21 14:52:59 2002
@@ -405,7 +405,8 @@
DECLARE_WAITQUEUE(wait,current) ;
- if(request_irq(dev->irq, &olympic_interrupt, SA_SHIRQ , "olympic", dev)) {
+ if(request_irq(dev->irq, &olympic_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, "olympic", dev)) {
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/tokenring/smctr.c linux/drivers/net/tokenring/smctr.c
--- linux-2.5.7/drivers/net/tokenring/smctr.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/tokenring/smctr.c Thu Mar 21 14:52:59 2002
@@ -544,7 +544,8 @@
dev->irq = 15;
break;
}
- if(request_irq(dev->irq, smctr_interrupt, SA_SHIRQ, smctr_name, dev))
+ if(request_irq(dev->irq, smctr_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, smctr_name, dev))
return (-ENODEV);
/* Get RAM base */
diff -urN linux-2.5.7/drivers/net/tokenring/tmsisa.c linux/drivers/net/tokenring/tmsisa.c
--- linux-2.5.7/drivers/net/tokenring/tmsisa.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/tokenring/tmsisa.c Thu Mar 21 14:52:59 2002
@@ -184,8 +184,8 @@
for(j = 0; irqlist[j] != 0; j++)
{
dev->irq = irqlist[j];
- if (!request_irq(dev->irq, tms380tr_interrupt, 0,
- isa_cardname, dev))
+ if (!request_irq(dev->irq, tms380tr_interrupt,
+ SA_NET_RANDOM, isa_cardname, dev))
break;
}
diff -urN linux-2.5.7/drivers/net/tokenring/tmspci.c linux/drivers/net/tokenring/tmspci.c
--- linux-2.5.7/drivers/net/tokenring/tmspci.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/tokenring/tmspci.c Thu Mar 21 14:52:59 2002
@@ -123,8 +123,8 @@
goto err_out_trdev;
}
- ret = request_irq(pdev->irq, tms380tr_interrupt, SA_SHIRQ,
- dev->name, dev);
+ ret = request_irq(pdev->irq, tms380tr_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (ret)
goto err_out_region;
diff -urN linux-2.5.7/drivers/net/tulip/de4x5.c linux/drivers/net/tulip/de4x5.c
--- linux-2.5.7/drivers/net/tulip/de4x5.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/tulip/de4x5.c Thu Mar 21 14:52:59 2002
@@ -1403,11 +1403,12 @@
lp->state = OPEN;
de4x5_dbg_open(dev);
- if (request_irq(dev->irq, (void *)de4x5_interrupt, SA_SHIRQ,
+ if (request_irq(dev->irq, (void *)de4x5_interrupt, SA_SHIRQ | SA_NET_RANDOM,
lp->adapter_name, dev)) {
printk("de4x5_open(): Requested IRQ%d is busy - attemping FAST/SHARE...", dev->irq);
- if (request_irq(dev->irq, de4x5_interrupt, SA_INTERRUPT | SA_SHIRQ,
- lp->adapter_name, dev)) {
+ if (request_irq(dev->irq, de4x5_interrupt,
+ SA_INTERRUPT | SA_SHIRQ | SA_NET_RANDOM,
+ lp->adapter_name, dev)) {
printk("\n Cannot get IRQ- reconfigure your hardware.\n");
disable_ast(dev);
de4x5_free_rx_buffs(dev);
diff -urN linux-2.5.7/drivers/net/tulip/dmfe.c linux/drivers/net/tulip/dmfe.c
--- linux-2.5.7/drivers/net/tulip/dmfe.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/tulip/dmfe.c Thu Mar 21 14:52:59 2002
@@ -496,7 +496,8 @@
DMFE_DBUG(0, "dmfe_open", 0);
- ret = request_irq(dev->irq, &dmfe_interrupt, SA_SHIRQ, dev->name, dev);
+ ret = request_irq(dev->irq, &dmfe_interrupt, SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev);
if (ret)
return ret;
diff -urN linux-2.5.7/drivers/net/tulip/tulip_core.c linux/drivers/net/tulip/tulip_core.c
--- linux-2.5.7/drivers/net/tulip/tulip_core.c Mon Mar 18 15:37:16 2002
+++ linux/drivers/net/tulip/tulip_core.c Thu Mar 21 14:52:59 2002
@@ -481,7 +481,9 @@
int retval;
MOD_INC_USE_COUNT;
- if ((retval = request_irq(dev->irq, &tulip_interrupt, SA_SHIRQ, dev->name, dev))) {
+ if ((retval = request_irq(dev->irq, &tulip_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev))) {
MOD_DEC_USE_COUNT;
return retval;
}
diff -urN linux-2.5.7/drivers/net/tulip/winbond-840.c linux/drivers/net/tulip/winbond-840.c
--- linux-2.5.7/drivers/net/tulip/winbond-840.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/tulip/winbond-840.c Thu Mar 21 14:52:59 2002
@@ -691,7 +691,8 @@
writel(0x00000001, ioaddr + PCIBusCfg); /* Reset */
netif_device_detach(dev);
- i = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &intr_handler, SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev);
if (i)
goto out_err;
diff -urN linux-2.5.7/drivers/net/tulip/xircom_cb.c linux/drivers/net/tulip/xircom_cb.c
--- linux-2.5.7/drivers/net/tulip/xircom_cb.c Mon Mar 18 15:37:18 2002
+++ linux/drivers/net/tulip/xircom_cb.c Thu Mar 21 14:52:59 2002
@@ -430,7 +430,8 @@
int retval;
enter("xircom_open");
printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
- retval = request_irq(dev->irq, &xircom_interrupt, SA_SHIRQ, dev->name, dev);
+ retval = request_irq(dev->irq, &xircom_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (retval) {
leave("xircom_open - No IRQ");
return retval;
diff -urN linux-2.5.7/drivers/net/tulip/xircom_tulip_cb.c linux/drivers/net/tulip/xircom_tulip_cb.c
--- linux-2.5.7/drivers/net/tulip/xircom_tulip_cb.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/tulip/xircom_tulip_cb.c Thu Mar 21 14:52:59 2002
@@ -798,7 +798,8 @@
{
struct xircom_private *tp = dev->priv;
- if (request_irq(dev->irq, &xircom_interrupt, SA_SHIRQ, dev->name, dev))
+ if (request_irq(dev->irq, &xircom_interrupt, SA_SHIRQ | SA_NET_RANDOM,
+ dev->name, dev))
return -EAGAIN;
xircom_init_ring(dev);
diff -urN linux-2.5.7/drivers/net/via-rhine.c linux/drivers/net/via-rhine.c
--- linux-2.5.7/drivers/net/via-rhine.c Mon Mar 18 15:37:14 2002
+++ linux/drivers/net/via-rhine.c Thu Mar 21 14:52:59 2002
@@ -1064,7 +1064,8 @@
/* Reset the chip. */
writew(CmdReset, ioaddr + ChipCmd);
- i = request_irq(np->pdev->irq, &via_rhine_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(np->pdev->irq, &via_rhine_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i)
return i;
diff -urN linux-2.5.7/drivers/net/wan/c101.c linux/drivers/net/wan/c101.c
--- linux-2.5.7/drivers/net/wan/c101.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/wan/c101.c Thu Mar 21 14:52:59 2002
@@ -254,7 +254,7 @@
}
memset(card, 0, sizeof(card_t));
- if (request_irq(irq, sca_intr, 0, devname, card)) {
+ if (request_irq(irq, sca_intr, SA_NET_RANDOM, devname, card)) {
printk(KERN_ERR "c101: could not allocate IRQ\n");
c101_destroy_card(card);
return(-EBUSY);
diff -urN linux-2.5.7/drivers/net/wan/comx-hw-comx.c linux/drivers/net/wan/comx-hw-comx.c
--- linux-2.5.7/drivers/net/wan/comx-hw-comx.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/wan/comx-hw-comx.c Thu Mar 21 14:52:59 2002
@@ -469,8 +469,8 @@
if (check_region(dev->base_addr, hw->io_extent)) {
return -EAGAIN;
}
- if (request_irq(dev->irq, COMX_interrupt, 0, dev->name,
- (void *)dev)) {
+ if (request_irq(dev->irq, COMX_interrupt, SA_NET_RANDOM,
+ dev->name, (void *)dev)) {
printk(KERN_ERR "comx-hw-comx: unable to obtain irq %d\n", dev->irq);
return -EAGAIN;
}
diff -urN linux-2.5.7/drivers/net/wan/comx-hw-locomx.c linux/drivers/net/wan/comx-hw-locomx.c
--- linux-2.5.7/drivers/net/wan/comx-hw-locomx.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/wan/comx-hw-locomx.c Thu Mar 21 14:52:59 2002
@@ -172,8 +172,8 @@
hw->board.chanA.irqs=&z8530_nop;
hw->board.chanB.irqs=&z8530_nop;
- if(request_irq(dev->irq, z8530_interrupt, SA_INTERRUPT,
- dev->name, &hw->board)) {
+ if(request_irq(dev->irq, z8530_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM, dev->name, &hw->board)) {
printk(KERN_ERR "%s: unable to obtain irq %d\n", dev->name,
dev->irq);
ret=-EAGAIN;
diff -urN linux-2.5.7/drivers/net/wan/comx-hw-mixcom.c linux/drivers/net/wan/comx-hw-mixcom.c
--- linux-2.5.7/drivers/net/wan/comx-hw-mixcom.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/wan/comx-hw-mixcom.c Thu Mar 21 14:52:59 2002
@@ -518,8 +518,8 @@
}
if(hw->channel==0 && !(ch->init_status & IRQ_ALLOCATED)) {
- if (request_irq(dev->irq, MIXCOM_interrupt, 0,
- dev->name, (void *)dev)) {
+ if (request_irq(dev->irq, MIXCOM_interrupt,
+ SA_NET_RANDOM, dev->name, (void *)dev)) {
printk(KERN_ERR "MIXCOM: unable to obtain irq %d\n", dev->irq);
ret = -EAGAIN;
goto err_release_region;
diff -urN linux-2.5.7/drivers/net/wan/cosa.c linux/drivers/net/wan/cosa.c
--- linux-2.5.7/drivers/net/wan/cosa.c Mon Mar 18 15:37:03 2002
+++ linux/drivers/net/wan/cosa.c Thu Mar 21 14:52:59 2002
@@ -548,7 +548,8 @@
cosa->nchannels = 2; /* FIXME: how to determine this? */
request_region(base, is_8bit(cosa)?2:4, cosa->type);
- if (request_irq(cosa->irq, cosa_interrupt, 0, cosa->type, cosa))
+ if (request_irq(cosa->irq, cosa_interrupt, SA_NET_RANDOM,
+ cosa->type, cosa))
goto bad1;
if (request_dma(cosa->dma, cosa->type)) {
free_irq(cosa->irq, cosa);
diff -urN linux-2.5.7/drivers/net/wan/cycx_main.c linux/drivers/net/wan/cycx_main.c
--- linux-2.5.7/drivers/net/wan/cycx_main.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/wan/cycx_main.c Thu Mar 21 14:52:59 2002
@@ -214,7 +214,8 @@
/* Allocate IRQ */
irq = conf->irq == 2 ? 9 : conf->irq; /* IRQ2 -> IRQ9 */
- if (request_irq(irq, cycx_isr, 0, wandev->name, card)) {
+ if (request_irq(irq, cycx_isr, SA_NET_RANDOM,
+ wandev->name, card)) {
printk(KERN_ERR "%s: can't reserve IRQ %d!\n",
wandev->name, irq);
goto out;
diff -urN linux-2.5.7/drivers/net/wan/dscc4.c linux/drivers/net/wan/dscc4.c
--- linux-2.5.7/drivers/net/wan/dscc4.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/wan/dscc4.c Thu Mar 21 14:52:59 2002
@@ -586,7 +586,8 @@
priv = (struct dscc4_pci_priv *)pci_get_drvdata(pdev);
- if (request_irq(pdev->irq, &dscc4_irq, SA_SHIRQ, DRV_NAME, priv->root)){
+ if (request_irq(pdev->irq, &dscc4_irq, SA_SHIRQ | SA_NET_RANDOM,
+ DRV_NAME, priv->root)){
printk(KERN_WARNING "%s: IRQ %d busy\n", DRV_NAME, pdev->irq);
goto err_out_iounmap;
}
diff -urN linux-2.5.7/drivers/net/wan/farsync.c linux/drivers/net/wan/farsync.c
--- linux-2.5.7/drivers/net/wan/farsync.c Mon Mar 18 15:37:07 2002
+++ linux/drivers/net/wan/farsync.c Thu Mar 21 14:52:59 2002
@@ -1597,7 +1597,8 @@
card->state = FST_RESET;
/* Register the interrupt handler */
- if ( request_irq ( card->irq, fst_intr, SA_SHIRQ, FST_DEV_NAME, card ))
+ if ( request_irq ( card->irq, fst_intr, SA_SHIRQ | SA_NET_RANDOM,
+ FST_DEV_NAME, card ))
{
printk_err ("Unable to register interrupt %d\n", card->irq );
diff -urN linux-2.5.7/drivers/net/wan/hostess_sv11.c linux/drivers/net/wan/hostess_sv11.c
--- linux-2.5.7/drivers/net/wan/hostess_sv11.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/wan/hostess_sv11.c Thu Mar 21 14:52:59 2002
@@ -254,7 +254,9 @@
/* We want a fast IRQ for this device. Actually we'd like an even faster
IRQ ;) - This is one driver RtLinux is made for */
- if(request_irq(irq, &z8530_interrupt, SA_INTERRUPT, "Hostess SV/11", dev)<0)
+ if(request_irq(irq, &z8530_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM,
+ "Hostess SV/11", dev)<0)
{
printk(KERN_WARNING "hostess: IRQ %d already in use.\n", irq);
goto fail1;
diff -urN linux-2.5.7/drivers/net/wan/lmc/lmc_main.c linux/drivers/net/wan/lmc/lmc_main.c
--- linux-2.5.7/drivers/net/wan/lmc/lmc_main.c Mon Mar 18 15:37:10 2002
+++ linux/drivers/net/wan/lmc/lmc_main.c Thu Mar 21 14:52:59 2002
@@ -1177,7 +1177,8 @@
lmc_softreset (sc);
/* Since we have to use PCI bus, this should work on x86,alpha,ppc */
- if (request_irq (dev->irq, &lmc_interrupt, SA_SHIRQ, dev->name, dev)){
+ if (request_irq (dev->irq, &lmc_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev)){
printk(KERN_WARNING "%s: could not get irq: %d\n", dev->name, dev->irq);
lmc_trace(dev, "lmc_open irq failed out");
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/wan/n2.c linux/drivers/net/wan/n2.c
--- linux-2.5.7/drivers/net/wan/n2.c Mon Mar 18 15:37:08 2002
+++ linux/drivers/net/wan/n2.c Thu Mar 21 14:52:59 2002
@@ -401,7 +401,7 @@
}
card->io = io;
- if (request_irq(irq, &sca_intr, 0, devname, card)) {
+ if (request_irq(irq, &sca_intr, SA_NET_RANDOM, devname, card)) {
printk(KERN_ERR "n2: could not allocate IRQ\n");
n2_destroy_card(card);
return(-EBUSY);
diff -urN linux-2.5.7/drivers/net/wan/sbni.c linux/drivers/net/wan/sbni.c
--- linux-2.5.7/drivers/net/wan/sbni.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/wan/sbni.c Thu Mar 21 14:52:59 2002
@@ -1168,7 +1168,8 @@
}
}
- if( request_irq(dev->irq, sbni_interrupt, SA_SHIRQ, dev->name, dev) ) {
+ if( request_irq(dev->irq, sbni_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev) ) {
printk( KERN_ERR "%s: unable to get IRQ %d.\n",
dev->name, dev->irq );
return -EAGAIN;
diff -urN linux-2.5.7/drivers/net/wan/sdla.c linux/drivers/net/wan/sdla.c
--- linux-2.5.7/drivers/net/wan/sdla.c Mon Mar 18 15:37:15 2002
+++ linux/drivers/net/wan/sdla.c Thu Mar 21 14:52:59 2002
@@ -1469,7 +1469,8 @@
}
dev->irq = map->irq;
- if (request_irq(dev->irq, &sdla_isr, 0, dev->name, dev))
+ if (request_irq(dev->irq, &sdla_isr, SA_NET_RANDOM,
+ dev->name, dev))
return(-EAGAIN);
if (flp->type == SDLA_S507)
diff -urN linux-2.5.7/drivers/net/wan/sdlamain.c linux/drivers/net/wan/sdlamain.c
--- linux-2.5.7/drivers/net/wan/sdlamain.c Mon Mar 18 15:37:17 2002
+++ linux/drivers/net/wan/sdlamain.c Thu Mar 21 14:52:59 2002
@@ -495,8 +495,7 @@
/* when using the S514 PCI adapter */
if(request_irq(irq, sdla_isr,
- (card->hw.type == SDLA_S514) ? SA_SHIRQ : 0,
- wandev->name, card)){
+ (card->hw.type == SDLA_S514) ? SA_SHIRQ : 0 | SA_NET_RANDOM, wandev->name, card)){
printk(KERN_INFO "%s: Can't reserve IRQ %d!\n", wandev->name, irq);
return -EINVAL;
diff -urN linux-2.5.7/drivers/net/wan/sealevel.c linux/drivers/net/wan/sealevel.c
--- linux-2.5.7/drivers/net/wan/sealevel.c Mon Mar 18 15:37:05 2002
+++ linux/drivers/net/wan/sealevel.c Thu Mar 21 14:52:59 2002
@@ -281,7 +281,8 @@
/* We want a fast IRQ for this device. Actually we'd like an even faster
IRQ ;) - This is one driver RtLinux is made for */
- if(request_irq(irq, &z8530_interrupt, SA_INTERRUPT, "SeaLevel", dev)<0)
+ if(request_irq(irq, &z8530_interrupt,
+ SA_INTERRUPT | SA_NET_RANDOM, "SeaLevel", dev)<0)
{
printk(KERN_WARNING "sealevel: IRQ %d already in use.\n", irq);
goto fail1_1;
diff -urN linux-2.5.7/drivers/net/wd.c linux/drivers/net/wd.c
--- linux-2.5.7/drivers/net/wd.c Mon Mar 18 15:37:04 2002
+++ linux/drivers/net/wd.c Thu Mar 21 14:52:59 2002
@@ -266,7 +266,8 @@
/* Snarf the interrupt now. There's no point in waiting since we cannot
share and the board will usually be enabled. */
- i = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
+ i = request_irq(dev->irq, ei_interrupt,
+ SA_NET_RANDOM, dev->name, dev);
if (i) {
printk (" unable to get IRQ %d.\n", dev->irq);
kfree(dev->priv);
diff -urN linux-2.5.7/drivers/net/wireless/airo.c linux/drivers/net/wireless/airo.c
--- linux-2.5.7/drivers/net/wireless/airo.c Mon Mar 18 15:37:06 2002
+++ linux/drivers/net/wireless/airo.c Thu Mar 21 14:52:59 2002
@@ -1190,7 +1190,8 @@
dev->irq = irq;
dev->base_addr = port;
- rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
+ rc = request_irq( dev->irq, airo_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev );
if (rc) {
printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
goto err_out_unlink;
diff -urN linux-2.5.7/drivers/net/wireless/airport.c linux/drivers/net/wireless/airport.c
--- linux-2.5.7/drivers/net/wireless/airport.c Mon Mar 18 15:37:13 2002
+++ linux/drivers/net/wireless/airport.c Thu Mar 21 14:52:59 2002
@@ -241,7 +241,8 @@
/* Reset it before we get the interrupt */
hermes_reset(hw);
- if (request_irq(ndev->irq, dldwd_interrupt, 0, "Airport", (void *)priv)) {
+ if (request_irq(ndev->irq, dldwd_interrupt, SA_NET_RANDOM,
+ "Airport", (void *)priv)) {
printk(KERN_ERR "airport: Couldn't get IRQ %d\n", ndev->irq);
goto failed;
}
diff -urN linux-2.5.7/drivers/net/wireless/orinoco_plx.c linux/drivers/net/wireless/orinoco_plx.c
--- linux-2.5.7/drivers/net/wireless/orinoco_plx.c Mon Mar 18 15:37:19 2002
+++ linux/drivers/net/wireless/orinoco_plx.c Thu Mar 21 14:52:59 2002
@@ -237,8 +237,8 @@
hermes_struct_init(&(priv->hw), dev->base_addr); /* XXX */
dev->name[0] = '\0'; /* name defaults to ethX */
register_netdev(dev);
- request_irq(pdev->irq, orinoco_plx_interrupt, SA_SHIRQ, dev->name,
- dev);
+ request_irq(pdev->irq, orinoco_plx_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (dldwd_proc_dev_init(priv) != 0) {
printk(KERN_ERR "%s: Failed to create /proc node\n", dev->name);
return -EIO;
diff -urN linux-2.5.7/drivers/net/wireless/wavelan.c linux/drivers/net/wireless/wavelan.c
--- linux-2.5.7/drivers/net/wireless/wavelan.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/wireless/wavelan.c Thu Mar 21 14:52:59 2002
@@ -4076,7 +4076,8 @@
return -ENXIO;
}
- if (request_irq(dev->irq, &wavelan_interrupt, 0, "WaveLAN", dev) != 0)
+ if (request_irq(dev->irq, &wavelan_interrupt, SA_NET_RANDOM,
+ "WaveLAN", dev) != 0)
{
#ifdef DEBUG_CONFIG_ERROR
printk(KERN_WARNING "%s: wavelan_open(): invalid IRQ\n",
diff -urN linux-2.5.7/drivers/net/yellowfin.c linux/drivers/net/yellowfin.c
--- linux-2.5.7/drivers/net/yellowfin.c Mon Mar 18 15:37:12 2002
+++ linux/drivers/net/yellowfin.c Thu Mar 21 14:52:59 2002
@@ -631,7 +631,8 @@
/* Reset the chip. */
outl(0x80000000, ioaddr + DMACtrl);
- i = request_irq(dev->irq, &yellowfin_interrupt, SA_SHIRQ, dev->name, dev);
+ i = request_irq(dev->irq, &yellowfin_interrupt,
+ SA_SHIRQ | SA_NET_RANDOM, dev->name, dev);
if (i) return i;
if (yellowfin_debug > 1)
diff -urN linux-2.5.7/drivers/net/znet.c linux/drivers/net/znet.c
--- linux-2.5.7/drivers/net/znet.c Mon Mar 18 15:37:02 2002
+++ linux/drivers/net/znet.c Thu Mar 21 14:52:59 2002
@@ -252,7 +252,8 @@
zn.lock = SPIN_LOCK_UNLOCKED;
/* These should never fail. You can't add devices to a sealed box! */
- if (request_irq(dev->irq, &znet_interrupt, 0, "ZNet", dev)
+ if (request_irq(dev->irq, &znet_interrupt, SA_NET_RANDOM,
+ "ZNet", dev)
|| request_dma(zn.rx_dma,"ZNet rx")
|| request_dma(zn.tx_dma,"ZNet tx")) {
printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);