1 /* lasi_82596.c -- driver for the intel 82596 ethernet controller, as
2 munged into HPPA boxen .
4 This driver is based upon 82596.c, original credits are below...
5 but there were too many hoops which HP wants jumped through to
6 keep this code in there in a sane manner.
8 3 primary sources of the mess --
9 1) hppa needs *lots* of cacheline flushing to keep this kind of
12 2) The 82596 needs to see all of its pointers as their physical
13 address. Thus virt_to_bus/bus_to_virt are *everywhere*.
15 3) The implementation HP is using seems to be significantly pickier
16 about when and how the command and RX units are started. some
17 command ordering was changed.
19 Examination of the mach driver leads one to believe that there
20 might be a saner way to pull this off... anyone who feels like a
21 full rewrite can be my guest.
23 Split 02/13/2000 Sam Creasey (sammy@oh.verio.com)
25 02/01/2000 Initial modifications for parisc by Helge Deller (deller@gmx.de)
26 03/02/2000 changes for better/correct(?) cache-flushing (deller)
29 /* 82596.c: A generic 82596 ethernet driver for linux. */
32 Written 1994 by Mark Evans.
33 This driver is for the Apricot 82596 bus-master interface
35 Modularised 12/94 Mark Evans
38 Modified to support the 82596 ethernet chips on 680x0 VME boards.
39 by Richard Hirst <richard@sleepie.demon.co.uk>
42 980825: Changed to receive directly in to sk_buffs which are
43 allocated at open() time. Eliminates copy on incoming frames
44 (small ones are still copied). Shared data now held in a
45 non-cached page, so we can run on 68060 in copyback mode.
48 * look at deferring rx frames rather than discarding (as per tulip)
49 * handle tx ring full as per tulip
50 * performace test to tune rx_copybreak
52 Most of my modifications relate to the braindead big-endian
53 implementation by Intel. When the i596 is operating in
54 'big-endian' mode, it thinks a 32 bit value of 0x12345678
55 should be stored as 0x56781234. This is a real pain, when
56 you have linked lists which are shared by the 680x0 and the
60 Written 1993 by Donald Becker.
61 Copyright 1993 United States Government as represented by the Director,
62 National Security Agency. This software may only be used and distributed
63 according to the terms of the GNU General Public License as modified by SRC,
64 incorporated herein by reference.
66 The author may be reached as becker@scyld.com, or C/O
67 Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
71 #include <linux/module.h>
72 #include <linux/kernel.h>
73 #include <linux/string.h>
74 #include <linux/ptrace.h>
75 #include <linux/errno.h>
76 #include <linux/ioport.h>
77 #include <linux/slab.h>
78 #include <linux/interrupt.h>
79 #include <linux/delay.h>
80 #include <linux/netdevice.h>
81 #include <linux/etherdevice.h>
82 #include <linux/skbuff.h>
83 #include <linux/init.h>
84 #include <linux/pci.h>
85 #include <linux/types.h>
87 #include <asm/bitops.h>
89 #include <asm/pgtable.h>
92 #include <asm/cache.h>
93 #include <asm/parisc-device.h>
95 static char version[] __devinitdata =
96 "82596.c $Revision: 1.29 $\n";
101 #define DEB_INIT 0x0001
102 #define DEB_PROBE 0x0002
103 #define DEB_SERIOUS 0x0004
104 #define DEB_ERRORS 0x0008
105 #define DEB_MULTI 0x0010
106 #define DEB_TDR 0x0020
107 #define DEB_OPEN 0x0040
108 #define DEB_RESET 0x0080
109 #define DEB_ADDCMD 0x0100
110 #define DEB_STATUS 0x0200
111 #define DEB_STARTTX 0x0400
112 #define DEB_RXADDR 0x0800
113 #define DEB_TXADDR 0x1000
114 #define DEB_RXFRAME 0x2000
115 #define DEB_INTS 0x4000
116 #define DEB_STRUCT 0x8000
117 #define DEB_ANY 0xffff
120 #define DEB(x,y) if (i596_debug & (x)) { y; }
123 #define CHECK_WBACK(addr,len) \
124 do { dma_cache_sync((void *)addr, len, DMA_TO_DEVICE); } while (0)
126 #define CHECK_INV(addr,len) \
127 do { dma_cache_sync((void *)addr,len, DMA_FROM_DEVICE); } while(0)
129 #define CHECK_WBACK_INV(addr,len) \
130 do { dma_cache_sync((void *)addr,len, DMA_BIDIRECTIONAL); } while (0)
133 #define PA_I82596_RESET 0 /* Offsets relative to LASI-LAN-Addr.*/
134 #define PA_CPU_PORT_L_ACCESS 4
135 #define PA_CHANNEL_ATTENTION 8
139 * Define various macros for Channel Attention, word swapping etc., dependent
140 * on architecture. MVME and BVME are 680x0 based, otherwise it is Intel.
144 #define WSWAPrfd(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
145 #define WSWAPrbd(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
146 #define WSWAPiscp(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
147 #define WSWAPscb(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
148 #define WSWAPcmd(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
149 #define WSWAPtbd(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
150 #define WSWAPchar(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
151 #define ISCP_BUSY 0x00010000
152 #define MACH_IS_APRICOT 0
154 #define WSWAPrfd(x) ((struct i596_rfd *)(x))
155 #define WSWAPrbd(x) ((struct i596_rbd *)(x))
156 #define WSWAPiscp(x) ((struct i596_iscp *)(x))
157 #define WSWAPscb(x) ((struct i596_scb *)(x))
158 #define WSWAPcmd(x) ((struct i596_cmd *)(x))
159 #define WSWAPtbd(x) ((struct i596_tbd *)(x))
160 #define WSWAPchar(x) ((char *)(x))
161 #define ISCP_BUSY 0x0001
162 #define MACH_IS_APRICOT 1
166 * The MPU_PORT command allows direct access to the 82596. With PORT access
167 * the following commands are available (p5-18). The 32-bit port command
168 * must be word-swapped with the most significant word written first.
169 * This only applies to VME boards.
171 #define PORT_RESET 0x00 /* reset 82596 */
172 #define PORT_SELFTEST 0x01 /* selftest */
173 #define PORT_ALTSCP 0x02 /* alternate SCB address */
174 #define PORT_ALTDUMP 0x03 /* Alternate DUMP address */
176 static int i596_debug = (DEB_SERIOUS|DEB_PROBE);
178 MODULE_AUTHOR("Richard Hirst");
179 MODULE_DESCRIPTION("i82596 driver");
180 MODULE_LICENSE("GPL");
181 MODULE_PARM(i596_debug, "i");
182 MODULE_PARM_DESC(i596_debug, "lasi_82596 debug mask");
184 /* Copy frames shorter than rx_copybreak, otherwise pass on up in
185 * a full sized sk_buff. Value of 100 stolen from tulip.c (!alpha).
187 static int rx_copybreak = 100;
189 #define MAX_DRIVERS 4 /* max count of drivers */
191 #define PKT_BUF_SZ 1536
192 #define MAX_MC_CNT 64
194 #define I596_NULL ((u32)0xffffffff)
196 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
197 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
198 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
200 #define CMD_FLEX 0x0008 /* Enable flexible memory model */
203 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
204 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7
207 #define STAT_C 0x8000 /* Set to 0 after execution */
208 #define STAT_B 0x4000 /* Command being executed */
209 #define STAT_OK 0x2000 /* Command executed ok */
210 #define STAT_A 0x1000 /* Command aborted */
212 #define CUC_START 0x0100
213 #define CUC_RESUME 0x0200
214 #define CUC_SUSPEND 0x0300
215 #define CUC_ABORT 0x0400
216 #define RX_START 0x0010
217 #define RX_RESUME 0x0020
218 #define RX_SUSPEND 0x0030
219 #define RX_ABORT 0x0040
223 #define OPT_SWAP_PORT 0x0001 /* Need to wordswp on the MPU port */
227 unsigned short porthi;
228 unsigned short portlo;
233 #define SIZE_MASK 0x3fff
240 u32 cache_pad[5]; /* Total 32 bytes... */
243 /* The command structure has two 'next' pointers; v_next is the address of
244 * the next command as seen by the CPU, b_next is the address of the next
245 * command as seen by the 82596. The b_next pointer, as used by the 82596
246 * always references the status field of the next command, rather than the
247 * v_next field, because the 82596 is unaware of v_next. It may seem more
248 * logical to put v_next at the end of the structure, but we cannot do that
249 * because the 82596 expects other fields to be there, depending on command
254 struct i596_cmd *v_next; /* Address from CPUs viewpoint */
255 unsigned short status;
256 unsigned short command;
257 dma_addr_t b_next; /* Address from i596 viewpoint */
265 struct sk_buff *skb; /* So we can free it after tx */
268 u32 cache_pad[6]; /* Total 64 bytes... */
270 u32 cache_pad[1]; /* Total 32 bytes... */
276 unsigned short status;
283 char mc_addrs[MAX_MC_CNT*6];
293 char i596_config[16];
299 dma_addr_t b_next; /* Address from i596 viewpoint */
301 unsigned short count;
303 struct i596_rfd *v_next; /* Address from CPUs viewpoint */
304 struct i596_rfd *v_prev;
306 u32 cache_pad[2]; /* Total 32 bytes... */
312 unsigned short count;
313 unsigned short zero1;
315 dma_addr_t b_data; /* Address from i596 viewpoint */
317 unsigned short zero2;
320 struct i596_rbd *v_next;
321 dma_addr_t b_addr; /* This rbd addr from i596 view */
322 unsigned char *v_data; /* Address from CPUs viewpoint */
323 /* Total 32 bytes... */
329 /* These values as chosen so struct i596_private fits in one page... */
331 #define TX_RING_SIZE 32
332 #define RX_RING_SIZE 16
335 unsigned short status;
336 unsigned short command;
346 unsigned short t_off;
360 struct i596_private {
361 volatile struct i596_scp scp __attribute__((aligned(32)));
362 volatile struct i596_iscp iscp __attribute__((aligned(32)));
363 volatile struct i596_scb scb __attribute__((aligned(32)));
364 struct sa_cmd sa_cmd __attribute__((aligned(32)));
365 struct cf_cmd cf_cmd __attribute__((aligned(32)));
366 struct tdr_cmd tdr_cmd __attribute__((aligned(32)));
367 struct mc_cmd mc_cmd __attribute__((aligned(32)));
368 struct i596_rfd rfds[RX_RING_SIZE] __attribute__((aligned(32)));
369 struct i596_rbd rbds[RX_RING_SIZE] __attribute__((aligned(32)));
370 struct tx_cmd tx_cmds[TX_RING_SIZE] __attribute__((aligned(32)));
371 struct i596_tbd tbds[TX_RING_SIZE] __attribute__((aligned(32)));
374 struct i596_rfd *rfd_head;
375 struct i596_rbd *rbd_head;
376 struct i596_cmd *cmd_tail;
377 struct i596_cmd *cmd_head;
380 struct net_device_stats stats;
388 static char init_setup[] =
390 0x8E, /* length, prefetch on */
391 0xC8, /* fifo to 8, monitor off */
392 0x80, /* don't save bad frames */
393 0x2E, /* No source address insertion, 8 byte preamble */
394 0x00, /* priority and backoff defaults */
395 0x60, /* interframe spacing */
396 0x00, /* slot time LSB */
397 0xf2, /* slot time and retries */
398 0x00, /* promiscuous mode */
399 0x00, /* collision detect */
400 0x40, /* minimum frame length */
403 0x7f /* *multi IA */ };
405 static int i596_open(struct net_device *dev);
406 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
407 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs);
408 static int i596_close(struct net_device *dev);
409 static struct net_device_stats *i596_get_stats(struct net_device *dev);
410 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
411 static void i596_tx_timeout (struct net_device *dev);
412 static void print_eth(unsigned char *buf, char *str);
413 static void set_multicast_list(struct net_device *dev);
415 static int rx_ring_size = RX_RING_SIZE;
416 static int ticks_limit = 100;
417 static int max_cmd_backlog = TX_RING_SIZE-1;
420 static inline void CA(struct net_device *dev)
422 gsc_writel(0, dev->base_addr + PA_CHANNEL_ATTENTION);
426 static inline void MPU_PORT(struct net_device *dev, int c, dma_addr_t x)
428 struct i596_private *lp = dev->priv;
430 u32 v = (u32) (c) | (u32) (x);
433 if (lp->options & OPT_SWAP_PORT) {
441 gsc_writel(a, dev->base_addr + PA_CPU_PORT_L_ACCESS);
443 gsc_writel(b, dev->base_addr + PA_CPU_PORT_L_ACCESS);
447 static inline int wait_istat(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
449 CHECK_INV(&(lp->iscp), sizeof(struct i596_iscp));
450 while (--delcnt && lp->iscp.stat) {
452 CHECK_INV(&(lp->iscp), sizeof(struct i596_iscp));
455 printk("%s: %s, iscp.stat %04x, didn't clear\n",
456 dev->name, str, lp->iscp.stat);
464 static inline int wait_cmd(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
466 CHECK_INV(&(lp->scb), sizeof(struct i596_scb));
467 while (--delcnt && lp->scb.command) {
469 CHECK_INV(&(lp->scb), sizeof(struct i596_scb));
472 printk("%s: %s, status %4.4x, cmd %4.4x.\n",
473 dev->name, str, lp->scb.status, lp->scb.command);
481 static void i596_display_data(struct net_device *dev)
483 struct i596_private *lp = dev->priv;
484 struct i596_cmd *cmd;
485 struct i596_rfd *rfd;
486 struct i596_rbd *rbd;
488 printk("lp and scp at %p, .sysbus = %08x, .iscp = %08x\n",
489 &lp->scp, lp->scp.sysbus, lp->scp.iscp);
490 printk("iscp at %p, iscp.stat = %08x, .scb = %08x\n",
491 &lp->iscp, lp->iscp.stat, lp->iscp.scb);
492 printk("scb at %p, scb.status = %04x, .command = %04x,"
493 " .cmd = %08x, .rfd = %08x\n",
494 &lp->scb, lp->scb.status, lp->scb.command,
495 lp->scb.cmd, lp->scb.rfd);
496 printk(" errors: crc %x, align %x, resource %x,"
497 " over %x, rcvdt %x, short %x\n",
498 lp->scb.crc_err, lp->scb.align_err, lp->scb.resource_err,
499 lp->scb.over_err, lp->scb.rcvdt_err, lp->scb.short_err);
501 while (cmd != NULL) {
502 printk("cmd at %p, .status = %04x, .command = %04x, .b_next = %08x\n",
503 cmd, cmd->status, cmd->command, cmd->b_next);
507 printk("rfd_head = %p\n", rfd);
509 printk (" %p .stat %04x, .cmd %04x, b_next %08x, rbd %08x,"
511 rfd, rfd->stat, rfd->cmd, rfd->b_next, rfd->rbd,
514 } while (rfd != lp->rfd_head);
516 printk("rbd_head = %p\n", rbd);
518 printk(" %p .count %04x, b_next %08x, b_data %08x, size %04x\n",
519 rbd, rbd->count, rbd->b_next, rbd->b_data, rbd->size);
521 } while (rbd != lp->rbd_head);
522 CHECK_INV(lp, sizeof(struct i596_private));
526 #if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
527 static void i596_error(int irq, void *dev_id, struct pt_regs *regs)
529 struct net_device *dev = dev_id;
530 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
534 printk("%s: Error interrupt\n", dev->name);
535 i596_display_data(dev);
539 #define virt_to_dma(lp,v) ((lp)->dma_addr + (dma_addr_t)((unsigned long)(v)-(unsigned long)(lp)))
541 static inline void init_rx_bufs(struct net_device *dev)
543 struct i596_private *lp = dev->priv;
545 struct i596_rfd *rfd;
546 struct i596_rbd *rbd;
548 /* First build the Receive Buffer Descriptor List */
550 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
552 struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ + 4);
555 panic("82596: alloc_skb() failed");
557 dma_addr = dma_map_single(lp->dev, skb->tail,PKT_BUF_SZ,
561 rbd->b_next = WSWAPrbd(virt_to_dma(lp,rbd+1));
562 rbd->b_addr = WSWAPrbd(virt_to_dma(lp,rbd));
564 rbd->v_data = skb->tail;
565 rbd->b_data = WSWAPchar(dma_addr);
566 rbd->size = PKT_BUF_SZ;
568 lp->rbd_head = lp->rbds;
569 rbd = lp->rbds + rx_ring_size - 1;
570 rbd->v_next = lp->rbds;
571 rbd->b_next = WSWAPrbd(virt_to_dma(lp,lp->rbds));
573 /* Now build the Receive Frame Descriptor List */
575 for (i = 0, rfd = lp->rfds; i < rx_ring_size; i++, rfd++) {
576 rfd->rbd = I596_NULL;
579 rfd->b_next = WSWAPrfd(virt_to_dma(lp,rfd+1));
582 lp->rfd_head = lp->rfds;
583 lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
585 rfd->rbd = WSWAPrbd(virt_to_dma(lp,lp->rbd_head));
586 rfd->v_prev = lp->rfds + rx_ring_size - 1;
587 rfd = lp->rfds + rx_ring_size - 1;
588 rfd->v_next = lp->rfds;
589 rfd->b_next = WSWAPrfd(virt_to_dma(lp,lp->rfds));
590 rfd->cmd = CMD_EOL|CMD_FLEX;
592 CHECK_WBACK_INV(lp, sizeof(struct i596_private));
595 static inline void remove_rx_bufs(struct net_device *dev)
597 struct i596_private *lp = dev->priv;
598 struct i596_rbd *rbd;
601 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
602 if (rbd->skb == NULL)
604 dma_unmap_single(lp->dev,
605 (dma_addr_t)WSWAPchar(rbd->b_data),
606 PKT_BUF_SZ, DMA_FROM_DEVICE);
607 dev_kfree_skb(rbd->skb);
612 static void rebuild_rx_bufs(struct net_device *dev)
614 struct i596_private *lp = dev->priv;
617 /* Ensure rx frame/buffer descriptors are tidy */
619 for (i = 0; i < rx_ring_size; i++) {
620 lp->rfds[i].rbd = I596_NULL;
621 lp->rfds[i].cmd = CMD_FLEX;
623 lp->rfds[rx_ring_size-1].cmd = CMD_EOL|CMD_FLEX;
624 lp->rfd_head = lp->rfds;
625 lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
626 lp->rbd_head = lp->rbds;
627 lp->rfds[0].rbd = WSWAPrbd(virt_to_dma(lp,lp->rbds));
629 CHECK_WBACK_INV(lp, sizeof(struct i596_private));
633 static int init_i596_mem(struct net_device *dev)
635 struct i596_private *lp = dev->priv;
638 disable_irq(dev->irq); /* disable IRQs from LAN */
640 printk("RESET 82596 port: %08lX (with IRQ%d disabled)\n",
641 dev->base_addr + PA_I82596_RESET,
644 gsc_writel(0, (void*)(dev->base_addr + PA_I82596_RESET)); /* Hard Reset */
645 udelay(100); /* Wait 100us - seems to help */
647 /* change the scp address */
649 lp->last_cmd = jiffies;
652 lp->scp.sysbus = 0x0000006c;
653 lp->scp.iscp = WSWAPiscp(virt_to_dma(lp,&(lp->iscp)));
654 lp->iscp.scb = WSWAPscb(virt_to_dma(lp,&(lp->scb)));
655 lp->iscp.stat = ISCP_BUSY;
659 lp->scb.cmd = I596_NULL;
661 DEB(DEB_INIT,printk("%s: starting i82596.\n", dev->name));
663 CHECK_WBACK(&(lp->scp), sizeof(struct i596_scp));
664 CHECK_WBACK(&(lp->iscp), sizeof(struct i596_iscp));
666 MPU_PORT(dev, PORT_ALTSCP, virt_to_dma(lp,&lp->scp));
670 if (wait_istat(dev,lp,1000,"initialization timed out"))
672 DEB(DEB_INIT,printk("%s: i82596 initialization successful\n", dev->name));
674 /* Ensure rx frame/buffer descriptors are tidy */
675 rebuild_rx_bufs(dev);
678 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
680 enable_irq(dev->irq); /* enable IRQs from LAN */
682 DEB(DEB_INIT,printk("%s: queuing CmdConfigure\n", dev->name));
683 memcpy(lp->cf_cmd.i596_config, init_setup, 14);
684 lp->cf_cmd.cmd.command = CmdConfigure;
685 CHECK_WBACK(&(lp->cf_cmd), sizeof(struct cf_cmd));
686 i596_add_cmd(dev, &lp->cf_cmd.cmd);
688 DEB(DEB_INIT,printk("%s: queuing CmdSASetup\n", dev->name));
689 memcpy(lp->sa_cmd.eth_addr, dev->dev_addr, 6);
690 lp->sa_cmd.cmd.command = CmdSASetup;
691 CHECK_WBACK(&(lp->sa_cmd), sizeof(struct sa_cmd));
692 i596_add_cmd(dev, &lp->sa_cmd.cmd);
694 DEB(DEB_INIT,printk("%s: queuing CmdTDR\n", dev->name));
695 lp->tdr_cmd.cmd.command = CmdTDR;
696 CHECK_WBACK(&(lp->tdr_cmd), sizeof(struct tdr_cmd));
697 i596_add_cmd(dev, &lp->tdr_cmd.cmd);
699 spin_lock_irqsave (&lp->lock, flags);
701 if (wait_cmd(dev,lp,1000,"timed out waiting to issue RX_START")) {
702 spin_unlock_irqrestore (&lp->lock, flags);
705 DEB(DEB_INIT,printk("%s: Issuing RX_START\n", dev->name));
706 lp->scb.command = RX_START;
707 lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
708 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
712 spin_unlock_irqrestore (&lp->lock, flags);
714 if (wait_cmd(dev,lp,1000,"RX_START not processed"))
716 DEB(DEB_INIT,printk("%s: Receive unit started OK\n", dev->name));
721 printk("%s: Failed to initialise 82596\n", dev->name);
722 MPU_PORT(dev, PORT_RESET, 0);
727 static inline int i596_rx(struct net_device *dev)
729 struct i596_private *lp = dev->priv;
730 struct i596_rfd *rfd;
731 struct i596_rbd *rbd;
734 DEB(DEB_RXFRAME,printk ("i596_rx(), rfd_head %p, rbd_head %p\n",
735 lp->rfd_head, lp->rbd_head));
738 rfd = lp->rfd_head; /* Ref next frame to check */
740 CHECK_INV(rfd, sizeof(struct i596_rfd));
741 while ((rfd->stat) & STAT_C) { /* Loop while complete frames */
742 if (rfd->rbd == I596_NULL)
744 else if (rfd->rbd == lp->rbd_head->b_addr) {
746 CHECK_INV(rbd, sizeof(struct i596_rbd));
749 printk("%s: rbd chain broken!\n", dev->name);
753 DEB(DEB_RXFRAME, printk(" rfd %p, rfd.rbd %08x, rfd.stat %04x\n",
754 rfd, rfd->rbd, rfd->stat));
756 if (rbd != NULL && ((rfd->stat) & STAT_OK)) {
758 int pkt_len = rbd->count & 0x3fff;
759 struct sk_buff *skb = rbd->skb;
762 DEB(DEB_RXADDR,print_eth(rbd->v_data, "received"));
765 /* Check if the packet is long enough to just accept
766 * without copying to a properly sized skbuff.
769 if (pkt_len > rx_copybreak) {
770 struct sk_buff *newskb;
773 dma_unmap_single(lp->dev,(dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
774 /* Get fresh skbuff to replace filled one. */
775 newskb = dev_alloc_skb(PKT_BUF_SZ + 4);
776 if (newskb == NULL) {
777 skb = NULL; /* drop pkt */
780 skb_reserve(newskb, 2);
782 /* Pass up the skb already on the Rx ring. */
783 skb_put(skb, pkt_len);
787 dma_addr = dma_map_single(lp->dev, newskb->tail, PKT_BUF_SZ, DMA_FROM_DEVICE);
788 rbd->v_data = newskb->tail;
789 rbd->b_data = WSWAPchar(dma_addr);
790 CHECK_WBACK_INV(rbd, sizeof(struct i596_rbd));
793 skb = dev_alloc_skb(pkt_len + 2);
796 /* XXX tulip.c can defer packets here!! */
797 printk ("%s: i596_rx Memory squeeze, dropping packet.\n", dev->name);
798 lp->stats.rx_dropped++;
803 /* 16 byte align the data fields */
804 dma_sync_single_for_cpu(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
806 memcpy(skb_put(skb,pkt_len), rbd->v_data, pkt_len);
807 dma_sync_single_for_device(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
810 skb->protocol=eth_type_trans(skb,dev);
812 dev->last_rx = jiffies;
813 lp->stats.rx_packets++;
814 lp->stats.rx_bytes+=pkt_len;
818 DEB(DEB_ERRORS, printk("%s: Error, rfd.stat = 0x%04x\n",
819 dev->name, rfd->stat));
820 lp->stats.rx_errors++;
821 if ((rfd->stat) & 0x0001)
822 lp->stats.collisions++;
823 if ((rfd->stat) & 0x0080)
824 lp->stats.rx_length_errors++;
825 if ((rfd->stat) & 0x0100)
826 lp->stats.rx_over_errors++;
827 if ((rfd->stat) & 0x0200)
828 lp->stats.rx_fifo_errors++;
829 if ((rfd->stat) & 0x0400)
830 lp->stats.rx_frame_errors++;
831 if ((rfd->stat) & 0x0800)
832 lp->stats.rx_crc_errors++;
833 if ((rfd->stat) & 0x1000)
834 lp->stats.rx_length_errors++;
837 /* Clear the buffer descriptor count and EOF + F flags */
839 if (rbd != NULL && (rbd->count & 0x4000)) {
841 lp->rbd_head = rbd->v_next;
842 CHECK_WBACK_INV(rbd, sizeof(struct i596_rbd));
845 /* Tidy the frame descriptor, marking it as end of list */
847 rfd->rbd = I596_NULL;
849 rfd->cmd = CMD_EOL|CMD_FLEX;
852 /* Remove end-of-list from old end descriptor */
854 rfd->v_prev->cmd = CMD_FLEX;
856 /* Update record of next frame descriptor to process */
858 lp->scb.rfd = rfd->b_next;
859 lp->rfd_head = rfd->v_next;
860 CHECK_WBACK_INV(rfd->v_prev, sizeof(struct i596_rfd));
861 CHECK_WBACK_INV(rfd, sizeof(struct i596_rfd));
863 CHECK_INV(rfd, sizeof(struct i596_rfd));
866 DEB(DEB_RXFRAME,printk ("frames %d\n", frames));
872 static inline void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
874 struct i596_cmd *ptr;
876 while (lp->cmd_head != NULL) {
878 lp->cmd_head = ptr->v_next;
881 switch ((ptr->command) & 0x7) {
884 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
885 struct sk_buff *skb = tx_cmd->skb;
886 dma_unmap_single(lp->dev, tx_cmd->dma_addr, skb->len, DMA_TO_DEVICE);
890 lp->stats.tx_errors++;
891 lp->stats.tx_aborted_errors++;
894 ptr->b_next = I596_NULL;
895 tx_cmd->cmd.command = 0; /* Mark as free */
900 ptr->b_next = I596_NULL;
902 CHECK_WBACK_INV(ptr, sizeof(struct i596_cmd));
905 wait_cmd(dev,lp,100,"i596_cleanup_cmd timed out");
906 lp->scb.cmd = I596_NULL;
907 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
911 static inline void i596_reset(struct net_device *dev, struct i596_private *lp)
915 DEB(DEB_RESET,printk("i596_reset\n"));
917 spin_lock_irqsave (&lp->lock, flags);
919 wait_cmd(dev,lp,100,"i596_reset timed out");
921 netif_stop_queue(dev);
923 /* FIXME: this command might cause an lpmc */
924 lp->scb.command = CUC_ABORT | RX_ABORT;
925 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
928 /* wait for shutdown */
929 wait_cmd(dev,lp,1000,"i596_reset 2 timed out");
930 spin_unlock_irqrestore (&lp->lock, flags);
932 i596_cleanup_cmd(dev,lp);
935 netif_start_queue(dev);
940 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
942 struct i596_private *lp = dev->priv;
945 DEB(DEB_ADDCMD,printk("i596_add_cmd cmd_head %p\n", lp->cmd_head));
948 cmd->command |= (CMD_EOL | CMD_INTR);
950 cmd->b_next = I596_NULL;
951 CHECK_WBACK(cmd, sizeof(struct i596_cmd));
953 spin_lock_irqsave (&lp->lock, flags);
955 if (lp->cmd_head != NULL) {
956 lp->cmd_tail->v_next = cmd;
957 lp->cmd_tail->b_next = WSWAPcmd(virt_to_dma(lp,&cmd->status));
958 CHECK_WBACK(lp->cmd_tail, sizeof(struct i596_cmd));
961 wait_cmd(dev,lp,100,"i596_add_cmd timed out");
962 lp->scb.cmd = WSWAPcmd(virt_to_dma(lp,&cmd->status));
963 lp->scb.command = CUC_START;
964 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
970 spin_unlock_irqrestore (&lp->lock, flags);
972 if (lp->cmd_backlog > max_cmd_backlog) {
973 unsigned long tickssofar = jiffies - lp->last_cmd;
975 if (tickssofar < ticks_limit)
978 printk("%s: command unit timed out, status resetting.\n", dev->name);
986 /* this function makes a perfectly adequate probe... but we have a
988 static int i596_test(struct net_device *dev)
990 struct i596_private *lp = dev->priv;
994 tint = (volatile int *)(&(lp->scp));
995 data = virt_to_dma(lp,tint);
998 CHECK_WBACK(tint,PAGE_SIZE);
1000 MPU_PORT(dev, 1, data);
1002 for(data = 1000000; data; data--) {
1003 CHECK_INV(tint,PAGE_SIZE);
1009 printk("i596_test result %d\n", tint[1]);
1015 static int i596_open(struct net_device *dev)
1017 DEB(DEB_OPEN,printk("%s: i596_open() irq %d.\n", dev->name, dev->irq));
1019 if (request_irq(dev->irq, &i596_interrupt, 0, "i82596", dev)) {
1020 printk("%s: IRQ %d not free\n", dev->name, dev->irq);
1026 if (init_i596_mem(dev)) {
1027 printk("%s: Failed to init memory\n", dev->name);
1028 goto out_remove_rx_bufs;
1031 netif_start_queue(dev);
1036 remove_rx_bufs(dev);
1037 free_irq(dev->irq, dev);
1042 static void i596_tx_timeout (struct net_device *dev)
1044 struct i596_private *lp = dev->priv;
1046 /* Transmitter timeout, serious problems. */
1047 DEB(DEB_ERRORS,printk("%s: transmit timed out, status resetting.\n",
1050 lp->stats.tx_errors++;
1052 /* Try to restart the adaptor */
1053 if (lp->last_restart == lp->stats.tx_packets) {
1054 DEB(DEB_ERRORS,printk ("Resetting board.\n"));
1055 /* Shutdown and restart */
1056 i596_reset (dev, lp);
1058 /* Issue a channel attention signal */
1059 DEB(DEB_ERRORS,printk ("Kicking board.\n"));
1060 lp->scb.command = CUC_START | RX_START;
1061 CHECK_WBACK_INV(&(lp->scb), sizeof(struct i596_scb));
1063 lp->last_restart = lp->stats.tx_packets;
1066 dev->trans_start = jiffies;
1067 netif_wake_queue (dev);
1071 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
1073 struct i596_private *lp = dev->priv;
1074 struct tx_cmd *tx_cmd;
1075 struct i596_tbd *tbd;
1076 short length = skb->len;
1077 dev->trans_start = jiffies;
1079 DEB(DEB_STARTTX,printk("%s: i596_start_xmit(%x,%p) called\n", dev->name,
1080 skb->len, skb->data));
1082 if (length < ETH_ZLEN) {
1083 skb = skb_padto(skb, ETH_ZLEN);
1089 netif_stop_queue(dev);
1091 tx_cmd = lp->tx_cmds + lp->next_tx_cmd;
1092 tbd = lp->tbds + lp->next_tx_cmd;
1094 if (tx_cmd->cmd.command) {
1095 DEB(DEB_ERRORS,printk ("%s: xmit ring full, dropping packet.\n",
1097 lp->stats.tx_dropped++;
1101 if (++lp->next_tx_cmd == TX_RING_SIZE)
1102 lp->next_tx_cmd = 0;
1103 tx_cmd->tbd = WSWAPtbd(virt_to_dma(lp,tbd));
1104 tbd->next = I596_NULL;
1106 tx_cmd->cmd.command = CMD_FLEX | CmdTx;
1112 tbd->size = EOF | length;
1114 tx_cmd->dma_addr = dma_map_single(lp->dev, skb->data, skb->len,
1116 tbd->data = WSWAPchar(tx_cmd->dma_addr);
1118 DEB(DEB_TXADDR,print_eth(skb->data, "tx-queued"));
1119 CHECK_WBACK_INV(tx_cmd, sizeof(struct tx_cmd));
1120 CHECK_WBACK_INV(tbd, sizeof(struct i596_tbd));
1121 i596_add_cmd(dev, &tx_cmd->cmd);
1123 lp->stats.tx_packets++;
1124 lp->stats.tx_bytes += length;
1127 netif_start_queue(dev);
1132 static void print_eth(unsigned char *add, char *str)
1136 printk("i596 0x%p, ", add);
1137 for (i = 0; i < 6; i++)
1138 printk(" %02X", add[i + 6]);
1140 for (i = 0; i < 6; i++)
1141 printk(" %02X", add[i]);
1142 printk(" %02X%02X, %s\n", add[12], add[13], str);
1146 #define LAN_PROM_ADDR 0xF0810000
1148 static int __devinit i82596_probe(struct net_device *dev,
1149 struct device *gen_dev)
1152 struct i596_private *lp;
1154 dma_addr_t dma_addr;
1156 /* This lot is ensure things have been cache line aligned. */
1157 if (sizeof(struct i596_rfd) != 32) {
1158 printk("82596: sizeof(struct i596_rfd) = %d\n",
1159 sizeof(struct i596_rfd));
1162 if ((sizeof(struct i596_rbd) % 32) != 0) {
1163 printk("82596: sizeof(struct i596_rbd) = %d\n",
1164 sizeof(struct i596_rbd));
1167 if ((sizeof(struct tx_cmd) % 32) != 0) {
1168 printk("82596: sizeof(struct tx_cmd) = %d\n",
1169 sizeof(struct tx_cmd));
1172 if (sizeof(struct i596_tbd) != 32) {
1173 printk("82596: sizeof(struct i596_tbd) = %d\n",
1174 sizeof(struct i596_tbd));
1178 if (sizeof(struct i596_private) > 4096) {
1179 printk("82596: sizeof(struct i596_private) = %d\n",
1180 sizeof(struct i596_private));
1185 if (!dev->base_addr || !dev->irq)
1188 if (pdc_lan_station_id(eth_addr, dev->base_addr)) {
1189 for (i=0; i < 6; i++) {
1190 eth_addr[i] = gsc_readb(LAN_PROM_ADDR + i);
1192 printk("82596.c: MAC of HP700 LAN read from EEPROM\n");
1195 dev->mem_start = (unsigned long) dma_alloc_noncoherent(gen_dev,
1196 sizeof(struct i596_private), &dma_addr, GFP_KERNEL);
1197 if (!dev->mem_start) {
1198 printk("%s: Couldn't get shared memory\n", dev->name);
1202 DEB(DEB_PROBE,printk("%s: 82596 at %#3lx,", dev->name, dev->base_addr));
1204 for (i = 0; i < 6; i++)
1205 DEB(DEB_PROBE,printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]));
1207 DEB(DEB_PROBE,printk(" IRQ %d.\n", dev->irq));
1209 DEB(DEB_PROBE,printk(version));
1211 /* The 82596-specific entries in the device structure. */
1212 dev->open = i596_open;
1213 dev->stop = i596_close;
1214 dev->hard_start_xmit = i596_start_xmit;
1215 dev->get_stats = i596_get_stats;
1216 dev->set_multicast_list = set_multicast_list;
1217 dev->tx_timeout = i596_tx_timeout;
1218 dev->watchdog_timeo = TX_TIMEOUT;
1220 dev->priv = (void *)(dev->mem_start);
1223 DEB(DEB_INIT,printk ("%s: lp at 0x%08lx (%d bytes), lp->scb at 0x%08lx\n",
1224 dev->name, (unsigned long)lp,
1225 sizeof(struct i596_private), (unsigned long)&lp->scb));
1226 memset(lp, 0, sizeof(struct i596_private));
1228 lp->scb.command = 0;
1229 lp->scb.cmd = I596_NULL;
1230 lp->scb.rfd = I596_NULL;
1231 lp->lock = SPIN_LOCK_UNLOCKED;
1232 lp->dma_addr = dma_addr;
1235 CHECK_WBACK_INV(dev->mem_start, sizeof(struct i596_private));
1241 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1243 struct net_device *dev = dev_id;
1244 struct i596_private *lp;
1245 unsigned short status, ack_cmd = 0;
1248 printk("i596_interrupt(): irq %d for unknown device.\n", irq);
1254 spin_lock (&lp->lock);
1256 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1257 status = lp->scb.status;
1259 DEB(DEB_INTS,printk("%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1260 dev->name, irq, status));
1262 ack_cmd = status & 0xf000;
1265 DEB(DEB_ERRORS, printk("%s: interrupt with no events\n", dev->name));
1266 spin_unlock (&lp->lock);
1270 if ((status & 0x8000) || (status & 0x2000)) {
1271 struct i596_cmd *ptr;
1273 if ((status & 0x8000))
1274 DEB(DEB_INTS,printk("%s: i596 interrupt completed command.\n", dev->name));
1275 if ((status & 0x2000))
1276 DEB(DEB_INTS,printk("%s: i596 interrupt command unit inactive %x.\n", dev->name, status & 0x0700));
1278 while (lp->cmd_head != NULL) {
1279 CHECK_INV(lp->cmd_head, sizeof(struct i596_cmd));
1280 if (!(lp->cmd_head->status & STAT_C))
1285 DEB(DEB_STATUS,printk("cmd_head->status = %04x, ->command = %04x\n",
1286 lp->cmd_head->status, lp->cmd_head->command));
1287 lp->cmd_head = ptr->v_next;
1290 switch ((ptr->command) & 0x7) {
1293 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1294 struct sk_buff *skb = tx_cmd->skb;
1296 if ((ptr->status) & STAT_OK) {
1297 DEB(DEB_TXADDR,print_eth(skb->data, "tx-done"));
1299 lp->stats.tx_errors++;
1300 if ((ptr->status) & 0x0020)
1301 lp->stats.collisions++;
1302 if (!((ptr->status) & 0x0040))
1303 lp->stats.tx_heartbeat_errors++;
1304 if ((ptr->status) & 0x0400)
1305 lp->stats.tx_carrier_errors++;
1306 if ((ptr->status) & 0x0800)
1307 lp->stats.collisions++;
1308 if ((ptr->status) & 0x1000)
1309 lp->stats.tx_aborted_errors++;
1311 dma_unmap_single(lp->dev, tx_cmd->dma_addr, skb->len, DMA_TO_DEVICE);
1312 dev_kfree_skb_irq(skb);
1314 tx_cmd->cmd.command = 0; /* Mark free */
1319 unsigned short status = ((struct tdr_cmd *)ptr)->status;
1321 if (status & 0x8000) {
1322 DEB(DEB_ANY,printk("%s: link ok.\n", dev->name));
1324 if (status & 0x4000)
1325 printk("%s: Transceiver problem.\n", dev->name);
1326 if (status & 0x2000)
1327 printk("%s: Termination problem.\n", dev->name);
1328 if (status & 0x1000)
1329 printk("%s: Short circuit.\n", dev->name);
1331 DEB(DEB_TDR,printk("%s: Time %d.\n", dev->name, status & 0x07ff));
1336 /* Zap command so set_multicast_list() knows it is free */
1341 ptr->b_next = I596_NULL;
1342 CHECK_WBACK(ptr, sizeof(struct i596_cmd));
1343 lp->last_cmd = jiffies;
1346 /* This mess is arranging that only the last of any outstanding
1347 * commands has the interrupt bit set. Should probably really
1348 * only add to the cmd queue when the CU is stopped.
1351 while ((ptr != NULL) && (ptr != lp->cmd_tail)) {
1352 struct i596_cmd *prev = ptr;
1354 ptr->command &= 0x1fff;
1356 CHECK_WBACK_INV(prev, sizeof(struct i596_cmd));
1359 if ((lp->cmd_head != NULL))
1360 ack_cmd |= CUC_START;
1361 lp->scb.cmd = WSWAPcmd(virt_to_dma(lp,&lp->cmd_head->status));
1362 CHECK_WBACK_INV(&lp->scb, sizeof(struct i596_scb));
1364 if ((status & 0x1000) || (status & 0x4000)) {
1365 if ((status & 0x4000))
1366 DEB(DEB_INTS,printk("%s: i596 interrupt received a frame.\n", dev->name));
1368 /* Only RX_START if stopped - RGH 07-07-96 */
1369 if (status & 0x1000) {
1370 if (netif_running(dev)) {
1371 DEB(DEB_ERRORS,printk("%s: i596 interrupt receive unit inactive, status 0x%x\n", dev->name, status));
1372 ack_cmd |= RX_START;
1373 lp->stats.rx_errors++;
1374 lp->stats.rx_fifo_errors++;
1375 rebuild_rx_bufs(dev);
1379 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1380 lp->scb.command = ack_cmd;
1381 CHECK_WBACK(&lp->scb, sizeof(struct i596_scb));
1383 /* DANGER: I suspect that some kind of interrupt
1384 acknowledgement aside from acking the 82596 might be needed
1385 here... but it's running acceptably without */
1389 wait_cmd(dev,lp,100,"i596 interrupt, exit timeout");
1390 DEB(DEB_INTS,printk("%s: exiting interrupt.\n", dev->name));
1392 spin_unlock (&lp->lock);
1396 static int i596_close(struct net_device *dev)
1398 struct i596_private *lp = dev->priv;
1399 unsigned long flags;
1401 netif_stop_queue(dev);
1403 DEB(DEB_INIT,printk("%s: Shutting down ethercard, status was %4.4x.\n",
1404 dev->name, lp->scb.status));
1406 spin_lock_irqsave(&lp->lock, flags);
1408 wait_cmd(dev,lp,100,"close1 timed out");
1409 lp->scb.command = CUC_ABORT | RX_ABORT;
1410 CHECK_WBACK(&lp->scb, sizeof(struct i596_scb));
1414 wait_cmd(dev,lp,100,"close2 timed out");
1415 spin_unlock_irqrestore(&lp->lock, flags);
1416 DEB(DEB_STRUCT,i596_display_data(dev));
1417 i596_cleanup_cmd(dev,lp);
1419 disable_irq(dev->irq);
1421 free_irq(dev->irq, dev);
1422 remove_rx_bufs(dev);
1429 static struct net_device_stats *
1430 i596_get_stats(struct net_device *dev)
1432 struct i596_private *lp = dev->priv;
1438 * Set or clear the multicast filter for this adaptor.
1441 static void set_multicast_list(struct net_device *dev)
1443 struct i596_private *lp = dev->priv;
1444 int config = 0, cnt;
1446 DEB(DEB_MULTI,printk("%s: set multicast list, %d entries, promisc %s, allmulti %s\n", dev->name, dev->mc_count, dev->flags & IFF_PROMISC ? "ON" : "OFF", dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1448 if ((dev->flags & IFF_PROMISC) && !(lp->cf_cmd.i596_config[8] & 0x01)) {
1449 lp->cf_cmd.i596_config[8] |= 0x01;
1452 if (!(dev->flags & IFF_PROMISC) && (lp->cf_cmd.i596_config[8] & 0x01)) {
1453 lp->cf_cmd.i596_config[8] &= ~0x01;
1456 if ((dev->flags & IFF_ALLMULTI) && (lp->cf_cmd.i596_config[11] & 0x20)) {
1457 lp->cf_cmd.i596_config[11] &= ~0x20;
1460 if (!(dev->flags & IFF_ALLMULTI) && !(lp->cf_cmd.i596_config[11] & 0x20)) {
1461 lp->cf_cmd.i596_config[11] |= 0x20;
1465 if (lp->cf_cmd.cmd.command)
1466 printk("%s: config change request already queued\n",
1469 lp->cf_cmd.cmd.command = CmdConfigure;
1470 CHECK_WBACK_INV(&lp->cf_cmd, sizeof(struct cf_cmd));
1471 i596_add_cmd(dev, &lp->cf_cmd.cmd);
1475 cnt = dev->mc_count;
1476 if (cnt > MAX_MC_CNT)
1479 printk("%s: Only %d multicast addresses supported",
1483 if (dev->mc_count > 0) {
1484 struct dev_mc_list *dmi;
1489 cmd->cmd.command = CmdMulticastList;
1490 cmd->mc_cnt = dev->mc_count * 6;
1492 for (dmi = dev->mc_list; cnt && dmi != NULL; dmi = dmi->next, cnt--, cp += 6) {
1493 memcpy(cp, dmi->dmi_addr, 6);
1495 DEB(DEB_MULTI,printk("%s: Adding address %02x:%02x:%02x:%02x:%02x:%02x\n",
1496 dev->name, cp[0],cp[1],cp[2],cp[3],cp[4],cp[5]));
1498 CHECK_WBACK_INV(&lp->mc_cmd, sizeof(struct mc_cmd));
1499 i596_add_cmd(dev, &cmd->cmd);
1503 MODULE_PARM(debug, "i");
1504 MODULE_PARM_DESC(debug, "lasi_82596 debug mask");
1505 static int debug = -1;
1507 static int num_drivers;
1508 static struct net_device *netdevs[MAX_DRIVERS];
1510 static int __devinit
1511 lan_init_chip(struct parisc_device *dev)
1513 struct net_device *netdevice;
1516 if (num_drivers >= MAX_DRIVERS) {
1517 /* max count of possible i82596 drivers reached */
1522 printk(KERN_ERR __FILE__ ": IRQ not found for i82596 at 0x%lx\n", dev->hpa);
1526 printk(KERN_INFO "Found i82596 at 0x%lx, IRQ %d\n", dev->hpa, dev->irq);
1528 netdevice = alloc_etherdev(0);
1532 netdevice->base_addr = dev->hpa;
1533 netdevice->irq = dev->irq;
1535 retval = i82596_probe(netdevice, &dev->dev);
1537 free_netdev(netdevice);
1541 retval = register_netdev(netdevice);
1543 struct i596_private *lp = netdevice->priv;
1544 printk(KERN_WARNING __FILE__ ": register_netdevice ret'd %d\n", retval);
1545 dma_free_noncoherent(lp->dev, sizeof(struct i596_private),
1546 (void *)netdevice->mem_start, lp->dma_addr);
1547 free_netdev(netdevice);
1550 if (dev->id.sversion == 0x72) {
1551 ((struct i596_private *)netdevice->priv)->options = OPT_SWAP_PORT;
1554 netdevs[num_drivers++] = netdevice;
1560 static struct parisc_device_id lan_tbl[] = {
1561 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0008a },
1562 { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00072 },
1566 MODULE_DEVICE_TABLE(parisc, lan_tbl);
1568 static struct parisc_driver lan_driver = {
1570 .id_table = lan_tbl,
1571 .probe = lan_init_chip,
1574 static int __devinit lasi_82596_init(void)
1578 return register_parisc_driver(&lan_driver);
1581 module_init(lasi_82596_init);
1583 static void __exit lasi_82596_exit(void)
1587 for (i=0; i<MAX_DRIVERS; i++) {
1588 struct i596_private *lp;
1589 struct net_device *netdevice;
1591 netdevice = netdevs[i];
1595 unregister_netdev(netdevice);
1597 lp = netdevice->priv;
1598 dma_free_noncoherent(lp->dev, sizeof(struct i596_private),
1599 (void *)netdevice->mem_start, lp->dma_addr);
1600 free_netdev(netdevice);
1603 unregister_parisc_driver(&lan_driver);
1606 module_exit(lasi_82596_exit);