1 /* Intel Professional Workstation/panther ethernet driver */
2 /* lp486e.c: A panther 82596 ethernet driver for linux. */
4 History and copyrights:
7 Written 1993 by Donald Becker.
8 Copyright 1993 United States Government as represented by the Director,
9 National Security Agency. This software may only be used and
10 distributed according to the terms of the GNU General Public License
11 as modified by SRC, incorporated herein by reference.
13 The author may be reached as becker@scyld.com, or C/O
14 Scyld Computing Corporation
15 410 Severn Ave., Suite 210
19 Written 1994 by Mark Evans.
20 This driver is for the Apricot 82596 bus-master interface
22 Modularised 12/94 Mark Evans
24 Professional Workstation
25 Derived from apricot.c by Ard van Breemen
26 <ard@murphy.nl>|<ard@cstmel.hobby.nl>|<ard@cstmel.nl.eu.org>
29 Thanks to Murphy Software BV for letting me write this in their time.
30 Well, actually, I get payed doing this...
31 (Also: see http://www.murphy.nl for murphy, and my homepage ~ard for
32 more information on the Professional Workstation)
38 There are currently two motherboards that I know of in the
39 professional workstation. The only one that I know is the
40 intel panther motherboard. -- ard
43 The pws is equipped with an intel 82596. This is a very intelligent controller
44 which runs its own micro-code. Communication with the hostprocessor is done
45 through linked lists of commands and buffers in the hostprocessors memory.
46 A complete description of the 82596 is available from intel. Search for
47 a file called "29021806.pdf". It is a complete description of the chip itself.
48 To use it for the pws some additions are needed regarding generation of
49 the PORT and CA signal, and the interrupt glue needed for a pc.
51 PORT SIZE ACTION MEANING
52 0xCB0 2 WRITE Lower 16 bits for PORT command
53 0xCB2 2 WRITE Upper 16 bits for PORT command, and issue of PORT command
54 0xCB4 1 WRITE Generation of CA signal
55 0xCB8 1 WRITE Clear interrupt glue
56 All other communication is through memory!
59 #include <linux/module.h>
60 #include <linux/init.h>
61 #include <linux/delay.h>
62 #include <linux/kernel.h>
63 #include <linux/string.h>
64 #include <linux/errno.h>
65 #include <linux/ioport.h>
66 #include <linux/slab.h>
67 #include <linux/interrupt.h>
68 #include <linux/netdevice.h>
69 #include <linux/etherdevice.h>
70 #include <linux/skbuff.h>
71 #include <linux/bitops.h>
76 #define DRV_NAME "lp486e"
78 /* debug print flags */
79 #define LOG_SRCDST 0x80000000
80 #define LOG_STATINT 0x40000000
81 #define LOG_STARTINT 0x20000000
83 #define i596_debug debug
85 static int i596_debug = 0;
87 static const char * const medianame[] = {
89 "10baseT-FD", "AUI-FD",
92 #define LP486E_TOTAL_SIZE 16
94 #define I596_NULL (0xffffffff)
96 #define CMD_EOL 0x8000 /* The last command of the list, stop. */
97 #define CMD_SUSP 0x4000 /* Suspend after doing cmd. */
98 #define CMD_INTR 0x2000 /* Interrupt after doing cmd. */
100 #define CMD_FLEX 0x0008 /* Enable flexible memory model */
106 CmdMulticastList = 3,
114 static const char *CUcmdnames[8] = { "NOP", "IASetup", "Configure", "MulticastList",
115 "Tx", "TDR", "Dump", "Diagnose" };
118 /* Status word bits */
119 #define STAT_CX 0x8000 /* The CU finished executing a command
120 with the Interrupt bit set */
121 #define STAT_FR 0x4000 /* The RU finished receiving a frame */
122 #define STAT_CNA 0x2000 /* The CU left the active state */
123 #define STAT_RNR 0x1000 /* The RU left the active state */
124 #define STAT_ACK (STAT_CX | STAT_FR | STAT_CNA | STAT_RNR)
125 #define STAT_CUS 0x0700 /* Status of CU: 0: idle, 1: suspended,
126 2: active, 3-7: unused */
127 #define STAT_RUS 0x00f0 /* Status of RU: 0: idle, 1: suspended,
128 2: no resources, 4: ready,
129 10: no resources due to no more RBDs,
130 12: no more RBDs, other: unused */
131 #define STAT_T 0x0008 /* Bus throttle timers loaded */
132 #define STAT_ZERO 0x0807 /* Always zero */
135 static char *CUstates[8] = {
136 "idle", "suspended", "active", 0, 0, 0, 0, 0
138 static char *RUstates[16] = {
139 "idle", "suspended", "no resources", 0, "ready", 0, 0, 0,
140 0, 0, "no RBDs", 0, "out of RBDs", 0, 0, 0
144 i596_out_status(int status) {
148 printk("status %4.4x:", status);
149 if (status == 0xffff)
150 printk(" strange..\n");
152 if (status & STAT_CX)
154 if (status & STAT_CNA)
155 printk(" CU stopped");
156 if (status & STAT_FR)
157 printk(" got a frame");
158 if (status & STAT_RNR)
159 printk(" RU stopped");
161 printk(" throttled");
162 if (status & STAT_ZERO)
164 s = CUstates[(status & STAT_CUS) >> 8];
168 printk(" CU(%s)", s);
169 s = RUstates[(status & STAT_RUS) >> 4];
173 printk(" RU(%s)", s);
175 printk(" bad status");
181 /* Command word bits */
182 #define ACK_CX 0x8000
183 #define ACK_FR 0x4000
184 #define ACK_CNA 0x2000
185 #define ACK_RNR 0x1000
187 #define CUC_START 0x0100
188 #define CUC_RESUME 0x0200
189 #define CUC_SUSPEND 0x0300
190 #define CUC_ABORT 0x0400
192 #define RX_START 0x0010
193 #define RX_RESUME 0x0020
194 #define RX_SUSPEND 0x0030
195 #define RX_ABORT 0x0040
197 typedef u32 phys_addr;
199 static inline phys_addr
201 return x ? virt_to_bus(x) : I596_NULL;
205 pa_to_va(phys_addr x) {
206 return (x == I596_NULL) ? NULL : bus_to_virt(x);
209 /* status bits for cmd */
210 #define CMD_STAT_C 0x8000 /* CU command complete */
211 #define CMD_STAT_B 0x4000 /* CU command in progress */
212 #define CMD_STAT_OK 0x2000 /* CU command completed without errors */
213 #define CMD_STAT_A 0x1000 /* CU command abnormally terminated */
215 struct i596_cmd { /* 8 bytes */
216 unsigned short status;
217 unsigned short command;
218 phys_addr pa_next; /* va_to_pa(struct i596_cmd *next) */
222 #define SIZE_MASK 0x3fff
227 phys_addr pa_next; /* va_to_pa(struct i596_tbd *next) */
228 phys_addr pa_data; /* va_to_pa(char *data) */
234 phys_addr pa_tbd; /* va_to_pa(struct i596_tbd *tbd) */
239 /* status bits for rfd */
240 #define RFD_STAT_C 0x8000 /* Frame reception complete */
241 #define RFD_STAT_B 0x4000 /* Frame reception in progress */
242 #define RFD_STAT_OK 0x2000 /* Frame received without errors */
243 #define RFD_STATUS 0x1fff
244 #define RFD_LENGTH_ERR 0x1000
245 #define RFD_CRC_ERR 0x0800
246 #define RFD_ALIGN_ERR 0x0400
247 #define RFD_NOBUFS_ERR 0x0200
248 #define RFD_DMA_ERR 0x0100 /* DMA overrun failure to acquire system bus */
249 #define RFD_SHORT_FRAME_ERR 0x0080
250 #define RFD_NOEOP_ERR 0x0040
251 #define RFD_TRUNC_ERR 0x0020
252 #define RFD_MULTICAST 0x0002 /* 0: destination had our address
253 1: destination was broadcast/multicast */
254 #define RFD_COLLISION 0x0001
256 /* receive frame descriptor */
260 phys_addr pa_next; /* va_to_pa(struct i596_rfd *next) */
261 phys_addr pa_rbd; /* va_to_pa(struct i596_rbd *rbd) */
262 unsigned short count;
267 #define RBD_EL 0x8000
269 #define RBD_SIZEMASK 0x3fff
270 #define RBD_EOF 0x8000
273 /* receive buffer descriptor */
277 phys_addr pa_next; /* va_to_pa(struct i596_tbd *next) */
278 phys_addr pa_data; /* va_to_pa(char *data) */
279 phys_addr pa_prev; /* va_to_pa(struct i596_tbd *prev) */
281 /* Driver private part */
285 #define RX_RING_SIZE 64
286 #define RX_SKBSIZE (ETH_FRAME_LEN+10)
287 #define RX_RBD_SIZE 32
289 /* System Control Block - 40 bytes */
293 phys_addr pa_cmd; /* 4 - va_to_pa(struct i596_cmd *cmd) */
294 phys_addr pa_rfd; /* 8 - va_to_pa(struct i596_rfd *rfd) */
295 u32 crc_err; /* 12 */
296 u32 align_err; /* 16 */
297 u32 resource_err; /* 20 */
298 u32 over_err; /* 24 */
299 u32 rcvdt_err; /* 28 */
300 u32 short_err; /* 32 */
305 /* Intermediate System Configuration Pointer - 8 bytes */
308 phys_addr pa_scb; /* 4 - va_to_pa(struct i596_scb *scb) */
311 /* System Configuration Pointer - 12 bytes */
315 phys_addr pa_iscp; /* 8 - va_to_pa(struct i596_iscp *iscp) */
318 /* Selftest and dump results - needs 16-byte alignment */
320 * The size of the dump area is 304 bytes. When the dump is executed
321 * by the Port command an extra word will be appended to the dump area.
322 * The extra word is a copy of the Dump status word (containing the
323 * C, B, OK bits). [I find 0xa006, with a0 for C+OK and 6 for dump]
326 u16 dump[153]; /* (304 = 130h) + 2 bytes */
329 struct i596_private { /* aligned to a 16-byte boundary */
330 struct i596_scp scp; /* 0 - needs 16-byte alignment */
331 struct i596_iscp iscp; /* 12 */
332 struct i596_scb scb; /* 20 */
334 struct i596_dump dump; /* 64 - needs 16-byte alignment */
336 struct i596_cmd set_add;
337 char eth_addr[8]; /* directly follows set_add */
339 struct i596_cmd set_conf;
340 char i596_config[16]; /* directly follows set_conf */
343 unsigned long tdr_stat; /* directly follows tdr */
346 struct i596_rbd *rbd_list;
347 struct i596_rbd *rbd_tail;
348 struct i596_rfd *rx_tail;
349 struct i596_cmd *cmd_tail;
350 struct i596_cmd *cmd_head;
352 unsigned long last_cmd;
353 struct net_device_stats stats;
357 static char init_setup[14] = {
358 0x8E, /* length 14 bytes, prefetch on */
359 0xC8, /* default: fifo to 8, monitor off */
360 0x40, /* default: don't save bad frames (apricot.c had 0x80) */
361 0x2E, /* (default is 0x26)
362 No source address insertion, 8 byte preamble */
363 0x00, /* default priority and backoff */
364 0x60, /* default interframe spacing */
365 0x00, /* default slot time LSB */
366 0xf2, /* default slot time and nr of retries */
367 0x00, /* default various bits
368 (0: promiscuous mode, 1: broadcast disable,
369 2: encoding mode, 3: transmit on no CRS,
370 4: no CRC insertion, 5: CRC type,
371 6: bit stuffing, 7: padding) */
372 0x00, /* default carrier sense and collision detect */
373 0x40, /* default minimum frame length */
374 0xff, /* (default is 0xff, and that is what apricot.c has;
375 elp486.c has 0xfb: Enable crc append in memory.) */
376 0x00, /* default: not full duplex */
377 0x7f /* (default is 0x3f) multi IA */
380 static int i596_open(struct net_device *dev);
381 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
382 static irqreturn_t i596_interrupt(int irq, void *dev_id);
383 static int i596_close(struct net_device *dev);
384 static struct net_device_stats *i596_get_stats(struct net_device *dev);
385 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
386 static void print_eth(char *);
387 static void set_multicast_list(struct net_device *dev);
388 static void i596_tx_timeout(struct net_device *dev);
391 i596_timeout(struct net_device *dev, char *msg, int ct) {
392 struct i596_private *lp;
395 lp = (struct i596_private *) dev->priv;
396 while (lp->scb.command) {
397 if (--boguscnt == 0) {
398 printk("%s: %s timed out - stat %4.4x, cmd %4.4x\n",
400 lp->scb.status, lp->scb.command);
410 init_rx_bufs(struct net_device *dev, int num) {
411 struct i596_private *lp;
412 struct i596_rfd *rfd;
414 // struct i596_rbd *rbd;
416 lp = (struct i596_private *) dev->priv;
417 lp->scb.pa_rfd = I596_NULL;
419 for (i = 0; i < num; i++) {
420 rfd = kmalloc(sizeof(struct i596_rfd), GFP_KERNEL);
425 rfd->pa_rbd = I596_NULL;
434 rfd->pa_next = lp->scb.pa_rfd;
435 lp->scb.pa_rfd = va_to_pa(rfd);
436 lp->rx_tail->pa_next = lp->scb.pa_rfd;
440 for (i = 0; i<RX_RBD_SIZE; i++) {
441 rbd = kmalloc(sizeof(struct i596_rbd), GFP_KERNEL);
445 rbd->skb = dev_alloc_skb(RX_SKBSIZE);
447 printk("dev_alloc_skb failed");
449 rbd->next = rfd->rbd;
451 rfd->rbd->prev = rbd;
452 rbd->size = RX_SKBSIZE;
454 rbd->size = (RX_SKBSIZE | RBD_EL);
460 printk("Could not kmalloc rbd\n");
463 lp->rbd_tail->next = rfd->rbd;
469 remove_rx_bufs(struct net_device *dev) {
470 struct i596_private *lp;
471 struct i596_rfd *rfd;
473 lp = (struct i596_private *) dev->priv;
474 lp->rx_tail->pa_next = I596_NULL;
477 rfd = pa_to_va(lp->scb.pa_rfd);
478 lp->scb.pa_rfd = rfd->pa_next;
480 } while (rfd != lp->rx_tail);
490 #define PORT_RESET 0x00 /* reset 82596 */
491 #define PORT_SELFTEST 0x01 /* selftest */
492 #define PORT_ALTSCP 0x02 /* alternate SCB address */
493 #define PORT_DUMP 0x03 /* dump */
495 #define IOADDR 0xcb0 /* real constant */
496 #define IRQ 10 /* default IRQ - can be changed by ECU */
498 /* The 82596 requires two 16-bit write cycles for a port command */
500 PORT(phys_addr a, unsigned int cmd) {
502 printk("lp486e.c: PORT: address not aligned\n");
503 outw(((a & 0xffff) | cmd), IOADDR);
504 outw(((a>>16) & 0xffff), IOADDR+2);
519 /* selftest or dump */
521 i596_port_do(struct net_device *dev, int portcmd, char *cmdname) {
522 struct i596_private *lp = dev->priv;
526 memset((void *)&(lp->dump), 0, sizeof(struct i596_dump));
527 outp = &(lp->dump.dump[0]);
529 PORT(va_to_pa(outp), portcmd);
530 mdelay(30); /* random, unmotivated */
532 printk("lp486e i82596 %s result:\n", cmdname);
533 for (m = ARRAY_SIZE(lp->dump.dump); m && lp->dump.dump[m-1] == 0; m--)
535 for (i = 0; i < m; i++) {
536 printk(" %04x", lp->dump.dump[i]);
545 i596_scp_setup(struct net_device *dev) {
546 struct i596_private *lp = dev->priv;
549 /* Setup SCP, ISCP, SCB */
552 * only a single byte is significant - here 0x44
553 * 0x80: big endian mode (details depend on stepping)
555 * 0x20: interrupt pin is active low
556 * 0x10: lock function disabled
557 * 0x08: external triggering of bus throttle timers
558 * 0x06: 00: 82586 compat mode, 01: segmented mode, 10: linear mode
561 lp->scp.sysbus = 0x00440000; /* linear mode */
562 lp->scp.pad = 0; /* must be zero */
563 lp->scp.pa_iscp = va_to_pa(&(lp->iscp));
566 * The CPU sets the ISCP to 1 before it gives the first CA()
568 lp->iscp.busy = 0x0001;
569 lp->iscp.pa_scb = va_to_pa(&(lp->scb));
573 lp->scb.pa_cmd = I596_NULL;
574 /* lp->scb.pa_rfd has been initialised already */
576 lp->last_cmd = jiffies;
582 * We need to wait 10 systemclock cycles, and
583 * 5 serial clock cycles.
585 PORT(0, PORT_RESET); /* address part ignored */
589 * Before the CA signal is asserted, the default SCP address
590 * (0x00fffff4) can be changed to a 16-byte aligned value
592 PORT(va_to_pa(&lp->scp), PORT_ALTSCP); /* change the scp address */
595 * The initialization procedure begins when a
596 * Channel Attention signal is asserted after a reset.
602 * The ISCP busy is cleared by the 82596 after the SCB address is read.
605 while (lp->iscp.busy) {
606 if (--boguscnt == 0) {
607 /* No i82596 present? */
608 printk("%s: i82596 initialization timed out\n",
615 /* I find here boguscnt==100, so no delay was required. */
621 init_i596(struct net_device *dev) {
622 struct i596_private *lp;
624 if (i596_scp_setup(dev))
627 lp = (struct i596_private *) dev->priv;
630 memcpy ((void *)lp->i596_config, init_setup, 14);
631 lp->set_conf.command = CmdConfigure;
632 i596_add_cmd(dev, (void *)&lp->set_conf);
634 memcpy ((void *)lp->eth_addr, dev->dev_addr, 6);
635 lp->set_add.command = CmdIASetup;
636 i596_add_cmd(dev, (struct i596_cmd *)&lp->set_add);
638 lp->tdr.command = CmdTDR;
639 i596_add_cmd(dev, (struct i596_cmd *)&lp->tdr);
641 if (lp->scb.command && i596_timeout(dev, "i82596 init", 200))
644 lp->scb.command = RX_START;
649 if (lp->scb.command && i596_timeout(dev, "Receive Unit start", 100))
655 /* Receive a single frame */
657 i596_rx_one(struct net_device *dev, struct i596_private *lp,
658 struct i596_rfd *rfd, int *frames) {
660 if (rfd->stat & RFD_STAT_OK) {
662 int pkt_len = (rfd->count & 0x3fff);
663 struct sk_buff *skb = dev_alloc_skb(pkt_len);
667 if (rfd->cmd & CMD_EOL)
668 printk("Received on EOL\n");
671 printk ("%s: i596_rx Memory squeeze, "
672 "dropping packet.\n", dev->name);
673 lp->stats.rx_dropped++;
677 memcpy(skb_put(skb,pkt_len), rfd->data, pkt_len);
679 skb->protocol = eth_type_trans(skb,dev);
681 dev->last_rx = jiffies;
682 lp->stats.rx_packets++;
685 printk("Frame reception error status %04x\n",
688 lp->stats.rx_errors++;
689 if (rfd->stat & RFD_COLLISION)
690 lp->stats.collisions++;
691 if (rfd->stat & RFD_SHORT_FRAME_ERR)
692 lp->stats.rx_length_errors++;
693 if (rfd->stat & RFD_DMA_ERR)
694 lp->stats.rx_over_errors++;
695 if (rfd->stat & RFD_NOBUFS_ERR)
696 lp->stats.rx_fifo_errors++;
697 if (rfd->stat & RFD_ALIGN_ERR)
698 lp->stats.rx_frame_errors++;
699 if (rfd->stat & RFD_CRC_ERR)
700 lp->stats.rx_crc_errors++;
701 if (rfd->stat & RFD_LENGTH_ERR)
702 lp->stats.rx_length_errors++;
704 rfd->stat = rfd->count = 0;
709 i596_rx(struct net_device *dev) {
710 struct i596_private *lp = (struct i596_private *) dev->priv;
711 struct i596_rfd *rfd;
715 rfd = pa_to_va(lp->scb.pa_rfd);
717 printk(KERN_ERR "i596_rx: NULL rfd?\n");
721 if (rfd->stat && !(rfd->stat & (RFD_STAT_C | RFD_STAT_B)))
722 printk("SF:%p-%04x\n", rfd, rfd->stat);
724 if (!(rfd->stat & RFD_STAT_C))
725 break; /* next one not ready */
726 if (i596_rx_one(dev, lp, rfd, &frames))
727 break; /* out of memory */
729 lp->rx_tail->cmd = 0;
731 lp->scb.pa_rfd = rfd->pa_next;
739 i596_cleanup_cmd(struct net_device *dev) {
740 struct i596_private *lp;
741 struct i596_cmd *cmd;
743 lp = (struct i596_private *) dev->priv;
744 while (lp->cmd_head) {
745 cmd = (struct i596_cmd *)lp->cmd_head;
747 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
750 switch ((cmd->command) & 0x7) {
752 struct tx_cmd *tx_cmd = (struct tx_cmd *) cmd;
753 struct i596_tbd * tx_cmd_tbd;
754 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
756 dev_kfree_skb_any(tx_cmd_tbd->skb);
758 lp->stats.tx_errors++;
759 lp->stats.tx_aborted_errors++;
761 cmd->pa_next = I596_NULL;
762 kfree((unsigned char *)tx_cmd);
763 netif_wake_queue(dev);
766 case CmdMulticastList: {
767 // unsigned short count = *((unsigned short *) (ptr + 1));
769 cmd->pa_next = I596_NULL;
770 kfree((unsigned char *)cmd);
774 cmd->pa_next = I596_NULL;
781 if (lp->scb.command && i596_timeout(dev, "i596_cleanup_cmd", 100))
784 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
787 static void i596_reset(struct net_device *dev, struct i596_private *lp, int ioaddr) {
789 if (lp->scb.command && i596_timeout(dev, "i596_reset", 100))
792 netif_stop_queue(dev);
794 lp->scb.command = CUC_ABORT | RX_ABORT;
798 /* wait for shutdown */
799 if (lp->scb.command && i596_timeout(dev, "i596_reset(2)", 400))
802 i596_cleanup_cmd(dev);
805 netif_start_queue(dev);
806 /*dev_kfree_skb(skb, FREE_WRITE);*/
810 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd) {
811 struct i596_private *lp = dev->priv;
812 int ioaddr = dev->base_addr;
816 cmd->command |= (CMD_EOL | CMD_INTR);
817 cmd->pa_next = I596_NULL;
819 spin_lock_irqsave(&lp->cmd_lock, flags);
822 lp->cmd_tail->pa_next = va_to_pa(cmd);
825 if (lp->scb.command && i596_timeout(dev, "i596_add_cmd", 100))
827 lp->scb.pa_cmd = va_to_pa(cmd);
828 lp->scb.command = CUC_START;
834 lp->cmd_head = pa_to_va(lp->scb.pa_cmd);
835 spin_unlock_irqrestore(&lp->cmd_lock, flags);
837 if (lp->cmd_backlog > 16) {
838 int tickssofar = jiffies - lp->last_cmd;
839 if (tickssofar < HZ/4)
842 printk(KERN_WARNING "%s: command unit timed out, status resetting.\n", dev->name);
843 i596_reset(dev, lp, ioaddr);
847 static int i596_open(struct net_device *dev)
851 i = request_irq(dev->irq, &i596_interrupt, IRQF_SHARED, dev->name, dev);
853 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
857 if ((i = init_rx_bufs(dev, RX_RING_SIZE)) < RX_RING_SIZE)
858 printk(KERN_ERR "%s: only able to allocate %d receive buffers\n", dev->name, i);
861 free_irq(dev->irq, dev);
864 netif_start_queue(dev);
866 return 0; /* Always succeed */
869 static int i596_start_xmit (struct sk_buff *skb, struct net_device *dev) {
870 struct i596_private *lp = dev->priv;
871 struct tx_cmd *tx_cmd;
876 if (length < ETH_ZLEN) {
877 if (skb_padto(skb, ETH_ZLEN))
882 dev->trans_start = jiffies;
884 tx_cmd = kmalloc((sizeof (struct tx_cmd) + sizeof (struct i596_tbd)), GFP_ATOMIC);
885 if (tx_cmd == NULL) {
886 printk(KERN_WARNING "%s: i596_xmit Memory squeeze, dropping packet.\n", dev->name);
887 lp->stats.tx_dropped++;
890 struct i596_tbd *tx_cmd_tbd;
891 tx_cmd_tbd = (struct i596_tbd *) (tx_cmd + 1);
892 tx_cmd->pa_tbd = va_to_pa (tx_cmd_tbd);
893 tx_cmd_tbd->pa_next = I596_NULL;
895 tx_cmd->cmd.command = (CMD_FLEX | CmdTx);
900 tx_cmd_tbd->size = (EOF | length);
902 tx_cmd_tbd->pa_data = va_to_pa (skb->data);
903 tx_cmd_tbd->skb = skb;
905 if (i596_debug & LOG_SRCDST)
906 print_eth (skb->data);
908 i596_add_cmd (dev, (struct i596_cmd *) tx_cmd);
910 lp->stats.tx_packets++;
917 i596_tx_timeout (struct net_device *dev) {
918 struct i596_private *lp = dev->priv;
919 int ioaddr = dev->base_addr;
921 /* Transmitter timeout, serious problems. */
922 printk(KERN_WARNING "%s: transmit timed out, status resetting.\n", dev->name);
923 lp->stats.tx_errors++;
925 /* Try to restart the adaptor */
926 if (lp->last_restart == lp->stats.tx_packets) {
927 printk ("Resetting board.\n");
929 /* Shutdown and restart */
930 i596_reset (dev, lp, ioaddr);
932 /* Issue a channel attention signal */
933 printk ("Kicking board.\n");
934 lp->scb.command = (CUC_START | RX_START);
936 lp->last_restart = lp->stats.tx_packets;
938 netif_wake_queue(dev);
941 static void print_eth(char *add)
946 for (i = 0; i < 6; i++)
947 printk(" %2.2X", (unsigned char) add[i]);
951 for (i = 0; i < 6; i++)
952 printk(" %2.2X", (unsigned char) add[i+6]);
955 printk ("type %2.2X%2.2X\n",
956 (unsigned char) add[12], (unsigned char) add[13]);
959 static int __init lp486e_probe(struct net_device *dev) {
960 struct i596_private *lp;
961 unsigned char eth_addr[6] = { 0, 0xaa, 0, 0, 0, 0 };
971 if (!request_region(IOADDR, LP486E_TOTAL_SIZE, DRV_NAME)) {
972 printk(KERN_ERR "lp486e: IO address 0x%x in use\n", IOADDR);
976 lp = (struct i596_private *) dev->priv;
977 spin_lock_init(&lp->cmd_lock);
980 * Do we really have this thing?
982 if (i596_scp_setup(dev)) {
987 dev->base_addr = IOADDR;
992 * How do we find the ethernet address? I don't know.
993 * One possibility is to look at the EISA configuration area
994 * [0xe8000-0xe9fff]. This contains the ethernet address
995 * but not at a fixed address - things depend on setup options.
997 * If we find no address, or the wrong address, use
998 * ifconfig eth0 hw ether a1:a2:a3:a4:a5:a6
999 * with the value found in the BIOS setup.
1001 bios = bus_to_virt(0xe8000);
1002 for (j = 0; j < 0x2000; j++) {
1003 if (bios[j] == 0 && bios[j+1] == 0xaa && bios[j+2] == 0) {
1004 printk("%s: maybe address at BIOS 0x%x:",
1005 dev->name, 0xe8000+j);
1006 for (i = 0; i < 6; i++) {
1007 eth_addr[i] = bios[i+j];
1008 printk(" %2.2X", eth_addr[i]);
1014 printk("%s: lp486e 82596 at %#3lx, IRQ %d,",
1015 dev->name, dev->base_addr, dev->irq);
1016 for (i = 0; i < 6; i++)
1017 printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]);
1020 /* The LP486E-specific entries in the device structure. */
1021 dev->open = &i596_open;
1022 dev->stop = &i596_close;
1023 dev->hard_start_xmit = &i596_start_xmit;
1024 dev->get_stats = &i596_get_stats;
1025 dev->set_multicast_list = &set_multicast_list;
1026 dev->watchdog_timeo = 5*HZ;
1027 dev->tx_timeout = i596_tx_timeout;
1030 /* selftest reports 0x320925ae - don't know what that means */
1031 i596_port_do(dev, PORT_SELFTEST, "selftest");
1032 i596_port_do(dev, PORT_DUMP, "dump");
1037 release_region(IOADDR, LP486E_TOTAL_SIZE);
1042 i596_handle_CU_completion(struct net_device *dev,
1043 struct i596_private *lp,
1044 unsigned short status,
1045 unsigned short *ack_cmdp) {
1046 struct i596_cmd *cmd;
1048 int commands_done = 0;
1050 unsigned long flags;
1052 spin_lock_irqsave(&lp->cmd_lock, flags);
1055 while (lp->cmd_head && (lp->cmd_head->status & CMD_STAT_C)) {
1058 lp->cmd_head = pa_to_va(lp->cmd_head->pa_next);
1062 cmd_val = cmd->command & 0x7;
1064 printk("finished CU %s command (%d)\n",
1065 CUcmdnames[cmd_val], cmd_val);
1070 struct tx_cmd *tx_cmd;
1071 struct i596_tbd *tx_cmd_tbd;
1073 tx_cmd = (struct tx_cmd *) cmd;
1074 tx_cmd_tbd = pa_to_va(tx_cmd->pa_tbd);
1077 if (cmd->status & CMD_STAT_OK) {
1079 print_eth(pa_to_va(tx_cmd_tbd->pa_data));
1081 lp->stats.tx_errors++;
1083 printk("transmission failure:%04x\n",
1085 if (cmd->status & 0x0020)
1086 lp->stats.collisions++;
1087 if (!(cmd->status & 0x0040))
1088 lp->stats.tx_heartbeat_errors++;
1089 if (cmd->status & 0x0400)
1090 lp->stats.tx_carrier_errors++;
1091 if (cmd->status & 0x0800)
1092 lp->stats.collisions++;
1093 if (cmd->status & 0x1000)
1094 lp->stats.tx_aborted_errors++;
1096 dev_kfree_skb_irq(tx_cmd_tbd->skb);
1098 cmd->pa_next = I596_NULL;
1099 kfree((unsigned char *)tx_cmd);
1100 netif_wake_queue(dev);
1104 case CmdMulticastList:
1105 cmd->pa_next = I596_NULL;
1106 kfree((unsigned char *)cmd);
1111 unsigned long status = *((unsigned long *) (cmd + 1));
1112 if (status & 0x8000) {
1114 printk("%s: link ok.\n", dev->name);
1116 if (status & 0x4000)
1117 printk("%s: Transceiver problem.\n",
1119 if (status & 0x2000)
1120 printk("%s: Termination problem.\n",
1122 if (status & 0x1000)
1123 printk("%s: Short circuit.\n",
1125 printk("%s: Time %ld.\n",
1126 dev->name, status & 0x07ff);
1130 cmd->pa_next = I596_NULL;
1131 lp->last_cmd = jiffies;
1138 while (cmd && (cmd != lp->cmd_tail)) {
1139 cmd->command &= 0x1fff;
1140 cmd = pa_to_va(cmd->pa_next);
1145 *ack_cmdp |= CUC_START;
1146 lp->scb.pa_cmd = va_to_pa(lp->cmd_head);
1147 spin_unlock_irqrestore(&lp->cmd_lock, flags);
1151 i596_interrupt (int irq, void *dev_instance) {
1152 struct net_device *dev = (struct net_device *) dev_instance;
1153 struct i596_private *lp;
1154 unsigned short status, ack_cmd = 0;
1157 lp = (struct i596_private *) dev->priv;
1160 * The 82596 examines the command, performs the required action,
1161 * and then clears the SCB command word.
1163 if (lp->scb.command && i596_timeout(dev, "interrupt", 40))
1167 * The status word indicates the status of the 82596.
1168 * It is modified only by the 82596.
1170 * [So, we must not clear it. I find often status 0xffff,
1171 * which is not one of the values allowed by the docs.]
1173 status = lp->scb.status;
1176 printk("%s: i596 interrupt, ", dev->name);
1177 i596_out_status(status);
1180 /* Impossible, but it happens - perhaps when we get
1181 a receive interrupt but scb.pa_rfd is I596_NULL. */
1182 if (status == 0xffff) {
1183 printk("%s: i596_interrupt: got status 0xffff\n", dev->name);
1187 ack_cmd = (status & STAT_ACK);
1189 if (status & (STAT_CX | STAT_CNA))
1190 i596_handle_CU_completion(dev, lp, status, &ack_cmd);
1192 if (status & (STAT_FR | STAT_RNR)) {
1193 /* Restart the receive unit when it got inactive somehow */
1194 if ((status & STAT_RNR) && netif_running(dev))
1195 ack_cmd |= RX_START;
1197 if (status & STAT_FR) {
1198 frames_in = i596_rx(dev);
1200 printk("receive frame reported, but no frames\n");
1204 /* acknowledge the interrupt */
1206 if ((lp->scb.pa_cmd != I596_NULL) && netif_running(dev))
1207 ack_cmd |= CUC_START;
1210 if (lp->scb.command && i596_timeout(dev, "i596 interrupt", 100))
1213 lp->scb.command = ack_cmd;
1222 static int i596_close(struct net_device *dev) {
1223 struct i596_private *lp = dev->priv;
1225 netif_stop_queue(dev);
1228 printk("%s: Shutting down ethercard, status was %4.4x.\n",
1229 dev->name, lp->scb.status);
1231 lp->scb.command = (CUC_ABORT | RX_ABORT);
1234 i596_cleanup_cmd(dev);
1236 if (lp->scb.command && i596_timeout(dev, "i596_close", 200))
1239 free_irq(dev->irq, dev);
1240 remove_rx_bufs(dev);
1245 static struct net_device_stats * i596_get_stats(struct net_device *dev) {
1246 struct i596_private *lp = dev->priv;
1252 * Set or clear the multicast filter for this adaptor.
1255 static void set_multicast_list(struct net_device *dev) {
1256 struct i596_private *lp = dev->priv;
1257 struct i596_cmd *cmd;
1260 printk ("%s: set multicast list %d\n",
1261 dev->name, dev->mc_count);
1263 if (dev->mc_count > 0) {
1264 struct dev_mc_list *dmi;
1266 cmd = kmalloc(sizeof(struct i596_cmd)+2+dev->mc_count*6, GFP_ATOMIC);
1268 printk (KERN_ERR "%s: set_multicast Memory squeeze.\n", dev->name);
1271 cmd->command = CmdMulticastList;
1272 *((unsigned short *) (cmd + 1)) = dev->mc_count * 6;
1273 cp = ((char *)(cmd + 1))+2;
1274 for (dmi = dev->mc_list; dmi != NULL; dmi = dmi->next) {
1278 if (i596_debug & LOG_SRCDST)
1279 print_eth (((char *)(cmd + 1)) + 2);
1280 i596_add_cmd(dev, cmd);
1282 if (lp->set_conf.pa_next != I596_NULL) {
1285 if (dev->mc_count == 0 && !(dev->flags & (IFF_PROMISC | IFF_ALLMULTI))) {
1286 if (dev->flags & IFF_ALLMULTI)
1287 dev->flags |= IFF_PROMISC;
1288 lp->i596_config[8] &= ~0x01;
1290 lp->i596_config[8] |= 0x01;
1293 i596_add_cmd(dev, (struct i596_cmd *) &lp->set_conf);
1297 MODULE_AUTHOR("Ard van Breemen <ard@cstmel.nl.eu.org>");
1298 MODULE_DESCRIPTION("Intel Panther onboard i82596 driver");
1299 MODULE_LICENSE("GPL");
1301 static struct net_device *dev_lp486e;
1302 static int full_duplex;
1304 static int io = IOADDR;
1305 static int irq = IRQ;
1307 module_param(debug, int, 0);
1308 //module_param(max_interrupt_work, int, 0);
1309 //module_param(reverse_probe, int, 0);
1310 //module_param(rx_copybreak, int, 0);
1311 module_param(options, int, 0);
1312 module_param(full_duplex, int, 0);
1314 static int __init lp486e_init_module(void) {
1316 struct net_device *dev = alloc_etherdev(sizeof(struct i596_private));
1321 dev->base_addr = io;
1322 err = lp486e_probe(dev);
1327 err = register_netdev(dev);
1329 release_region(dev->base_addr, LP486E_TOTAL_SIZE);
1339 static void __exit lp486e_cleanup_module(void) {
1340 unregister_netdev(dev_lp486e);
1341 release_region(dev_lp486e->base_addr, LP486E_TOTAL_SIZE);
1342 free_netdev(dev_lp486e);
1345 module_init(lp486e_init_module);
1346 module_exit(lp486e_cleanup_module);