blob: 79dca398f3ac3de724b74174dbfcdb583ceb0301 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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.
6
7 This software may be used and distributed according to the terms
8 of the GNU General Public License, incorporated herein by reference.
9
10 The author may be reached as hamish@zot.apana.org.au
11
12 This file is a network device driver for the SEEQ 8005 chipset and
13 the Linux operating system.
14
15*/
16
17static const char version[] =
18 "seeq8005.c:v1.00 8/07/95 Hamish Coleman (hamish@zot.apana.org.au)\n";
19
20/*
21 Sources:
22 SEEQ 8005 databook
23
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
31*/
32
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
50#include <asm/system.h>
51#include <asm/io.h>
52#include <asm/dma.h>
53
54#include "seeq8005.h"
55
56/* First, a few definitions that the brave might change. */
57/* A zero-terminated list of I/O addresses to be probed. */
58static unsigned int seeq8005_portlist[] __initdata =
59 { 0x300, 0x320, 0x340, 0x360, 0};
60
61/* use 0 for production, 1 for verification, >2 for debug */
62#ifndef NET_DEBUG
63#define NET_DEBUG 1
64#endif
65static unsigned int net_debug = NET_DEBUG;
66
67/* Information that need to be kept for each board. */
68struct net_local {
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. */
72};
73
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
78
79/* Index to functions, as function prototypes. */
80
81static int seeq8005_probe1(struct net_device *dev, int ioaddr);
82static int seeq8005_open(struct net_device *dev);
83static void seeq8005_timeout(struct net_device *dev);
84static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev);
85static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs *regs);
86static void seeq8005_rx(struct net_device *dev);
87static int seeq8005_close(struct net_device *dev);
88static struct net_device_stats *seeq8005_get_stats(struct net_device *dev);
89static void set_multicast_list(struct net_device *dev);
90
91/* Example routines you must write ;->. */
92#define tx_done(dev) (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
93static void hardware_send_packet(struct net_device *dev, char *buf, int length);
94extern void seeq8005_init(struct net_device *dev, int startp);
95static inline void wait_for_buffer(struct net_device *dev);
96
97
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.
101 */
102
103static int io = 0x320;
104static int irq = 10;
105
106struct net_device * __init seeq8005_probe(int unit)
107{
108 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
109 unsigned *port;
110 int err = 0;
111
112 if (!dev)
113 return ERR_PTR(-ENODEV);
114
115 if (unit >= 0) {
116 sprintf(dev->name, "eth%d", unit);
117 netdev_boot_setup_check(dev);
118 io = dev->base_addr;
119 irq = dev->irq;
120 }
121
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. */
125 err = -ENXIO;
126 } else {
127 for (port = seeq8005_portlist; *port; port++) {
128 if (seeq8005_probe1(dev, *port) == 0)
129 break;
130 }
131 if (!*port)
132 err = -ENODEV;
133 }
134 if (err)
135 goto out;
136 err = register_netdev(dev);
137 if (err)
138 goto out1;
139 return dev;
140out1:
141 release_region(dev->base_addr, SEEQ8005_IO_EXTENT);
142out:
143 free_netdev(dev);
144 return ERR_PTR(err);
145}
146
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. */
150
151static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
152{
153 static unsigned version_printed;
154 int i,j;
155 unsigned char SA_prom[32];
156 int old_cfg1;
157 int old_cfg2;
158 int old_stat;
159 int old_dmaar;
160 int old_rear;
161 int retval;
162
163 if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
164 return -ENODEV;
165
166 if (net_debug>1)
167 printk("seeq8005: probing at 0x%x\n",ioaddr);
168
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 */
173 }
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);
178 }
179 retval = -ENODEV;
180 goto out;
181 }
182
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;
189 }
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);
194 }
195 retval = -ENODEV;
196 goto out;
197 }
198
199 old_cfg2 = inw(SEEQ_CFG2); /* read CFG2 register */
200 old_cfg1 = inw(SEEQ_CFG1);
201 old_dmaar = inw(SEEQ_DMAAR);
202
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);
209 }
210
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 */
214
215
216 j=0;
217 for(i=0; i <32; i++) {
218 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
219 }
220
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");
226 }
227 outw( old_stat, SEEQ_STATUS);
228 outw( old_dmaar, SEEQ_DMAAR);
229 outw( old_cfg1, SEEQ_CFG1);
230 retval = -ENODEV;
231 goto out;
232 }
233#endif
234
235 outw( SEEQCFG2_RESET, SEEQ_CFG2); /* reset the card */
236 udelay(5);
237 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
238
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]);
245 }
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(" ");
252 }
253 }
254 printk("\n");
255 }
256 }
257
258#if 0
259 /*
260 * testing the packet buffer memory doesn't work yet
261 * but all other buffer accesses do
262 * - fixing is not a priority
263 */
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);
271 }
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++;
285 }
286 if (j) {
287 printk("%i\n",j);
288 } else {
289 printk("ok.\n");
290 }
291 }
292#endif
293
294 if (net_debug && version_printed++ == 0)
295 printk(version);
296
297 printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
298
299 /* Fill in the 'dev' fields. */
300 dev->base_addr = ioaddr;
301 dev->irq = irq;
302
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]);
306
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();
311
312 outw( SEEQCMD_RX_INT_EN | SEEQCMD_SET_RX_ON | SEEQCMD_SET_RX_OFF, SEEQ_CMD );
313
314 dev->irq = probe_irq_off(cookie);
315
316 if (net_debug >= 2)
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.
321 */
322 dev->irq = 9;
323
324#if 0
325 {
326 int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
327 if (irqval) {
328 printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
329 dev->irq, irqval);
330 retval = -EAGAIN;
331 goto out;
332 }
333 }
334#endif
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;
343
344 return 0;
345out:
346 release_region(ioaddr, SEEQ8005_IO_EXTENT);
347 return retval;
348}
349
350
351/* Open/initialize the board. This is called (in the current kernel)
352 sometime after booting when the 'ifconfig' program is run.
353
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.
357 */
358static int seeq8005_open(struct net_device *dev)
359{
360 struct net_local *lp = netdev_priv(dev);
361
362 {
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;
368 }
369 }
370
371 /* Reset the hardware here. Don't forget to set the station address. */
372 seeq8005_init(dev, 1);
373
374 lp->open_time = jiffies;
375
376 netif_start_queue(dev);
377 return 0;
378}
379
380static void seeq8005_timeout(struct net_device *dev)
381{
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);
389}
390
391static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev)
392{
393 struct net_local *lp = netdev_priv(dev);
394 short length = skb->len;
395 unsigned char *buf;
396
397 if (length < ETH_ZLEN) {
398 skb = skb_padto(skb, ETH_ZLEN);
399 if (skb == NULL)
400 return 0;
401 length = ETH_ZLEN;
402 }
403 buf = skb->data;
404
405 /* Block a timer-based transmit from overlapping */
406 netif_stop_queue(dev);
407
408 hardware_send_packet(dev, buf, length);
409 dev->trans_start = jiffies;
410 lp->stats.tx_bytes += length;
411 dev_kfree_skb (skb);
412 /* You might need to clean up and record Tx statistics here. */
413
414 return 0;
415}
416
417/*
418 * wait_for_buffer
419 *
420 * This routine waits for the SEEQ chip to assert that the FIFO is ready
421 * by checking for a window interrupt, and then clearing it. This has to
422 * occur in the interrupt handler!
423 */
424inline void wait_for_buffer(struct net_device * dev)
425{
426 int ioaddr = dev->base_addr;
427 unsigned long tmp;
428 int status;
429
430 tmp = jiffies + HZ;
431 while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
432 cpu_relax();
433
434 if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
435 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
436}
437
438/* The typical workload of the driver:
439 Handle the network interface interrupts. */
440static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs * regs)
441{
442 struct net_device *dev = dev_id;
443 struct net_local *lp;
444 int ioaddr, status, boguscount = 0;
445 int handled = 0;
446
447 ioaddr = dev->base_addr;
448 lp = netdev_priv(dev);
449
450 status = inw(SEEQ_STATUS);
451 do {
452 if (net_debug >2) {
453 printk("%s: int, status=0x%04x\n",dev->name,status);
454 }
455
456 if (status & SEEQSTAT_WINDOW_INT) {
457 handled = 1;
458 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
459 if (net_debug) {
460 printk("%s: window int!\n",dev->name);
461 }
462 }
463 if (status & SEEQSTAT_TX_INT) {
464 handled = 1;
465 outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
466 lp->stats.tx_packets++;
467 netif_wake_queue(dev); /* Inform upper layers. */
468 }
469 if (status & SEEQSTAT_RX_INT) {
470 handled = 1;
471 /* Got a packet(s). */
472 seeq8005_rx(dev);
473 }
474 status = inw(SEEQ_STATUS);
475 } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
476
477 if(net_debug>2) {
478 printk("%s: eoi\n",dev->name);
479 }
480 return IRQ_RETVAL(handled);
481}
482
483/* We have a good packet(s), get it/them out of the buffers. */
484static void seeq8005_rx(struct net_device *dev)
485{
486 struct net_local *lp = netdev_priv(dev);
487 int boguscount = 10;
488 int pkt_hdr;
489 int ioaddr = dev->base_addr;
490
491 do {
492 int next_packet;
493 int pkt_len;
494 int i;
495 int status;
496
497 status = inw(SEEQ_STATUS);
498 outw( lp->receive_ptr, SEEQ_DMAAR);
499 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
500 wait_for_buffer(dev);
501 next_packet = ntohs(inw(SEEQ_BUFFER));
502 pkt_hdr = inw(SEEQ_BUFFER);
503
504 if (net_debug>2) {
505 printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
506 }
507
508 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) { /* Read all the frames? */
509 return; /* Done for now */
510 }
511
512 if ((pkt_hdr & SEEQPKTS_DONE)==0)
513 break;
514
515 if (next_packet < lp->receive_ptr) {
516 pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
517 } else {
518 pkt_len = next_packet - lp->receive_ptr - 4;
519 }
520
521 if (next_packet < ((DEFAULT_TEA+1)<<8)) { /* is the next_packet address sane? */
522 printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
523 seeq8005_init(dev,1);
524 return;
525 }
526
527 lp->receive_ptr = next_packet;
528
529 if (net_debug>2) {
530 printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
531 }
532
533 if (pkt_hdr & SEEQPKTS_ANY_ERROR) { /* There was an error. */
534 lp->stats.rx_errors++;
535 if (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
536 if (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
537 if (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
538 if (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
539 /* skip over this packet */
540 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
541 outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
542 } else {
543 /* Malloc up new buffer. */
544 struct sk_buff *skb;
545 unsigned char *buf;
546
547 skb = dev_alloc_skb(pkt_len);
548 if (skb == NULL) {
549 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
550 lp->stats.rx_dropped++;
551 break;
552 }
553 skb->dev = dev;
554 skb_reserve(skb, 2); /* align data on 16 byte */
555 buf = skb_put(skb,pkt_len);
556
557 insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
558
559 if (net_debug>2) {
560 char * p = buf;
561 printk("%s: recv ",dev->name);
562 for(i=0;i<14;i++) {
563 printk("%02x ",*(p++)&0xff);
564 }
565 printk("\n");
566 }
567
568 skb->protocol=eth_type_trans(skb,dev);
569 netif_rx(skb);
570 dev->last_rx = jiffies;
571 lp->stats.rx_packets++;
572 lp->stats.rx_bytes += pkt_len;
573 }
574 } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
575
576 /* If any worth-while packets have been received, netif_rx()
577 has done a mark_bh(NET_BH) for us and will work on them
578 when we get to the bottom-half routine. */
579 return;
580}
581
582/* The inverse routine to net_open(). */
583static int seeq8005_close(struct net_device *dev)
584{
585 struct net_local *lp = netdev_priv(dev);
586 int ioaddr = dev->base_addr;
587
588 lp->open_time = 0;
589
590 netif_stop_queue(dev);
591
592 /* Flush the Tx and disable Rx here. */
593 outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
594
595 free_irq(dev->irq, dev);
596
597 /* Update the statistics here. */
598
599 return 0;
600
601}
602
603/* Get the current statistics. This may be called with the card open or
604 closed. */
605static struct net_device_stats *seeq8005_get_stats(struct net_device *dev)
606{
607 struct net_local *lp = netdev_priv(dev);
608
609 return &lp->stats;
610}
611
612/* Set or clear the multicast filter for this adaptor.
613 num_addrs == -1 Promiscuous mode, receive all packets
614 num_addrs == 0 Normal mode, clear multicast list
615 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
616 best-effort filtering.
617 */
618static void set_multicast_list(struct net_device *dev)
619{
620/*
621 * I _could_ do up to 6 addresses here, but won't (yet?)
622 */
623
624#if 0
625 int ioaddr = dev->base_addr;
626/*
627 * hmm, not even sure if my matching works _anyway_ - seem to be receiving
628 * _everything_ . . .
629 */
630
631 if (num_addrs) { /* Enable promiscuous mode */
632 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL, SEEQ_CFG1);
633 dev->flags|=IFF_PROMISC;
634 } else { /* Disable promiscuous mode, use normal mode */
635 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
636 }
637#endif
638}
639
640void seeq8005_init(struct net_device *dev, int startp)
641{
642 struct net_local *lp = netdev_priv(dev);
643 int ioaddr = dev->base_addr;
644 int i;
645
646 outw(SEEQCFG2_RESET, SEEQ_CFG2); /* reset device */
647 udelay(5);
648
649 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
650 outw( 0, SEEQ_DMAAR); /* load start address into both low and high byte */
651/* wait_for_buffer(dev); */ /* I think that you only need a wait for memory buffer */
652 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
653
654 for(i=0;i<6;i++) { /* set Station address */
655 outb(dev->dev_addr[i], SEEQ_BUFFER);
656 udelay(2);
657 }
658
659 outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1); /* set xmit end area pointer to 16K */
660 outb( DEFAULT_TEA, SEEQ_BUFFER); /* this gives us 16K of send buffer and 48K of recv buffer */
661
662 lp->receive_ptr = (DEFAULT_TEA+1)<<8; /* so we can find our packet_header */
663 outw( lp->receive_ptr, SEEQ_RPR); /* Receive Pointer Register is set to recv buffer memory */
664
665 outw( 0x00ff, SEEQ_REA); /* Receive Area End */
666
667 if (net_debug>4) {
668 printk("%s: SA0 = ",dev->name);
669
670 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
671 outw( 0, SEEQ_DMAAR);
672 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
673
674 for(i=0;i<6;i++) {
675 printk("%02x ",inb(SEEQ_BUFFER));
676 }
677 printk("\n");
678 }
679
680 outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
681 outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
682 outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
683
684 if (net_debug>4) {
685 int old_cfg1;
686 old_cfg1 = inw(SEEQ_CFG1);
687 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
688 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
689 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
690 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
691 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
692
693 }
694}
695
696
697static void hardware_send_packet(struct net_device * dev, char *buf, int length)
698{
699 int ioaddr = dev->base_addr;
700 int status = inw(SEEQ_STATUS);
701 int transmit_ptr = 0;
702 int tmp;
703
704 if (net_debug>4) {
705 printk("%s: send 0x%04x\n",dev->name,length);
706 }
707
708 /* Set FIFO to writemode and set packet-buffer address */
709 outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
710 outw( transmit_ptr, SEEQ_DMAAR);
711
712 /* output SEEQ Packet header barfage */
713 outw( htons(length + 4), SEEQ_BUFFER);
714 outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
715
716 /* blat the buffer */
717 outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
718 /* paranoia !! */
719 outw( 0, SEEQ_BUFFER);
720 outw( 0, SEEQ_BUFFER);
721
722 /* set address of start of transmit chain */
723 outw( transmit_ptr, SEEQ_TPR);
724
725 /* drain FIFO */
726 tmp = jiffies;
727 while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && (jiffies - tmp < HZ))
728 mb();
729
730 /* doit ! */
731 outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
732
733}
734
735
736#ifdef MODULE
737
738static struct net_device *dev_seeq;
739MODULE_LICENSE("GPL");
740module_param(io, int, 0);
741module_param(irq, int, 0);
742MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
743MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
744
745int init_module(void)
746{
747 dev_seeq = seeq8005_probe(-1);
748 if (IS_ERR(dev_seeq))
749 return PTR_ERR(dev_seeq);
750 return 0;
751}
752
753void cleanup_module(void)
754{
755 unregister_netdev(dev_seeq);
756 release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
757 free_netdev(dev_seeq);
758}
759
760#endif /* MODULE */
761
762/*
763 * Local variables:
764 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
765 * version-control: t
766 * kept-new-versions: 5
767 * tab-width: 4
768 * End:
769 */