diff -urN linux-2.5.6/drivers/net/3c501.c linux/drivers/net/3c501.c --- linux-2.5.6/drivers/net/3c501.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/3c501.c Sun Mar 10 13:15:17 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.6/drivers/net/3c503.c linux/drivers/net/3c503.c --- linux-2.5.6/drivers/net/3c503.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/3c503.c Sun Mar 10 13:15:17 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.6/drivers/net/3c505.c linux/drivers/net/3c505.c --- linux-2.5.6/drivers/net/3c505.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/3c505.c Sun Mar 10 13:15:17 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.6/drivers/net/3c507.c linux/drivers/net/3c507.c --- linux-2.5.6/drivers/net/3c507.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/3c507.c Sun Mar 10 13:15:17 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.6/drivers/net/3c509.c linux/drivers/net/3c509.c --- linux-2.5.6/drivers/net/3c509.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/3c509.c Sun Mar 10 13:15:17 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.6/drivers/net/3c515.c linux/drivers/net/3c515.c --- linux-2.5.6/drivers/net/3c515.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/3c515.c Sun Mar 10 13:15:17 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.6/drivers/net/3c523.c linux/drivers/net/3c523.c --- linux-2.5.6/drivers/net/3c523.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/3c523.c Sun Mar 10 13:15:17 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.6/drivers/net/3c527.c linux/drivers/net/3c527.c --- linux-2.5.6/drivers/net/3c527.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/3c527.c Sun Mar 10 13:15:17 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.6/drivers/net/3c59x.c linux/drivers/net/3c59x.c --- linux-2.5.6/drivers/net/3c59x.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/3c59x.c Sun Mar 10 13:15:17 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.6/drivers/net/7990.c linux/drivers/net/7990.c --- linux-2.5.6/drivers/net/7990.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/7990.c Sun Mar 10 13:15:17 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.6/drivers/net/8139cp.c linux/drivers/net/8139cp.c --- linux-2.5.6/drivers/net/8139cp.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/8139cp.c Sun Mar 10 13:15:17 2002 @@ -1033,7 +1033,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.6/drivers/net/8139too.c linux/drivers/net/8139too.c --- linux-2.5.6/drivers/net/8139too.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/8139too.c Sun Mar 10 13:15:17 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.6/drivers/net/82596.c linux/drivers/net/82596.c --- linux-2.5.6/drivers/net/82596.c Thu Mar 7 21:18:15 2002 +++ linux/drivers/net/82596.c Sun Mar 10 13:15:17 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.6/drivers/net/\ linux/drivers/net/\ --- linux-2.5.6/drivers/net/\ Wed Dec 31 19:00:00 1969 +++ linux/drivers/net/\ Sun Mar 10 13:25:54 2002 @@ -0,0 +1,2241 @@ +/* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */ +/* + Copyright 2001 Jeff Garzik + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* 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 "); +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.6/drivers/net/a2065.c linux/drivers/net/a2065.c --- linux-2.5.6/drivers/net/a2065.c Thu Mar 7 21:18:54 2002 +++ linux/drivers/net/a2065.c Sun Mar 10 13:15:17 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.6/drivers/net/ac3200.c linux/drivers/net/ac3200.c --- linux-2.5.6/drivers/net/ac3200.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/ac3200.c Sun Mar 10 13:15:17 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.6/drivers/net/acenic.c linux/drivers/net/acenic.c --- linux-2.5.6/drivers/net/acenic.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/acenic.c Sun Mar 10 13:15:17 2002 @@ -1370,7 +1370,8 @@ goto init_error; } - ecode = request_irq(dev->irq, ace_interrupt, SA_SHIRQ, dev->name, dev); + ecode = request_irq(dev->irq, ace_interrupt, + SA_SHIRQ | SA_NET_RANDOM, dev->name, dev); if (ecode) { printk(KERN_WARNING "%s: Requested IRQ %d is busy\n", dev->name, dev->irq); diff -urN linux-2.5.6/drivers/net/aironet4500_card.c linux/drivers/net/aironet4500_card.c --- linux-2.5.6/drivers/net/aironet4500_card.c Thu Mar 7 21:18:11 2002 +++ linux/drivers/net/aironet4500_card.c Sun Mar 10 13:15:17 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.6/drivers/net/am79c961a.c linux/drivers/net/am79c961a.c --- linux-2.5.6/drivers/net/am79c961a.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/am79c961a.c Sun Mar 10 13:15:17 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.6/drivers/net/apne.c linux/drivers/net/apne.c --- linux-2.5.6/drivers/net/apne.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/apne.c Sun Mar 10 13:15:17 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.6/drivers/net/appletalk/cops.c linux/drivers/net/appletalk/cops.c --- linux-2.5.6/drivers/net/appletalk/cops.c Thu Mar 7 21:18:32 2002 +++ linux/drivers/net/appletalk/cops.c Sun Mar 10 13:15:17 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.6/drivers/net/appletalk/ltpc.c linux/drivers/net/appletalk/ltpc.c --- linux-2.5.6/drivers/net/appletalk/ltpc.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/appletalk/ltpc.c Sun Mar 10 13:15:17 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.6/drivers/net/arcnet/arc-rimi.c linux/drivers/net/arcnet/arc-rimi.c --- linux-2.5.6/drivers/net/arcnet/arc-rimi.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/arcnet/arc-rimi.c Sun Mar 10 13:15:17 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.6/drivers/net/arcnet/com20020.c linux/drivers/net/arcnet/com20020.c --- linux-2.5.6/drivers/net/arcnet/com20020.c Thu Mar 7 21:18:23 2002 +++ linux/drivers/net/arcnet/com20020.c Sun Mar 10 13:15:17 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.6/drivers/net/arcnet/com90io.c linux/drivers/net/arcnet/com90io.c --- linux-2.5.6/drivers/net/arcnet/com90io.c Thu Mar 7 21:18:23 2002 +++ linux/drivers/net/arcnet/com90io.c Sun Mar 10 13:15:17 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.6/drivers/net/arcnet/com90xx.c linux/drivers/net/arcnet/com90xx.c --- linux-2.5.6/drivers/net/arcnet/com90xx.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/arcnet/com90xx.c Sun Mar 10 13:15:17 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.6/drivers/net/ariadne.c linux/drivers/net/ariadne.c --- linux-2.5.6/drivers/net/ariadne.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/ariadne.c Sun Mar 10 13:15:17 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.6/drivers/net/ariadne2.c linux/drivers/net/ariadne2.c --- linux-2.5.6/drivers/net/ariadne2.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/ariadne2.c Sun Mar 10 13:15:17 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.6/drivers/net/arlan.c linux/drivers/net/arlan.c --- linux-2.5.6/drivers/net/arlan.c Thu Mar 7 21:18:11 2002 +++ linux/drivers/net/arlan.c Sun Mar 10 13:15:17 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.6/drivers/net/at1700.c linux/drivers/net/at1700.c --- linux-2.5.6/drivers/net/at1700.c Thu Mar 7 21:18:26 2002 +++ linux/drivers/net/at1700.c Sun Mar 10 13:15:17 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.6/drivers/net/atarilance.c linux/drivers/net/atarilance.c --- linux-2.5.6/drivers/net/atarilance.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/atarilance.c Sun Mar 10 13:15:17 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.6/drivers/net/atp.c linux/drivers/net/atp.c --- linux-2.5.6/drivers/net/atp.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/atp.c Sun Mar 10 13:15:17 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.6/drivers/net/au1000_eth.c linux/drivers/net/au1000_eth.c --- linux-2.5.6/drivers/net/au1000_eth.c Thu Mar 7 21:18:04 2002 +++ linux/drivers/net/au1000_eth.c Sun Mar 10 13:15:17 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.6/drivers/net/bagetlance.c linux/drivers/net/bagetlance.c --- linux-2.5.6/drivers/net/bagetlance.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/bagetlance.c Sun Mar 10 13:15:17 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.6/drivers/net/bmac.c linux/drivers/net/bmac.c --- linux-2.5.6/drivers/net/bmac.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/bmac.c Sun Mar 10 13:15:17 2002 @@ -1405,17 +1405,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.6/drivers/net/cs89x0.c linux/drivers/net/cs89x0.c --- linux-2.5.6/drivers/net/cs89x0.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/cs89x0.c Sun Mar 10 13:15:17 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.6/drivers/net/daynaport.c linux/drivers/net/daynaport.c --- linux-2.5.6/drivers/net/daynaport.c Thu Mar 7 21:18:04 2002 +++ linux/drivers/net/daynaport.c Sun Mar 10 13:15:17 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.6/drivers/net/de600.c linux/drivers/net/de600.c --- linux-2.5.6/drivers/net/de600.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/de600.c Sun Mar 10 13:15:19 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.6/drivers/net/de620.c linux/drivers/net/de620.c --- linux-2.5.6/drivers/net/de620.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/de620.c Sun Mar 10 13:15:19 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.6/drivers/net/declance.c linux/drivers/net/declance.c --- linux-2.5.6/drivers/net/declance.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/declance.c Sun Mar 10 13:15:19 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.6/drivers/net/defxx.c linux/drivers/net/defxx.c --- linux-2.5.6/drivers/net/defxx.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/defxx.c Sun Mar 10 13:15:19 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.6/drivers/net/depca.c linux/drivers/net/depca.c --- linux-2.5.6/drivers/net/depca.c Thu Mar 7 21:18:54 2002 +++ linux/drivers/net/depca.c Sun Mar 10 13:15:19 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.6/drivers/net/dgrs.c linux/drivers/net/dgrs.c --- linux-2.5.6/drivers/net/dgrs.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/dgrs.c Sun Mar 10 13:15:19 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.6/drivers/net/dl2k.c linux/drivers/net/dl2k.c --- linux-2.5.6/drivers/net/dl2k.c Thu Mar 7 21:18:27 2002 +++ linux/drivers/net/dl2k.c Sun Mar 10 13:15:19 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.6/drivers/net/donkey linux/drivers/net/donkey --- linux-2.5.6/drivers/net/donkey Wed Dec 31 19:00:00 1969 +++ linux/drivers/net/donkey Sun Mar 10 13:17:35 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.6/drivers/net/e100/e100_main.c linux/drivers/net/e100/e100_main.c --- linux-2.5.6/drivers/net/e100/e100_main.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/e100/e100_main.c Sun Mar 10 13:18:20 2002 @@ -967,7 +967,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.6/drivers/net/e1000/e1000_main.c linux/drivers/net/e1000/e1000_main.c --- linux-2.5.6/drivers/net/e1000/e1000_main.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/e1000/e1000_main.c Sun Mar 10 13:21:02 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.6/drivers/net/e2100.c linux/drivers/net/e2100.c --- linux-2.5.6/drivers/net/e2100.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/e2100.c Sun Mar 10 13:15:20 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.6/drivers/net/eepro.c linux/drivers/net/eepro.c --- linux-2.5.6/drivers/net/eepro.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/eepro.c Sun Mar 10 13:15:20 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.6/drivers/net/eepro100.c linux/drivers/net/eepro100.c --- linux-2.5.6/drivers/net/eepro100.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/eepro100.c Sun Mar 10 13:15:20 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.6/drivers/net/eexpress.c linux/drivers/net/eexpress.c --- linux-2.5.6/drivers/net/eexpress.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/eexpress.c Sun Mar 10 13:15:20 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.6/drivers/net/epic100.c linux/drivers/net/epic100.c --- linux-2.5.6/drivers/net/epic100.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/epic100.c Sun Mar 10 13:15:20 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.6/drivers/net/es3210.c linux/drivers/net/es3210.c --- linux-2.5.6/drivers/net/es3210.c Thu Mar 7 21:18:19 2002 +++ linux/drivers/net/es3210.c Sun Mar 10 13:15:20 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.6/drivers/net/eth16i.c linux/drivers/net/eth16i.c --- linux-2.5.6/drivers/net/eth16i.c Thu Mar 7 21:18:21 2002 +++ linux/drivers/net/eth16i.c Sun Mar 10 13:15:20 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.6/drivers/net/ewrk3.c linux/drivers/net/ewrk3.c --- linux-2.5.6/drivers/net/ewrk3.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/ewrk3.c Sun Mar 10 13:15:20 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.6/drivers/net/fc/iph5526.c linux/drivers/net/fc/iph5526.c --- linux-2.5.6/drivers/net/fc/iph5526.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/fc/iph5526.c Sun Mar 10 13:15:20 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.6/drivers/net/fealnx.c linux/drivers/net/fealnx.c --- linux-2.5.6/drivers/net/fealnx.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/fealnx.c Sun Mar 10 13:15:20 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.6/drivers/net/fmv18x.c linux/drivers/net/fmv18x.c --- linux-2.5.6/drivers/net/fmv18x.c Thu Mar 7 21:18:09 2002 +++ linux/drivers/net/fmv18x.c Sun Mar 10 13:15:20 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.6/drivers/net/gt96100eth.c linux/drivers/net/gt96100eth.c --- linux-2.5.6/drivers/net/gt96100eth.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/gt96100eth.c Sun Mar 10 13:15:20 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.6/drivers/net/hamachi.c linux/drivers/net/hamachi.c --- linux-2.5.6/drivers/net/hamachi.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/hamachi.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/baycom_ser_fdx.c linux/drivers/net/hamradio/baycom_ser_fdx.c --- linux-2.5.6/drivers/net/hamradio/baycom_ser_fdx.c Thu Mar 7 21:18:54 2002 +++ linux/drivers/net/hamradio/baycom_ser_fdx.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/baycom_ser_hdx.c linux/drivers/net/hamradio/baycom_ser_hdx.c --- linux-2.5.6/drivers/net/hamradio/baycom_ser_hdx.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/hamradio/baycom_ser_hdx.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/dmascc.c linux/drivers/net/hamradio/dmascc.c --- linux-2.5.6/drivers/net/hamradio/dmascc.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/hamradio/dmascc.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/scc.c linux/drivers/net/hamradio/scc.c --- linux-2.5.6/drivers/net/hamradio/scc.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/hamradio/scc.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/soundmodem/sm_sbc.c linux/drivers/net/hamradio/soundmodem/sm_sbc.c --- linux-2.5.6/drivers/net/hamradio/soundmodem/sm_sbc.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/hamradio/soundmodem/sm_sbc.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/soundmodem/sm_wss.c linux/drivers/net/hamradio/soundmodem/sm_wss.c --- linux-2.5.6/drivers/net/hamradio/soundmodem/sm_wss.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/hamradio/soundmodem/sm_wss.c Sun Mar 10 13:15:20 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.6/drivers/net/hamradio/yam.c linux/drivers/net/hamradio/yam.c --- linux-2.5.6/drivers/net/hamradio/yam.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/hamradio/yam.c Sun Mar 10 13:15:20 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.6/drivers/net/hp-plus.c linux/drivers/net/hp-plus.c --- linux-2.5.6/drivers/net/hp-plus.c Thu Mar 7 21:18:08 2002 +++ linux/drivers/net/hp-plus.c Sun Mar 10 13:15:20 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.6/drivers/net/hp.c linux/drivers/net/hp.c --- linux-2.5.6/drivers/net/hp.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/hp.c Sun Mar 10 13:15:20 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.6/drivers/net/hp100.c linux/drivers/net/hp100.c --- linux-2.5.6/drivers/net/hp100.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/hp100.c Sun Mar 10 13:15:20 2002 @@ -1126,8 +1126,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.6/drivers/net/hydra.c linux/drivers/net/hydra.c --- linux-2.5.6/drivers/net/hydra.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/hydra.c Sun Mar 10 13:15:20 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.6/drivers/net/ibmlana.c linux/drivers/net/ibmlana.c --- linux-2.5.6/drivers/net/ibmlana.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/ibmlana.c Sun Mar 10 13:15:20 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.6/drivers/net/ioc3-eth.c linux/drivers/net/ioc3-eth.c --- linux-2.5.6/drivers/net/ioc3-eth.c Thu Mar 7 21:18:08 2002 +++ linux/drivers/net/ioc3-eth.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/ali-ircc.c linux/drivers/net/irda/ali-ircc.c --- linux-2.5.6/drivers/net/irda/ali-ircc.c Thu Mar 7 21:18:27 2002 +++ linux/drivers/net/irda/ali-ircc.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/irport.c linux/drivers/net/irda/irport.c --- linux-2.5.6/drivers/net/irda/irport.c Thu Mar 7 21:18:13 2002 +++ linux/drivers/net/irda/irport.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/nsc-ircc.c linux/drivers/net/irda/nsc-ircc.c --- linux-2.5.6/drivers/net/irda/nsc-ircc.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/irda/nsc-ircc.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/sa1100_ir.c linux/drivers/net/irda/sa1100_ir.c --- linux-2.5.6/drivers/net/irda/sa1100_ir.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/irda/sa1100_ir.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/toshoboe.c linux/drivers/net/irda/toshoboe.c --- linux-2.5.6/drivers/net/irda/toshoboe.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/irda/toshoboe.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/vlsi_ir.c linux/drivers/net/irda/vlsi_ir.c --- linux-2.5.6/drivers/net/irda/vlsi_ir.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/irda/vlsi_ir.c Sun Mar 10 13:15:20 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.6/drivers/net/irda/w83977af_ir.c linux/drivers/net/irda/w83977af_ir.c --- linux-2.5.6/drivers/net/irda/w83977af_ir.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/irda/w83977af_ir.c Sun Mar 10 13:15:20 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.6/drivers/net/isa-skeleton.c linux/drivers/net/isa-skeleton.c --- linux-2.5.6/drivers/net/isa-skeleton.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/isa-skeleton.c Sun Mar 10 13:15:20 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.6/drivers/net/lance.c linux/drivers/net/lance.c --- linux-2.5.6/drivers/net/lance.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/lance.c Sun Mar 10 13:15:20 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.6/drivers/net/lasi_82596.c linux/drivers/net/lasi_82596.c --- linux-2.5.6/drivers/net/lasi_82596.c Thu Mar 7 21:18:13 2002 +++ linux/drivers/net/lasi_82596.c Sun Mar 10 13:15:20 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.6/drivers/net/lne390.c linux/drivers/net/lne390.c --- linux-2.5.6/drivers/net/lne390.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/lne390.c Sun Mar 10 13:15:20 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.6/drivers/net/lp486e.c linux/drivers/net/lp486e.c --- linux-2.5.6/drivers/net/lp486e.c Thu Mar 7 21:18:20 2002 +++ linux/drivers/net/lp486e.c Sun Mar 10 13:15:20 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.6/drivers/net/mac89x0.c linux/drivers/net/mac89x0.c --- linux-2.5.6/drivers/net/mac89x0.c Thu Mar 7 21:18:53 2002 +++ linux/drivers/net/mac89x0.c Sun Mar 10 13:15:20 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.6/drivers/net/mace.c linux/drivers/net/mace.c --- linux-2.5.6/drivers/net/mace.c Thu Mar 7 21:18:20 2002 +++ linux/drivers/net/mace.c Sun Mar 10 13:15:20 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.6/drivers/net/macmace.c linux/drivers/net/macmace.c --- linux-2.5.6/drivers/net/macmace.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/macmace.c Sun Mar 10 13:15:20 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.6/drivers/net/myri_sbus.c linux/drivers/net/myri_sbus.c --- linux-2.5.6/drivers/net/myri_sbus.c Thu Mar 7 21:18:09 2002 +++ linux/drivers/net/myri_sbus.c Sun Mar 10 13:15:20 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.6/drivers/net/natsemi.c linux/drivers/net/natsemi.c --- linux-2.5.6/drivers/net/natsemi.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/natsemi.c Sun Mar 10 13:15:20 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.6/drivers/net/ne.c linux/drivers/net/ne.c --- linux-2.5.6/drivers/net/ne.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/ne.c Sun Mar 10 13:15:20 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.6/drivers/net/ne2.c linux/drivers/net/ne2.c --- linux-2.5.6/drivers/net/ne2.c Thu Mar 7 21:18:30 2002 +++ linux/drivers/net/ne2.c Sun Mar 10 13:15:20 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.6/drivers/net/ne2k-pci.c linux/drivers/net/ne2k-pci.c --- linux-2.5.6/drivers/net/ne2k-pci.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/ne2k-pci.c Sun Mar 10 13:15:20 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.6/drivers/net/ne3210.c linux/drivers/net/ne3210.c --- linux-2.5.6/drivers/net/ne3210.c Thu Mar 7 21:18:27 2002 +++ linux/drivers/net/ne3210.c Sun Mar 10 13:15:20 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.6/drivers/net/ni5010.c linux/drivers/net/ni5010.c --- linux-2.5.6/drivers/net/ni5010.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/ni5010.c Sun Mar 10 13:15:20 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.6/drivers/net/ni52.c linux/drivers/net/ni52.c --- linux-2.5.6/drivers/net/ni52.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/ni52.c Sun Mar 10 13:15:20 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.6/drivers/net/ni65.c linux/drivers/net/ni65.c --- linux-2.5.6/drivers/net/ni65.c Thu Mar 7 21:18:19 2002 +++ linux/drivers/net/ni65.c Sun Mar 10 13:15:20 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.6/drivers/net/ns83820.c linux/drivers/net/ns83820.c --- linux-2.5.6/drivers/net/ns83820.c Thu Mar 7 21:18:58 2002 +++ linux/drivers/net/ns83820.c Sun Mar 10 13:15:20 2002 @@ -1442,8 +1442,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.6/drivers/net/oaknet.c linux/drivers/net/oaknet.c --- linux-2.5.6/drivers/net/oaknet.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/oaknet.c Sun Mar 10 13:15:20 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.6/drivers/net/pci-skeleton.c linux/drivers/net/pci-skeleton.c --- linux-2.5.6/drivers/net/pci-skeleton.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/pci-skeleton.c Sun Mar 10 13:15:20 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.6/drivers/net/pcmcia/axnet_cs.c linux/drivers/net/pcmcia/axnet_cs.c --- linux-2.5.6/drivers/net/pcmcia/axnet_cs.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/pcmcia/axnet_cs.c Sun Mar 10 13:15:20 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.6/drivers/net/pcmcia/pcnet_cs.c linux/drivers/net/pcmcia/pcnet_cs.c --- linux-2.5.6/drivers/net/pcmcia/pcnet_cs.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/pcmcia/pcnet_cs.c Sun Mar 10 13:15:20 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.6/drivers/net/pcnet32.c linux/drivers/net/pcnet32.c --- linux-2.5.6/drivers/net/pcnet32.c Thu Mar 7 21:18:20 2002 +++ linux/drivers/net/pcnet32.c Sun Mar 10 13:15:21 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.6/drivers/net/rcpci45.c linux/drivers/net/rcpci45.c --- linux-2.5.6/drivers/net/rcpci45.c Thu Mar 7 21:18:19 2002 +++ linux/drivers/net/rcpci45.c Sun Mar 10 13:15:21 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.6/drivers/net/rrunner.c linux/drivers/net/rrunner.c --- linux-2.5.6/drivers/net/rrunner.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/rrunner.c Sun Mar 10 13:15:21 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.6/drivers/net/saa9730.c linux/drivers/net/saa9730.c --- linux-2.5.6/drivers/net/saa9730.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/saa9730.c Sun Mar 10 13:15:21 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.6/drivers/net/sb1000.c linux/drivers/net/sb1000.c --- linux-2.5.6/drivers/net/sb1000.c Thu Mar 7 21:18:08 2002 +++ linux/drivers/net/sb1000.c Sun Mar 10 13:15:21 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.6/drivers/net/seeq8005.c linux/drivers/net/seeq8005.c --- linux-2.5.6/drivers/net/seeq8005.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/seeq8005.c Sun Mar 10 13:15:21 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.6/drivers/net/sgiseeq.c linux/drivers/net/sgiseeq.c --- linux-2.5.6/drivers/net/sgiseeq.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/sgiseeq.c Sun Mar 10 13:15:21 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.6/drivers/net/sis900.c linux/drivers/net/sis900.c --- linux-2.5.6/drivers/net/sis900.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/sis900.c Sun Mar 10 13:15:21 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.6/drivers/net/sk98lin/skge.c linux/drivers/net/sk98lin/skge.c --- linux-2.5.6/drivers/net/sk98lin/skge.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/sk98lin/skge.c Sun Mar 10 13:15:21 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.6/drivers/net/sk_g16.c linux/drivers/net/sk_g16.c --- linux-2.5.6/drivers/net/sk_g16.c Thu Mar 7 21:18:43 2002 +++ linux/drivers/net/sk_g16.c Sun Mar 10 13:15:21 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.6/drivers/net/sk_mca.c linux/drivers/net/sk_mca.c --- linux-2.5.6/drivers/net/sk_mca.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/sk_mca.c Sun Mar 10 13:15:21 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.6/drivers/net/skfp/skfddi.c linux/drivers/net/skfp/skfddi.c --- linux-2.5.6/drivers/net/skfp/skfddi.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/skfp/skfddi.c Sun Mar 10 13:15:21 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.6/drivers/net/smc-mca.c linux/drivers/net/smc-mca.c --- linux-2.5.6/drivers/net/smc-mca.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/smc-mca.c Sun Mar 10 13:15:21 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.6/drivers/net/smc-ultra.c linux/drivers/net/smc-ultra.c --- linux-2.5.6/drivers/net/smc-ultra.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/smc-ultra.c Sun Mar 10 13:15:21 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.6/drivers/net/smc-ultra32.c linux/drivers/net/smc-ultra32.c --- linux-2.5.6/drivers/net/smc-ultra32.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/smc-ultra32.c Sun Mar 10 13:15:21 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.6/drivers/net/smc9194.c linux/drivers/net/smc9194.c --- linux-2.5.6/drivers/net/smc9194.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/smc9194.c Sun Mar 10 13:15:21 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.6/drivers/net/sonic.c linux/drivers/net/sonic.c --- linux-2.5.6/drivers/net/sonic.c Thu Mar 7 21:18:58 2002 +++ linux/drivers/net/sonic.c Sun Mar 10 13:15:21 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.6/drivers/net/starfire.c linux/drivers/net/starfire.c --- linux-2.5.6/drivers/net/starfire.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/starfire.c Sun Mar 10 13:15:21 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.6/drivers/net/stnic.c linux/drivers/net/stnic.c --- linux-2.5.6/drivers/net/stnic.c Thu Mar 7 21:18:13 2002 +++ linux/drivers/net/stnic.c Sun Mar 10 13:15:21 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.6/drivers/net/sun3lance.c linux/drivers/net/sun3lance.c --- linux-2.5.6/drivers/net/sun3lance.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/sun3lance.c Sun Mar 10 13:15:21 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.6/drivers/net/sunbmac.c linux/drivers/net/sunbmac.c --- linux-2.5.6/drivers/net/sunbmac.c Thu Mar 7 21:18:04 2002 +++ linux/drivers/net/sunbmac.c Sun Mar 10 13:15:21 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.6/drivers/net/sundance.c linux/drivers/net/sundance.c --- linux-2.5.6/drivers/net/sundance.c Thu Mar 7 21:18:07 2002 +++ linux/drivers/net/sundance.c Sun Mar 10 13:15:21 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.6/drivers/net/sungem.c linux/drivers/net/sungem.c --- linux-2.5.6/drivers/net/sungem.c Thu Mar 7 21:18:58 2002 +++ linux/drivers/net/sungem.c Sun Mar 10 13:15:21 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.6/drivers/net/sunhme.c linux/drivers/net/sunhme.c --- linux-2.5.6/drivers/net/sunhme.c Thu Mar 7 21:18:24 2002 +++ linux/drivers/net/sunhme.c Sun Mar 10 13:15:21 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.6/drivers/net/sunlance.c linux/drivers/net/sunlance.c --- linux-2.5.6/drivers/net/sunlance.c Thu Mar 7 21:18:22 2002 +++ linux/drivers/net/sunlance.c Sun Mar 10 13:15:21 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.6/drivers/net/sunqe.c linux/drivers/net/sunqe.c --- linux-2.5.6/drivers/net/sunqe.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/sunqe.c Sun Mar 10 13:15:21 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.6/drivers/net/tg3.c linux/drivers/net/tg3.c --- linux-2.5.6/drivers/net/tg3.c Thu Mar 7 21:18:05 2002 +++ linux/drivers/net/tg3.c Sun Mar 10 13:21:45 2002 @@ -3746,10 +3746,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.6/drivers/net/tlan.c linux/drivers/net/tlan.c --- linux-2.5.6/drivers/net/tlan.c Thu Mar 7 21:18:13 2002 +++ linux/drivers/net/tlan.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/3c359.c linux/drivers/net/tokenring/3c359.c --- linux-2.5.6/drivers/net/tokenring/3c359.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/tokenring/3c359.c Sun Mar 10 13:22:13 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.6/drivers/net/tokenring/abyss.c linux/drivers/net/tokenring/abyss.c --- linux-2.5.6/drivers/net/tokenring/abyss.c Thu Mar 7 21:18:19 2002 +++ linux/drivers/net/tokenring/abyss.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/ibmtr.c linux/drivers/net/tokenring/ibmtr.c --- linux-2.5.6/drivers/net/tokenring/ibmtr.c Thu Mar 7 21:18:11 2002 +++ linux/drivers/net/tokenring/ibmtr.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/lanstreamer.c linux/drivers/net/tokenring/lanstreamer.c --- linux-2.5.6/drivers/net/tokenring/lanstreamer.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/tokenring/lanstreamer.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/madgemc.c linux/drivers/net/tokenring/madgemc.c --- linux-2.5.6/drivers/net/tokenring/madgemc.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/tokenring/madgemc.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/olympic.c linux/drivers/net/tokenring/olympic.c --- linux-2.5.6/drivers/net/tokenring/olympic.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/tokenring/olympic.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/smctr.c linux/drivers/net/tokenring/smctr.c --- linux-2.5.6/drivers/net/tokenring/smctr.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/tokenring/smctr.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/tmsisa.c linux/drivers/net/tokenring/tmsisa.c --- linux-2.5.6/drivers/net/tokenring/tmsisa.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/tokenring/tmsisa.c Sun Mar 10 13:15:21 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.6/drivers/net/tokenring/tmspci.c linux/drivers/net/tokenring/tmspci.c --- linux-2.5.6/drivers/net/tokenring/tmspci.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/tokenring/tmspci.c Sun Mar 10 13:15:21 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.6/drivers/net/tulip/de4x5.c linux/drivers/net/tulip/de4x5.c --- linux-2.5.6/drivers/net/tulip/de4x5.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/tulip/de4x5.c Sun Mar 10 13:23:42 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.6/drivers/net/tulip/dmfe.c linux/drivers/net/tulip/dmfe.c --- linux-2.5.6/drivers/net/tulip/dmfe.c Thu Mar 7 21:18:57 2002 +++ linux/drivers/net/tulip/dmfe.c Sun Mar 10 13:24:41 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.6/drivers/net/tulip/tulip_core.c linux/drivers/net/tulip/tulip_core.c --- linux-2.5.6/drivers/net/tulip/tulip_core.c Thu Mar 7 21:18:54 2002 +++ linux/drivers/net/tulip/tulip_core.c Sun Mar 10 13:15:21 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.6/drivers/net/tulip/winbond-840.c linux/drivers/net/tulip/winbond-840.c --- linux-2.5.6/drivers/net/tulip/winbond-840.c Thu Mar 7 21:18:16 2002 +++ linux/drivers/net/tulip/winbond-840.c Sun Mar 10 13:24:22 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.6/drivers/net/tulip/xircom_cb.c linux/drivers/net/tulip/xircom_cb.c --- linux-2.5.6/drivers/net/tulip/xircom_cb.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/tulip/xircom_cb.c Sun Mar 10 13:26:11 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.6/drivers/net/tulip/xircom_tulip_cb.c linux/drivers/net/tulip/xircom_tulip_cb.c --- linux-2.5.6/drivers/net/tulip/xircom_tulip_cb.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/tulip/xircom_tulip_cb.c Sun Mar 10 13:24:00 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.6/drivers/net/via-rhine.c linux/drivers/net/via-rhine.c --- linux-2.5.6/drivers/net/via-rhine.c Thu Mar 7 21:18:29 2002 +++ linux/drivers/net/via-rhine.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/c101.c linux/drivers/net/wan/c101.c --- linux-2.5.6/drivers/net/wan/c101.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/wan/c101.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/comx-hw-comx.c linux/drivers/net/wan/comx-hw-comx.c --- linux-2.5.6/drivers/net/wan/comx-hw-comx.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/wan/comx-hw-comx.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/comx-hw-locomx.c linux/drivers/net/wan/comx-hw-locomx.c --- linux-2.5.6/drivers/net/wan/comx-hw-locomx.c Thu Mar 7 21:18:55 2002 +++ linux/drivers/net/wan/comx-hw-locomx.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/comx-hw-mixcom.c linux/drivers/net/wan/comx-hw-mixcom.c --- linux-2.5.6/drivers/net/wan/comx-hw-mixcom.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/wan/comx-hw-mixcom.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/cosa.c linux/drivers/net/wan/cosa.c --- linux-2.5.6/drivers/net/wan/cosa.c Thu Mar 7 21:18:06 2002 +++ linux/drivers/net/wan/cosa.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/cycx_main.c linux/drivers/net/wan/cycx_main.c --- linux-2.5.6/drivers/net/wan/cycx_main.c Thu Mar 7 21:18:31 2002 +++ linux/drivers/net/wan/cycx_main.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/dscc4.c linux/drivers/net/wan/dscc4.c --- linux-2.5.6/drivers/net/wan/dscc4.c Thu Mar 7 21:18:18 2002 +++ linux/drivers/net/wan/dscc4.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/farsync.c linux/drivers/net/wan/farsync.c --- linux-2.5.6/drivers/net/wan/farsync.c Thu Mar 7 21:18:14 2002 +++ linux/drivers/net/wan/farsync.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/hostess_sv11.c linux/drivers/net/wan/hostess_sv11.c --- linux-2.5.6/drivers/net/wan/hostess_sv11.c Thu Mar 7 21:18:56 2002 +++ linux/drivers/net/wan/hostess_sv11.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/lmc/lmc_main.c linux/drivers/net/wan/lmc/lmc_main.c --- linux-2.5.6/drivers/net/wan/lmc/lmc_main.c Thu Mar 7 21:18:23 2002 +++ linux/drivers/net/wan/lmc/lmc_main.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/n2.c linux/drivers/net/wan/n2.c --- linux-2.5.6/drivers/net/wan/n2.c Thu Mar 7 21:18:17 2002 +++ linux/drivers/net/wan/n2.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/sbni.c linux/drivers/net/wan/sbni.c --- linux-2.5.6/drivers/net/wan/sbni.c Thu Mar 7 21:18:24 2002 +++ linux/drivers/net/wan/sbni.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/sdla.c linux/drivers/net/wan/sdla.c --- linux-2.5.6/drivers/net/wan/sdla.c Thu Mar 7 21:18:32 2002 +++ linux/drivers/net/wan/sdla.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/sdlamain.c linux/drivers/net/wan/sdlamain.c --- linux-2.5.6/drivers/net/wan/sdlamain.c Thu Mar 7 21:18:16 2002 +++ linux/drivers/net/wan/sdlamain.c Sun Mar 10 13:15:21 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.6/drivers/net/wan/sealevel.c linux/drivers/net/wan/sealevel.c --- linux-2.5.6/drivers/net/wan/sealevel.c Thu Mar 7 21:18:11 2002 +++ linux/drivers/net/wan/sealevel.c Sun Mar 10 13:15:21 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.6/drivers/net/wd.c linux/drivers/net/wd.c --- linux-2.5.6/drivers/net/wd.c Thu Mar 7 21:18:08 2002 +++ linux/drivers/net/wd.c Sun Mar 10 13:15:21 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.6/drivers/net/wireless/airo.c linux/drivers/net/wireless/airo.c --- linux-2.5.6/drivers/net/wireless/airo.c Thu Mar 7 21:18:12 2002 +++ linux/drivers/net/wireless/airo.c Sun Mar 10 13:15:23 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.6/drivers/net/wireless/airport.c linux/drivers/net/wireless/airport.c --- linux-2.5.6/drivers/net/wireless/airport.c Thu Mar 7 21:18:28 2002 +++ linux/drivers/net/wireless/airport.c Sun Mar 10 13:15:23 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.6/drivers/net/wireless/orinoco_plx.c linux/drivers/net/wireless/orinoco_plx.c --- linux-2.5.6/drivers/net/wireless/orinoco_plx.c Thu Mar 7 21:18:58 2002 +++ linux/drivers/net/wireless/orinoco_plx.c Sun Mar 10 13:15:23 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.6/drivers/net/wireless/wavelan.c linux/drivers/net/wireless/wavelan.c --- linux-2.5.6/drivers/net/wireless/wavelan.c Thu Mar 7 21:18:24 2002 +++ linux/drivers/net/wireless/wavelan.c Sun Mar 10 13:24: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.6/drivers/net/yellowfin.c linux/drivers/net/yellowfin.c --- linux-2.5.6/drivers/net/yellowfin.c Thu Mar 7 21:18:25 2002 +++ linux/drivers/net/yellowfin.c Sun Mar 10 13:15:23 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.6/drivers/net/znet.c linux/drivers/net/znet.c --- linux-2.5.6/drivers/net/znet.c Thu Mar 7 21:18:03 2002 +++ linux/drivers/net/znet.c Sun Mar 10 13:15:23 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);