b43: Add driver load messages
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / seeq8005.c
blob48c64fb20eecf164b9022aae727e6dc86e8f5290
1 /* seeq8005.c: A network driver for linux. */
2 /*
3 Based on skeleton.c,
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";
21 Sources:
22 SEEQ 8005 databook
24 Version history:
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
29 0.56 Send working
30 0.48 Receive working
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>
39 #include <linux/in.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>
48 #include <linux/bitops.h>
49 #include <linux/jiffies.h>
51 #include <asm/system.h>
52 #include <asm/io.h>
53 #include <asm/dma.h>
55 #include "seeq8005.h"
57 /* First, a few definitions that the brave might change. */
58 /* A zero-terminated list of I/O addresses to be probed. */
59 static unsigned int seeq8005_portlist[] __initdata =
60 { 0x300, 0x320, 0x340, 0x360, 0};
62 /* use 0 for production, 1 for verification, >2 for debug */
63 #ifndef NET_DEBUG
64 #define NET_DEBUG 1
65 #endif
66 static unsigned int net_debug = NET_DEBUG;
68 /* Information that need to be kept for each board. */
69 struct net_local {
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. */
75 #define SA_ADDR0 0x00
76 #define SA_ADDR1 0x80
77 #define SA_ADDR2 0x4b
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);
86 static void seeq8005_rx(struct net_device *dev);
87 static int seeq8005_close(struct net_device *dev);
88 static void set_multicast_list(struct net_device *dev);
90 /* Example routines you must write ;->. */
91 #define tx_done(dev) (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
92 static void hardware_send_packet(struct net_device *dev, char *buf, int length);
93 extern void seeq8005_init(struct net_device *dev, int startp);
94 static inline void wait_for_buffer(struct net_device *dev);
97 /* Check for a network adaptor of this type, and return '0' iff one exists.
98 If dev->base_addr == 0, probe all likely locations.
99 If dev->base_addr == 1, always return failure.
102 static int io = 0x320;
103 static int irq = 10;
105 struct net_device * __init seeq8005_probe(int unit)
107 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
108 unsigned *port;
109 int err = 0;
111 if (!dev)
112 return ERR_PTR(-ENODEV);
114 if (unit >= 0) {
115 sprintf(dev->name, "eth%d", unit);
116 netdev_boot_setup_check(dev);
117 io = dev->base_addr;
118 irq = dev->irq;
121 if (io > 0x1ff) { /* Check a single specified location. */
122 err = seeq8005_probe1(dev, io);
123 } else if (io != 0) { /* Don't probe at all. */
124 err = -ENXIO;
125 } else {
126 for (port = seeq8005_portlist; *port; port++) {
127 if (seeq8005_probe1(dev, *port) == 0)
128 break;
130 if (!*port)
131 err = -ENODEV;
133 if (err)
134 goto out;
135 err = register_netdev(dev);
136 if (err)
137 goto out1;
138 return dev;
139 out1:
140 release_region(dev->base_addr, SEEQ8005_IO_EXTENT);
141 out:
142 free_netdev(dev);
143 return ERR_PTR(err);
146 /* This is the real probe routine. Linux has a history of friendly device
147 probes on the ISA bus. A good device probes avoids doing writes, and
148 verifies that the correct device exists and functions. */
150 static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
152 static unsigned version_printed;
153 int i,j;
154 unsigned char SA_prom[32];
155 int old_cfg1;
156 int old_cfg2;
157 int old_stat;
158 int old_dmaar;
159 int old_rear;
160 int retval;
161 DECLARE_MAC_BUF(mac);
163 if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
164 return -ENODEV;
166 if (net_debug>1)
167 printk("seeq8005: probing at 0x%x\n",ioaddr);
169 old_stat = inw(SEEQ_STATUS); /* read status register */
170 if (old_stat == 0xffff) {
171 retval = -ENODEV;
172 goto out; /* assume that 0xffff == no device */
174 if ( (old_stat & 0x1800) != 0x1800 ) { /* assume that unused bits are 1, as my manual says */
175 if (net_debug>1) {
176 printk("seeq8005: reserved stat bits != 0x1800\n");
177 printk(" == 0x%04x\n",old_stat);
179 retval = -ENODEV;
180 goto out;
183 old_rear = inw(SEEQ_REA);
184 if (old_rear == 0xffff) {
185 outw(0,SEEQ_REA);
186 if (inw(SEEQ_REA) == 0xffff) { /* assume that 0xffff == no device */
187 retval = -ENODEV;
188 goto out;
190 } else if ((old_rear & 0xff00) != 0xff00) { /* assume that unused bits are 1 */
191 if (net_debug>1) {
192 printk("seeq8005: unused rear bits != 0xff00\n");
193 printk(" == 0x%04x\n",old_rear);
195 retval = -ENODEV;
196 goto out;
199 old_cfg2 = inw(SEEQ_CFG2); /* read CFG2 register */
200 old_cfg1 = inw(SEEQ_CFG1);
201 old_dmaar = inw(SEEQ_DMAAR);
203 if (net_debug>4) {
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 */
216 j=0;
217 for(i=0; i <32; i++) {
218 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
221 #if 0
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);
230 retval = -ENODEV;
231 goto out;
233 #endif
235 outw( SEEQCFG2_RESET, SEEQ_CFG2); /* reset the card */
236 udelay(5);
237 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
239 if (net_debug) {
240 printk("seeq8005: prom sum = 0x%08x\n",j);
241 for(j=0; j<32; j+=16) {
242 printk("seeq8005: prom %02x: ",j);
243 for(i=0;i<16;i++) {
244 printk("%02x ",SA_prom[j|i]);
246 printk(" ");
247 for(i=0;i<16;i++) {
248 if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
249 printk("%c", SA_prom[j|i]);
250 } else {
251 printk(" ");
254 printk("\n");
258 #if 0
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);
272 j=jiffies+HZ;
273 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
274 mb();
275 outw( 0 , SEEQ_DMAAR);
276 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
277 mb();
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);
281 j=0;
282 for(i=0;i<32768;i++) {
283 if (inw(SEEQ_BUFFER) != 0x5a5a)
284 j++;
286 if (j) {
287 printk("%i\n",j);
288 } else {
289 printk("ok.\n");
292 #endif
294 if (net_debug && version_printed++ == 0)
295 printk(version);
297 printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
299 /* Fill in the 'dev' fields. */
300 dev->base_addr = ioaddr;
301 dev->irq = irq;
303 /* Retrieve and print the ethernet address. */
304 for (i = 0; i < 6; i++)
305 dev->dev_addr[i] = SA_prom[i+6];
306 printk("%s", print_mac(mac, dev->dev_addr));
308 if (dev->irq == 0xff)
309 ; /* Do nothing: a user-level program will set it. */
310 else if (dev->irq < 2) { /* "Auto-IRQ" */
311 unsigned long cookie = probe_irq_on();
313 outw( SEEQCMD_RX_INT_EN | SEEQCMD_SET_RX_ON | SEEQCMD_SET_RX_OFF, SEEQ_CMD );
315 dev->irq = probe_irq_off(cookie);
317 if (net_debug >= 2)
318 printk(" autoirq is %d\n", dev->irq);
319 } else if (dev->irq == 2)
320 /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
321 * or don't know which one to set.
323 dev->irq = 9;
325 #if 0
327 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
328 if (irqval) {
329 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
330 dev->irq, irqval);
331 retval = -EAGAIN;
332 goto out;
335 #endif
336 dev->open = seeq8005_open;
337 dev->stop = seeq8005_close;
338 dev->hard_start_xmit = seeq8005_send_packet;
339 dev->tx_timeout = seeq8005_timeout;
340 dev->watchdog_timeo = HZ/20;
341 dev->set_multicast_list = set_multicast_list;
342 dev->flags &= ~IFF_MULTICAST;
344 return 0;
345 out:
346 release_region(ioaddr, SEEQ8005_IO_EXTENT);
347 return retval;
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);
364 if (irqval) {
365 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
366 dev->irq, irqval);
367 return -EAGAIN;
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);
377 return 0;
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 short length = skb->len;
394 unsigned char *buf;
396 if (length < ETH_ZLEN) {
397 if (skb_padto(skb, ETH_ZLEN))
398 return 0;
399 length = ETH_ZLEN;
401 buf = skb->data;
403 /* Block a timer-based transmit from overlapping */
404 netif_stop_queue(dev);
406 hardware_send_packet(dev, buf, length);
407 dev->trans_start = jiffies;
408 dev->stats.tx_bytes += length;
409 dev_kfree_skb (skb);
410 /* You might need to clean up and record Tx statistics here. */
412 return 0;
416 * wait_for_buffer
418 * This routine waits for the SEEQ chip to assert that the FIFO is ready
419 * by checking for a window interrupt, and then clearing it. This has to
420 * occur in the interrupt handler!
422 inline void wait_for_buffer(struct net_device * dev)
424 int ioaddr = dev->base_addr;
425 unsigned long tmp;
426 int status;
428 tmp = jiffies + HZ;
429 while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
430 cpu_relax();
432 if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
433 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
436 /* The typical workload of the driver:
437 Handle the network interface interrupts. */
438 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id)
440 struct net_device *dev = dev_id;
441 struct net_local *lp;
442 int ioaddr, status, boguscount = 0;
443 int handled = 0;
445 ioaddr = dev->base_addr;
446 lp = netdev_priv(dev);
448 status = inw(SEEQ_STATUS);
449 do {
450 if (net_debug >2) {
451 printk("%s: int, status=0x%04x\n",dev->name,status);
454 if (status & SEEQSTAT_WINDOW_INT) {
455 handled = 1;
456 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
457 if (net_debug) {
458 printk("%s: window int!\n",dev->name);
461 if (status & SEEQSTAT_TX_INT) {
462 handled = 1;
463 outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
464 dev->stats.tx_packets++;
465 netif_wake_queue(dev); /* Inform upper layers. */
467 if (status & SEEQSTAT_RX_INT) {
468 handled = 1;
469 /* Got a packet(s). */
470 seeq8005_rx(dev);
472 status = inw(SEEQ_STATUS);
473 } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
475 if(net_debug>2) {
476 printk("%s: eoi\n",dev->name);
478 return IRQ_RETVAL(handled);
481 /* We have a good packet(s), get it/them out of the buffers. */
482 static void seeq8005_rx(struct net_device *dev)
484 struct net_local *lp = netdev_priv(dev);
485 int boguscount = 10;
486 int pkt_hdr;
487 int ioaddr = dev->base_addr;
489 do {
490 int next_packet;
491 int pkt_len;
492 int i;
493 int status;
495 status = inw(SEEQ_STATUS);
496 outw( lp->receive_ptr, SEEQ_DMAAR);
497 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
498 wait_for_buffer(dev);
499 next_packet = ntohs(inw(SEEQ_BUFFER));
500 pkt_hdr = inw(SEEQ_BUFFER);
502 if (net_debug>2) {
503 printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
506 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) { /* Read all the frames? */
507 return; /* Done for now */
510 if ((pkt_hdr & SEEQPKTS_DONE)==0)
511 break;
513 if (next_packet < lp->receive_ptr) {
514 pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
515 } else {
516 pkt_len = next_packet - lp->receive_ptr - 4;
519 if (next_packet < ((DEFAULT_TEA+1)<<8)) { /* is the next_packet address sane? */
520 printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
521 seeq8005_init(dev,1);
522 return;
525 lp->receive_ptr = next_packet;
527 if (net_debug>2) {
528 printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
531 if (pkt_hdr & SEEQPKTS_ANY_ERROR) { /* There was an error. */
532 dev->stats.rx_errors++;
533 if (pkt_hdr & SEEQPKTS_SHORT) dev->stats.rx_frame_errors++;
534 if (pkt_hdr & SEEQPKTS_DRIB) dev->stats.rx_frame_errors++;
535 if (pkt_hdr & SEEQPKTS_OVERSIZE) dev->stats.rx_over_errors++;
536 if (pkt_hdr & SEEQPKTS_CRC_ERR) dev->stats.rx_crc_errors++;
537 /* skip over this packet */
538 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
539 outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
540 } else {
541 /* Malloc up new buffer. */
542 struct sk_buff *skb;
543 unsigned char *buf;
545 skb = dev_alloc_skb(pkt_len);
546 if (skb == NULL) {
547 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
548 dev->stats.rx_dropped++;
549 break;
551 skb_reserve(skb, 2); /* align data on 16 byte */
552 buf = skb_put(skb,pkt_len);
554 insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
556 if (net_debug>2) {
557 char * p = buf;
558 printk("%s: recv ",dev->name);
559 for(i=0;i<14;i++) {
560 printk("%02x ",*(p++)&0xff);
562 printk("\n");
565 skb->protocol=eth_type_trans(skb,dev);
566 netif_rx(skb);
567 dev->last_rx = jiffies;
568 dev->stats.rx_packets++;
569 dev->stats.rx_bytes += pkt_len;
571 } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
573 /* If any worth-while packets have been received, netif_rx()
574 has done a mark_bh(NET_BH) for us and will work on them
575 when we get to the bottom-half routine. */
576 return;
579 /* The inverse routine to net_open(). */
580 static int seeq8005_close(struct net_device *dev)
582 struct net_local *lp = netdev_priv(dev);
583 int ioaddr = dev->base_addr;
585 lp->open_time = 0;
587 netif_stop_queue(dev);
589 /* Flush the Tx and disable Rx here. */
590 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
592 free_irq(dev->irq, dev);
594 /* Update the statistics here. */
596 return 0;
600 /* Set or clear the multicast filter for this adaptor.
601 num_addrs == -1 Promiscuous mode, receive all packets
602 num_addrs == 0 Normal mode, clear multicast list
603 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
604 best-effort filtering.
606 static void set_multicast_list(struct net_device *dev)
609 * I _could_ do up to 6 addresses here, but won't (yet?)
612 #if 0
613 int ioaddr = dev->base_addr;
615 * hmm, not even sure if my matching works _anyway_ - seem to be receiving
616 * _everything_ . . .
619 if (num_addrs) { /* Enable promiscuous mode */
620 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL, SEEQ_CFG1);
621 dev->flags|=IFF_PROMISC;
622 } else { /* Disable promiscuous mode, use normal mode */
623 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
625 #endif
628 void seeq8005_init(struct net_device *dev, int startp)
630 struct net_local *lp = netdev_priv(dev);
631 int ioaddr = dev->base_addr;
632 int i;
634 outw(SEEQCFG2_RESET, SEEQ_CFG2); /* reset device */
635 udelay(5);
637 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
638 outw( 0, SEEQ_DMAAR); /* load start address into both low and high byte */
639 /* wait_for_buffer(dev); */ /* I think that you only need a wait for memory buffer */
640 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
642 for(i=0;i<6;i++) { /* set Station address */
643 outb(dev->dev_addr[i], SEEQ_BUFFER);
644 udelay(2);
647 outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1); /* set xmit end area pointer to 16K */
648 outb( DEFAULT_TEA, SEEQ_BUFFER); /* this gives us 16K of send buffer and 48K of recv buffer */
650 lp->receive_ptr = (DEFAULT_TEA+1)<<8; /* so we can find our packet_header */
651 outw( lp->receive_ptr, SEEQ_RPR); /* Receive Pointer Register is set to recv buffer memory */
653 outw( 0x00ff, SEEQ_REA); /* Receive Area End */
655 if (net_debug>4) {
656 printk("%s: SA0 = ",dev->name);
658 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
659 outw( 0, SEEQ_DMAAR);
660 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
662 for(i=0;i<6;i++) {
663 printk("%02x ",inb(SEEQ_BUFFER));
665 printk("\n");
668 outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
669 outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
670 outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
672 if (net_debug>4) {
673 int old_cfg1;
674 old_cfg1 = inw(SEEQ_CFG1);
675 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
676 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
677 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
678 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
679 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
685 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
687 int ioaddr = dev->base_addr;
688 int status = inw(SEEQ_STATUS);
689 int transmit_ptr = 0;
690 unsigned long tmp;
692 if (net_debug>4) {
693 printk("%s: send 0x%04x\n",dev->name,length);
696 /* Set FIFO to writemode and set packet-buffer address */
697 outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
698 outw( transmit_ptr, SEEQ_DMAAR);
700 /* output SEEQ Packet header barfage */
701 outw( htons(length + 4), SEEQ_BUFFER);
702 outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
704 /* blat the buffer */
705 outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
706 /* paranoia !! */
707 outw( 0, SEEQ_BUFFER);
708 outw( 0, SEEQ_BUFFER);
710 /* set address of start of transmit chain */
711 outw( transmit_ptr, SEEQ_TPR);
713 /* drain FIFO */
714 tmp = jiffies;
715 while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && time_before(jiffies, tmp + HZ))
716 mb();
718 /* doit ! */
719 outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
724 #ifdef MODULE
726 static struct net_device *dev_seeq;
727 MODULE_LICENSE("GPL");
728 module_param(io, int, 0);
729 module_param(irq, int, 0);
730 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
731 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
733 int __init init_module(void)
735 dev_seeq = seeq8005_probe(-1);
736 if (IS_ERR(dev_seeq))
737 return PTR_ERR(dev_seeq);
738 return 0;
741 void __exit cleanup_module(void)
743 unregister_netdev(dev_seeq);
744 release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
745 free_netdev(dev_seeq);
748 #endif /* MODULE */
751 * Local variables:
752 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
753 * version-control: t
754 * kept-new-versions: 5
755 * tab-width: 4
756 * End: