1 /* seeq8005.c: A network driver for linux. */
4 Written 1993-94 by Donald Becker.
5 See the skeleton.c file for further copyright information.
7 This software may be used and distributed according to the terms
8 of the GNU General Public License, incorporated herein by reference.
10 The author may be reached as hamish@zot.apana.org.au
12 This file is a network device driver for the SEEQ 8005 chipset and
13 the Linux operating system.
17 static const char version[] =
18 "seeq8005.c:v1.00 8/07/95 Hamish Coleman (hamish@zot.apana.org.au)\n";
25 1.00 Public release. cosmetic changes (no warnings now)
26 0.68 Turning per- packet,interrupt debug messages off - testing for release.
27 0.67 timing problems/bad buffer reads seem to be fixed now
28 0.63 *!@$ protocol=eth_type_trans -- now packets flow
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/types.h>
36 #include <linux/fcntl.h>
37 #include <linux/interrupt.h>
38 #include <linux/ioport.h>
40 #include <linux/slab.h>
41 #include <linux/string.h>
42 #include <linux/init.h>
43 #include <linux/delay.h>
44 #include <linux/errno.h>
45 #include <linux/netdevice.h>
46 #include <linux/etherdevice.h>
47 #include <linux/skbuff.h>
49 #include <asm/system.h>
50 #include <asm/bitops.h>
56 /* First, a few definitions that the brave might change. */
57 /* A zero-terminated list of I/O addresses to be probed. */
58 static unsigned int seeq8005_portlist[] __initdata =
59 { 0x300, 0x320, 0x340, 0x360, 0};
61 /* use 0 for production, 1 for verification, >2 for debug */
65 static unsigned int net_debug = NET_DEBUG;
67 /* Information that need to be kept for each board. */
69 struct net_device_stats stats;
70 unsigned short receive_ptr; /* What address in packet memory do we expect a recv_pkt_header? */
71 long open_time; /* Useless example local info. */
74 /* The station (ethernet) address prefix, used for IDing the board. */
79 /* Index to functions, as function prototypes. */
81 static int seeq8005_probe1(struct net_device *dev, int ioaddr);
82 static int seeq8005_open(struct net_device *dev);
83 static void seeq8005_timeout(struct net_device *dev);
84 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev);
85 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs *regs);
86 static void seeq8005_rx(struct net_device *dev);
87 static int seeq8005_close(struct net_device *dev);
88 static struct net_device_stats *seeq8005_get_stats(struct net_device *dev);
89 static void set_multicast_list(struct net_device *dev);
91 /* Example routines you must write ;->. */
92 #define tx_done(dev) (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
93 static void hardware_send_packet(struct net_device *dev, char *buf, int length);
94 extern void seeq8005_init(struct net_device *dev, int startp);
95 static inline void wait_for_buffer(struct net_device *dev);
98 /* Check for a network adaptor of this type, and return '0' iff one exists.
99 If dev->base_addr == 0, probe all likely locations.
100 If dev->base_addr == 1, always return failure.
103 static int io = 0x320;
106 struct net_device * __init seeq8005_probe(int unit)
108 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
113 return ERR_PTR(-ENODEV);
116 sprintf(dev->name, "eth%d", unit);
117 netdev_boot_setup_check(dev);
122 if (io > 0x1ff) { /* Check a single specified location. */
123 err = seeq8005_probe1(dev, io);
124 } else if (io != 0) { /* Don't probe at all. */
127 for (port = seeq8005_portlist; *port; port++) {
128 if (seeq8005_probe1(dev, *port) == 0)
136 err = register_netdev(dev);
141 release_region(dev->base_addr, SEEQ8005_IO_EXTENT);
147 /* This is the real probe routine. Linux has a history of friendly device
148 probes on the ISA bus. A good device probes avoids doing writes, and
149 verifies that the correct device exists and functions. */
151 static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
153 static unsigned version_printed;
155 unsigned char SA_prom[32];
163 if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
167 printk("seeq8005: probing at 0x%x\n",ioaddr);
169 old_stat = inw(SEEQ_STATUS); /* read status register */
170 if (old_stat == 0xffff) {
172 goto out; /* assume that 0xffff == no device */
174 if ( (old_stat & 0x1800) != 0x1800 ) { /* assume that unused bits are 1, as my manual says */
176 printk("seeq8005: reserved stat bits != 0x1800\n");
177 printk(" == 0x%04x\n",old_stat);
183 old_rear = inw(SEEQ_REA);
184 if (old_rear == 0xffff) {
186 if (inw(SEEQ_REA) == 0xffff) { /* assume that 0xffff == no device */
190 } else if ((old_rear & 0xff00) != 0xff00) { /* assume that unused bits are 1 */
192 printk("seeq8005: unused rear bits != 0xff00\n");
193 printk(" == 0x%04x\n",old_rear);
199 old_cfg2 = inw(SEEQ_CFG2); /* read CFG2 register */
200 old_cfg1 = inw(SEEQ_CFG1);
201 old_dmaar = inw(SEEQ_DMAAR);
204 printk("seeq8005: stat = 0x%04x\n",old_stat);
205 printk("seeq8005: cfg1 = 0x%04x\n",old_cfg1);
206 printk("seeq8005: cfg2 = 0x%04x\n",old_cfg2);
207 printk("seeq8005: raer = 0x%04x\n",old_rear);
208 printk("seeq8005: dmaar= 0x%04x\n",old_dmaar);
211 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD); /* setup for reading PROM */
212 outw( 0, SEEQ_DMAAR); /* set starting PROM address */
213 outw( SEEQCFG1_BUFFER_PROM, SEEQ_CFG1); /* set buffer to look at PROM */
217 for(i=0; i <32; i++) {
218 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
222 /* untested because I only have the one card */
223 if ( (j&0xff) != 0 ) { /* checksum appears to be 8bit = 0 */
224 if (net_debug>1) { /* check this before deciding that we have a card */
225 printk("seeq8005: prom sum error\n");
227 outw( old_stat, SEEQ_STATUS);
228 outw( old_dmaar, SEEQ_DMAAR);
229 outw( old_cfg1, SEEQ_CFG1);
235 outw( SEEQCFG2_RESET, SEEQ_CFG2); /* reset the card */
237 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
240 printk("seeq8005: prom sum = 0x%08x\n",j);
241 for(j=0; j<32; j+=16) {
242 printk("seeq8005: prom %02x: ",j);
244 printk("%02x ",SA_prom[j|i]);
248 if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
249 printk("%c", SA_prom[j|i]);
260 * testing the packet buffer memory doesn't work yet
261 * but all other buffer accesses do
262 * - fixing is not a priority
264 if (net_debug>1) { /* test packet buffer memory */
265 printk("seeq8005: testing packet buffer ... ");
266 outw( SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
267 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
268 outw( 0 , SEEQ_DMAAR);
269 for(i=0;i<32768;i++) {
270 outw(0x5a5a, SEEQ_BUFFER);
273 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
275 outw( 0 , SEEQ_DMAAR);
276 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
278 if ( (inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
279 outw( SEEQCMD_WINDOW_INT_ACK | (inw(SEEQ_STATUS)& SEEQCMD_INT_MASK), SEEQ_CMD);
280 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
282 for(i=0;i<32768;i++) {
283 if (inw(SEEQ_BUFFER) != 0x5a5a)
294 if (net_debug && version_printed++ == 0)
297 printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
299 /* Fill in the 'dev' fields. */
300 dev->base_addr = ioaddr;
303 /* Retrieve and print the ethernet address. */
304 for (i = 0; i < 6; i++)
305 printk(" %2.2x", dev->dev_addr[i] = SA_prom[i+6]);
307 if (dev->irq == 0xff)
308 ; /* Do nothing: a user-level program will set it. */
309 else if (dev->irq < 2) { /* "Auto-IRQ" */
310 unsigned long cookie = probe_irq_on();
312 outw( SEEQCMD_RX_INT_EN | SEEQCMD_SET_RX_ON | SEEQCMD_SET_RX_OFF, SEEQ_CMD );
314 dev->irq = probe_irq_off(cookie);
317 printk(" autoirq is %d\n", dev->irq);
318 } else if (dev->irq == 2)
319 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
320 * or don't know which one to set.
326 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
328 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
335 dev->open = seeq8005_open;
336 dev->stop = seeq8005_close;
337 dev->hard_start_xmit = seeq8005_send_packet;
338 dev->tx_timeout = seeq8005_timeout;
339 dev->watchdog_timeo = HZ/20;
340 dev->get_stats = seeq8005_get_stats;
341 dev->set_multicast_list = set_multicast_list;
342 dev->flags &= ~IFF_MULTICAST;
346 release_region(ioaddr, SEEQ8005_IO_EXTENT);
351 /* Open/initialize the board. This is called (in the current kernel)
352 sometime after booting when the 'ifconfig' program is run.
354 This routine should set everything up anew at each open, even
355 registers that "should" only need to be set once at boot, so that
356 there is non-reboot way to recover if something goes wrong.
358 static int seeq8005_open(struct net_device *dev)
360 struct net_local *lp = netdev_priv(dev);
363 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
365 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
371 /* Reset the hardware here. Don't forget to set the station address. */
372 seeq8005_init(dev, 1);
374 lp->open_time = jiffies;
376 netif_start_queue(dev);
380 static void seeq8005_timeout(struct net_device *dev)
382 int ioaddr = dev->base_addr;
383 printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
384 tx_done(dev) ? "IRQ conflict" : "network cable problem");
385 /* Try to restart the adaptor. */
386 seeq8005_init(dev, 1);
387 dev->trans_start = jiffies;
388 netif_wake_queue(dev);
391 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev)
393 struct net_local *lp = netdev_priv(dev);
394 short length = skb->len;
397 if (length < ETH_ZLEN) {
398 skb = skb_padto(skb, ETH_ZLEN);
405 /* Block a timer-based transmit from overlapping */
406 netif_stop_queue(dev);
408 hardware_send_packet(dev, buf, length);
409 dev->trans_start = jiffies;
410 lp->stats.tx_bytes += length;
412 /* You might need to clean up and record Tx statistics here. */
417 /* The typical workload of the driver:
418 Handle the network interface interrupts. */
419 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs * regs)
421 struct net_device *dev = dev_id;
422 struct net_local *lp;
423 int ioaddr, status, boguscount = 0;
426 ioaddr = dev->base_addr;
427 lp = netdev_priv(dev);
429 status = inw(SEEQ_STATUS);
432 printk("%s: int, status=0x%04x\n",dev->name,status);
435 if (status & SEEQSTAT_WINDOW_INT) {
437 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
439 printk("%s: window int!\n",dev->name);
442 if (status & SEEQSTAT_TX_INT) {
444 outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
445 lp->stats.tx_packets++;
446 netif_wake_queue(dev); /* Inform upper layers. */
448 if (status & SEEQSTAT_RX_INT) {
450 /* Got a packet(s). */
453 status = inw(SEEQ_STATUS);
454 } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
457 printk("%s: eoi\n",dev->name);
459 return IRQ_RETVAL(handled);
462 /* We have a good packet(s), get it/them out of the buffers. */
463 static void seeq8005_rx(struct net_device *dev)
465 struct net_local *lp = netdev_priv(dev);
468 int ioaddr = dev->base_addr;
476 status = inw(SEEQ_STATUS);
477 outw( lp->receive_ptr, SEEQ_DMAAR);
478 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
479 wait_for_buffer(dev);
480 next_packet = ntohs(inw(SEEQ_BUFFER));
481 pkt_hdr = inw(SEEQ_BUFFER);
484 printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
487 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) { /* Read all the frames? */
488 return; /* Done for now */
491 if ((pkt_hdr & SEEQPKTS_DONE)==0)
494 if (next_packet < lp->receive_ptr) {
495 pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
497 pkt_len = next_packet - lp->receive_ptr - 4;
500 if (next_packet < ((DEFAULT_TEA+1)<<8)) { /* is the next_packet address sane? */
501 printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
502 seeq8005_init(dev,1);
506 lp->receive_ptr = next_packet;
509 printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
512 if (pkt_hdr & SEEQPKTS_ANY_ERROR) { /* There was an error. */
513 lp->stats.rx_errors++;
514 if (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
515 if (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
516 if (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
517 if (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
518 /* skip over this packet */
519 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
520 outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
522 /* Malloc up new buffer. */
526 skb = dev_alloc_skb(pkt_len);
528 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
529 lp->stats.rx_dropped++;
533 skb_reserve(skb, 2); /* align data on 16 byte */
534 buf = skb_put(skb,pkt_len);
536 insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
540 printk("%s: recv ",dev->name);
542 printk("%02x ",*(p++)&0xff);
547 skb->protocol=eth_type_trans(skb,dev);
549 dev->last_rx = jiffies;
550 lp->stats.rx_packets++;
551 lp->stats.rx_bytes += pkt_len;
553 } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
555 /* If any worth-while packets have been received, netif_rx()
556 has done a mark_bh(NET_BH) for us and will work on them
557 when we get to the bottom-half routine. */
561 /* The inverse routine to net_open(). */
562 static int seeq8005_close(struct net_device *dev)
564 struct net_local *lp = netdev_priv(dev);
565 int ioaddr = dev->base_addr;
569 netif_stop_queue(dev);
571 /* Flush the Tx and disable Rx here. */
572 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
574 free_irq(dev->irq, dev);
576 /* Update the statistics here. */
582 /* Get the current statistics. This may be called with the card open or
584 static struct net_device_stats *seeq8005_get_stats(struct net_device *dev)
586 struct net_local *lp = netdev_priv(dev);
591 /* Set or clear the multicast filter for this adaptor.
592 num_addrs == -1 Promiscuous mode, receive all packets
593 num_addrs == 0 Normal mode, clear multicast list
594 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
595 best-effort filtering.
597 static void set_multicast_list(struct net_device *dev)
600 * I _could_ do up to 6 addresses here, but won't (yet?)
604 int ioaddr = dev->base_addr;
606 * hmm, not even sure if my matching works _anyway_ - seem to be receiving
610 if (num_addrs) { /* Enable promiscuous mode */
611 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL, SEEQ_CFG1);
612 dev->flags|=IFF_PROMISC;
613 } else { /* Disable promiscuous mode, use normal mode */
614 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
619 void seeq8005_init(struct net_device *dev, int startp)
621 struct net_local *lp = netdev_priv(dev);
622 int ioaddr = dev->base_addr;
625 outw(SEEQCFG2_RESET, SEEQ_CFG2); /* reset device */
628 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
629 outw( 0, SEEQ_DMAAR); /* load start address into both low and high byte */
630 /* wait_for_buffer(dev); */ /* I think that you only need a wait for memory buffer */
631 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
633 for(i=0;i<6;i++) { /* set Station address */
634 outb(dev->dev_addr[i], SEEQ_BUFFER);
638 outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1); /* set xmit end area pointer to 16K */
639 outb( DEFAULT_TEA, SEEQ_BUFFER); /* this gives us 16K of send buffer and 48K of recv buffer */
641 lp->receive_ptr = (DEFAULT_TEA+1)<<8; /* so we can find our packet_header */
642 outw( lp->receive_ptr, SEEQ_RPR); /* Receive Pointer Register is set to recv buffer memory */
644 outw( 0x00ff, SEEQ_REA); /* Receive Area End */
647 printk("%s: SA0 = ",dev->name);
649 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
650 outw( 0, SEEQ_DMAAR);
651 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
654 printk("%02x ",inb(SEEQ_BUFFER));
659 outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
660 outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
661 outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
665 old_cfg1 = inw(SEEQ_CFG1);
666 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
667 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
668 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
669 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
670 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
676 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
678 int ioaddr = dev->base_addr;
679 int status = inw(SEEQ_STATUS);
680 int transmit_ptr = 0;
684 printk("%s: send 0x%04x\n",dev->name,length);
687 /* Set FIFO to writemode and set packet-buffer address */
688 outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
689 outw( transmit_ptr, SEEQ_DMAAR);
691 /* output SEEQ Packet header barfage */
692 outw( htons(length + 4), SEEQ_BUFFER);
693 outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
695 /* blat the buffer */
696 outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
698 outw( 0, SEEQ_BUFFER);
699 outw( 0, SEEQ_BUFFER);
701 /* set address of start of transmit chain */
702 outw( transmit_ptr, SEEQ_TPR);
706 while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && (jiffies - tmp < HZ))
710 outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
718 * This routine waits for the SEEQ chip to assert that the FIFO is ready
719 * by checking for a window interrupt, and then clearing it. This has to
720 * occur in the interrupt handler!
722 inline void wait_for_buffer(struct net_device * dev)
724 int ioaddr = dev->base_addr;
729 while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
732 if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
733 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
738 static struct net_device *dev_seeq;
739 MODULE_LICENSE("GPL");
740 MODULE_PARM(io, "i");
741 MODULE_PARM(irq, "i");
742 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
743 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
745 int init_module(void)
747 dev_seeq = seeq8005_probe(-1);
748 if (IS_ERR(dev_seeq))
749 return PTR_ERR(dev_seeq);
753 void cleanup_module(void)
755 unregister_netdev(dev_seeq);
756 release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
757 free_netdev(dev_seeq);
764 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
766 * kept-new-versions: 5