*/
#include <linux/crc32.h>
#include <linux/delay.h>
-#include <linux/dio.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/skbuff.h>
+#include <linux/irq.h>
/* Used for the temporal inet entries and routing */
#include <linux/socket.h>
+#include <linux/bitops.h>
#include <asm/system.h>
-#include <asm/bitops.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <asm/pgtable.h>
+#ifdef CONFIG_HP300
+#include <asm/blinken.h>
+#endif
#include "7990.h"
+#define WRITERAP(lp,x) out_be16(lp->base + LANCE_RAP, (x))
+#define WRITERDP(lp,x) out_be16(lp->base + LANCE_RDP, (x))
+#define READRDP(lp) in_be16(lp->base + LANCE_RDP)
+
+#if defined(CONFIG_HPLANCE) || defined(CONFIG_HPLANCE_MODULE)
+#include "hplance.h"
+
+#undef WRITERAP
+#undef WRITERDP
+#undef READRDP
+
+#if defined(CONFIG_MVME147_NET) || defined(CONFIG_MVME147_NET_MODULE)
+
/* Lossage Factor Nine, Mr Sulu. */
-#define WRITERAP(x) (lp->writerap(lp,x))
-#define WRITERDP(x) (lp->writerdp(lp,x))
-#define READRDP() (lp->readrdp(lp))
-/* These used to be ll->rap = x, ll->rdp = x, and (ll->rdp). Sigh.
- * If you want to switch them back then
- * #define DECLARE_LL volatile struct lance_regs *ll = lp->ll
- */
-#define DECLARE_LL /* nothing to declare */
+#define WRITERAP(lp,x) (lp->writerap(lp,x))
+#define WRITERDP(lp,x) (lp->writerdp(lp,x))
+#define READRDP(lp) (lp->readrdp(lp))
+
+#else
+
+/* These inlines can be used if only CONFIG_HPLANCE is defined */
+static inline void WRITERAP(struct lance_private *lp, __u16 value)
+{
+ do {
+ out_be16(lp->base + HPLANCE_REGOFF + LANCE_RAP, value);
+ } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0);
+}
+
+static inline void WRITERDP(struct lance_private *lp, __u16 value)
+{
+ do {
+ out_be16(lp->base + HPLANCE_REGOFF + LANCE_RDP, value);
+ } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0);
+}
+
+static inline __u16 READRDP(struct lance_private *lp)
+{
+ __u16 value;
+ do {
+ value = in_be16(lp->base + HPLANCE_REGOFF + LANCE_RDP);
+ } while ((in_8(lp->base + HPLANCE_STATUS) & LE_ACK) == 0);
+ return value;
+}
+
+#endif
+#endif /* CONFIG_HPLANCE || CONFIG_HPLANCE_MODULE */
/* debugging output macros, various flavours */
/* #define TEST_HITS */
{
volatile struct lance_init_block *aib = lp->lance_init_block;
int leptr;
- DECLARE_LL;
leptr = LANCE_ADDR (aib);
- WRITERAP(LE_CSR1); /* load address of init block */
- WRITERDP(leptr & 0xFFFF);
- WRITERAP(LE_CSR2);
- WRITERDP(leptr >> 16);
- WRITERAP(LE_CSR3);
- WRITERDP(lp->busmaster_regval); /* set byteswap/ALEctrl/byte ctrl */
+ WRITERAP(lp, LE_CSR1); /* load address of init block */
+ WRITERDP(lp, leptr & 0xFFFF);
+ WRITERAP(lp, LE_CSR2);
+ WRITERDP(lp, leptr >> 16);
+ WRITERAP(lp, LE_CSR3);
+ WRITERDP(lp, lp->busmaster_regval); /* set byteswap/ALEctrl/byte ctrl */
/* Point back to csr0 */
- WRITERAP(LE_CSR0);
+ WRITERAP(lp, LE_CSR0);
}
/* #define to 0 or 1 appropriately */
static int init_restart_lance (struct lance_private *lp)
{
int i;
- DECLARE_LL;
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_INIT);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_INIT);
/* Need a hook here for sunlance ledma stuff */
/* Wait for the lance to complete initialization */
- for (i = 0; (i < 100) && !(READRDP() & (LE_C0_ERR | LE_C0_IDON)); i++)
+ for (i = 0; (i < 100) && !(READRDP(lp) & (LE_C0_ERR | LE_C0_IDON)); i++)
barrier();
- if ((i == 100) || (READRDP() & LE_C0_ERR)) {
- printk ("LANCE unopened after %d ticks, csr0=%4.4x.\n", i, READRDP());
+ if ((i == 100) || (READRDP(lp) & LE_C0_ERR)) {
+ printk ("LANCE unopened after %d ticks, csr0=%4.4x.\n", i, READRDP(lp));
return -1;
}
/* Clear IDON by writing a "1", enable interrupts and start lance */
- WRITERDP(LE_C0_IDON);
- WRITERDP(LE_C0_INEA | LE_C0_STRT);
+ WRITERDP(lp, LE_C0_IDON);
+ WRITERDP(lp, LE_C0_INEA | LE_C0_STRT);
return 0;
}
{
struct lance_private *lp = netdev_priv(dev);
int status;
- DECLARE_LL;
/* Stop the lance */
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_STOP);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STOP);
load_csrs (lp);
lance_init_ring (dev);
#ifdef TEST_HITS
int i;
#endif
- DECLARE_LL;
#ifdef TEST_HITS
printk ("[");
}
printk ("]");
#endif
-
- WRITERDP(LE_C0_RINT | LE_C0_INEA); /* ack Rx int, reenable ints */
+#ifdef CONFIG_HP300
+ blinken_leds(0x40, 0);
+#endif
+ WRITERDP(lp, LE_C0_RINT | LE_C0_INEA); /* ack Rx int, reenable ints */
for (rd = &ib->brx_ring [lp->rx_new]; /* For each Rx ring we own... */
!((bits = rd->rmd1_bits) & LE_R1_OWN);
rd = &ib->brx_ring [lp->rx_new]) {
volatile struct lance_tx_desc *td;
int i, j;
int status;
- DECLARE_LL;
+#ifdef CONFIG_HP300
+ blinken_leds(0x80, 0);
+#endif
/* csr0 is 2f3 */
- WRITERDP(LE_C0_TINT | LE_C0_INEA);
+ WRITERDP(lp, LE_C0_TINT | LE_C0_INEA);
/* csr0 is 73 */
j = lp->tx_old;
printk("%s: Carrier Lost, trying %s\n",
dev->name, lp->tpe?"TPE":"AUI");
/* Stop the lance */
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_STOP);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STOP);
lance_init_ring (dev);
load_csrs (lp);
init_restart_lance (lp);
printk ("%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
dev->name);
/* Stop the lance */
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_STOP);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STOP);
lance_init_ring (dev);
load_csrs (lp);
init_restart_lance (lp);
j = (j + 1) & lp->tx_ring_mod_mask;
}
lp->tx_old = j;
- WRITERDP(LE_C0_TINT | LE_C0_INEA);
+ WRITERDP(lp, LE_C0_TINT | LE_C0_INEA);
return 0;
}
struct net_device *dev = (struct net_device *)dev_id;
struct lance_private *lp = netdev_priv(dev);
int csr0;
- DECLARE_LL;
spin_lock (&lp->devlock);
- WRITERAP(LE_CSR0); /* LANCE Controller Status */
- csr0 = READRDP();
+ WRITERAP(lp, LE_CSR0); /* LANCE Controller Status */
+ csr0 = READRDP(lp);
PRINT_RINGS();
if (!(csr0 & LE_C0_INTR)) { /* Check if any interrupt has */
- spin_lock (&lp->devlock);
+ spin_unlock (&lp->devlock);
return IRQ_NONE; /* been generated by the Lance. */
}
/* Acknowledge all the interrupt sources ASAP */
- WRITERDP(csr0 & ~(LE_C0_INEA|LE_C0_TDMD|LE_C0_STOP|LE_C0_STRT|LE_C0_INIT));
+ WRITERDP(lp, csr0 & ~(LE_C0_INEA|LE_C0_TDMD|LE_C0_STOP|LE_C0_STRT|LE_C0_INIT));
if ((csr0 & LE_C0_ERR)) {
/* Clear the error condition */
- WRITERDP(LE_C0_BABL|LE_C0_ERR|LE_C0_MISS|LE_C0_INEA);
+ WRITERDP(lp, LE_C0_BABL|LE_C0_ERR|LE_C0_MISS|LE_C0_INEA);
}
if (csr0 & LE_C0_RINT)
printk("%s: Bus master arbitration failure, status %4.4x.\n",
dev->name, csr0);
/* Restart the chip. */
- WRITERDP(LE_C0_STRT);
+ WRITERDP(lp, LE_C0_STRT);
}
if (lp->tx_full && netif_queue_stopped(dev) && (TX_BUFFS_AVAIL >= 0)) {
netif_wake_queue (dev);
}
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_BABL|LE_C0_CERR|LE_C0_MISS|LE_C0_MERR|LE_C0_IDON|LE_C0_INEA);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_BABL|LE_C0_CERR|LE_C0_MISS|LE_C0_MERR|LE_C0_IDON|LE_C0_INEA);
spin_unlock (&lp->devlock);
return IRQ_HANDLED;
{
struct lance_private *lp = netdev_priv(dev);
int res;
- 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))
return -EAGAIN;
res = lance_reset(dev);
- lp->devlock = SPIN_LOCK_UNLOCKED;
+ spin_lock_init(&lp->devlock);
netif_start_queue (dev);
return res;
int lance_close (struct net_device *dev)
{
struct lance_private *lp = netdev_priv(dev);
- DECLARE_LL;
netif_stop_queue (dev);
/* Stop the LANCE */
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_STOP);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STOP);
free_irq(lp->irq, dev);
int entry, skblen, len;
static int outs;
unsigned long flags;
- DECLARE_LL;
if (!TX_BUFFS_AVAIL)
return -1;
outs++;
/* Kick the lance: transmit now */
- WRITERDP(LE_C0_INEA | LE_C0_TDMD);
+ WRITERDP(lp, LE_C0_INEA | LE_C0_TDMD);
dev->trans_start = jiffies;
dev_kfree_skb (skb);
struct lance_private *lp = netdev_priv(dev);
volatile struct lance_init_block *ib = lp->init_block;
int stopped;
- DECLARE_LL;
stopped = netif_queue_stopped(dev);
if (!stopped)
while (lp->tx_old != lp->tx_new)
schedule();
- WRITERAP(LE_CSR0);
- WRITERDP(LE_C0_STOP);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STOP);
lance_init_ring (dev);
if (dev->flags & IFF_PROMISC) {
netif_start_queue (dev);
}
+#ifdef CONFIG_NET_POLL_CONTROLLER
+void lance_poll(struct net_device *dev)
+{
+ struct lance_private *lp = netdev_priv(dev);
+
+ spin_lock (&lp->devlock);
+ WRITERAP(lp, LE_CSR0);
+ WRITERDP(lp, LE_C0_STRT);
+ spin_unlock (&lp->devlock);
+ lance_interrupt(dev->irq, dev, NULL);
+}
+#endif
+
MODULE_LICENSE("GPL");
git://git.onelab.eu / linux-2.6.git / blobdiff