drivers/net: Kill now superfluous ->last_rx stores.
[linux-2.6.git] / drivers / net / seeq8005.c
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.
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
17 static 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 #include <linux/jiffies.h>
50
51 #include <asm/system.h>
52 #include <asm/io.h>
53 #include <asm/dma.h>
54
55 #include "seeq8005.h"
56
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};
61
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;
67
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. */
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
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);
89
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);
95
96
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.
100    */
101
102 static int io = 0x320;
103 static int irq = 10;
104
105 struct net_device * __init seeq8005_probe(int unit)
106 {
107         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
108         unsigned *port;
109         int err = 0;
110
111         if (!dev)
112                 return ERR_PTR(-ENODEV);
113
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;
119         }
120
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;
129                 }
130                 if (!*port)
131                         err = -ENODEV;
132         }
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);
144 }
145
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.  */
149
150 static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
151 {
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
162         if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
163                 return -ENODEV;
164
165         if (net_debug>1)
166                 printk("seeq8005: probing at 0x%x\n",ioaddr);
167
168         old_stat = inw(SEEQ_STATUS);                                    /* read status register */
169         if (old_stat == 0xffff) {
170                 retval = -ENODEV;
171                 goto out;                                               /* assume that 0xffff == no device */
172         }
173         if ( (old_stat & 0x1800) != 0x1800 ) {                          /* assume that unused bits are 1, as my manual says */
174                 if (net_debug>1) {
175                         printk("seeq8005: reserved stat bits != 0x1800\n");
176                         printk("          == 0x%04x\n",old_stat);
177                 }
178                 retval = -ENODEV;
179                 goto out;
180         }
181
182         old_rear = inw(SEEQ_REA);
183         if (old_rear == 0xffff) {
184                 outw(0,SEEQ_REA);
185                 if (inw(SEEQ_REA) == 0xffff) {                          /* assume that 0xffff == no device */
186                         retval = -ENODEV;
187                         goto out;
188                 }
189         } else if ((old_rear & 0xff00) != 0xff00) {                     /* assume that unused bits are 1 */
190                 if (net_debug>1) {
191                         printk("seeq8005: unused rear bits != 0xff00\n");
192                         printk("          == 0x%04x\n",old_rear);
193                 }
194                 retval = -ENODEV;
195                 goto out;
196         }
197
198         old_cfg2 = inw(SEEQ_CFG2);                                      /* read CFG2 register */
199         old_cfg1 = inw(SEEQ_CFG1);
200         old_dmaar = inw(SEEQ_DMAAR);
201
202         if (net_debug>4) {
203                 printk("seeq8005: stat = 0x%04x\n",old_stat);
204                 printk("seeq8005: cfg1 = 0x%04x\n",old_cfg1);
205                 printk("seeq8005: cfg2 = 0x%04x\n",old_cfg2);
206                 printk("seeq8005: raer = 0x%04x\n",old_rear);
207                 printk("seeq8005: dmaar= 0x%04x\n",old_dmaar);
208         }
209
210         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);      /* setup for reading PROM */
211         outw( 0, SEEQ_DMAAR);                                           /* set starting PROM address */
212         outw( SEEQCFG1_BUFFER_PROM, SEEQ_CFG1);                         /* set buffer to look at PROM */
213
214
215         j=0;
216         for(i=0; i <32; i++) {
217                 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
218         }
219
220 #if 0
221         /* untested because I only have the one card */
222         if ( (j&0xff) != 0 ) {                                          /* checksum appears to be 8bit = 0 */
223                 if (net_debug>1) {                                      /* check this before deciding that we have a card */
224                         printk("seeq8005: prom sum error\n");
225                 }
226                 outw( old_stat, SEEQ_STATUS);
227                 outw( old_dmaar, SEEQ_DMAAR);
228                 outw( old_cfg1, SEEQ_CFG1);
229                 retval = -ENODEV;
230                 goto out;
231         }
232 #endif
233
234         outw( SEEQCFG2_RESET, SEEQ_CFG2);                               /* reset the card */
235         udelay(5);
236         outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
237
238         if (net_debug) {
239                 printk("seeq8005: prom sum = 0x%08x\n",j);
240                 for(j=0; j<32; j+=16) {
241                         printk("seeq8005: prom %02x: ",j);
242                         for(i=0;i<16;i++) {
243                                 printk("%02x ",SA_prom[j|i]);
244                         }
245                         printk(" ");
246                         for(i=0;i<16;i++) {
247                                 if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
248                                         printk("%c", SA_prom[j|i]);
249                                 } else {
250                                         printk(" ");
251                                 }
252                         }
253                         printk("\n");
254                 }
255         }
256
257 #if 0
258         /*
259          * testing the packet buffer memory doesn't work yet
260          * but all other buffer accesses do
261          *                      - fixing is not a priority
262          */
263         if (net_debug>1) {                                      /* test packet buffer memory */
264                 printk("seeq8005: testing packet buffer ... ");
265                 outw( SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
266                 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
267                 outw( 0 , SEEQ_DMAAR);
268                 for(i=0;i<32768;i++) {
269                         outw(0x5a5a, SEEQ_BUFFER);
270                 }
271                 j=jiffies+HZ;
272                 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
273                         mb();
274                 outw( 0 , SEEQ_DMAAR);
275                 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
276                         mb();
277                 if ( (inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
278                         outw( SEEQCMD_WINDOW_INT_ACK | (inw(SEEQ_STATUS)& SEEQCMD_INT_MASK), SEEQ_CMD);
279                 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
280                 j=0;
281                 for(i=0;i<32768;i++) {
282                         if (inw(SEEQ_BUFFER) != 0x5a5a)
283                                 j++;
284                 }
285                 if (j) {
286                         printk("%i\n",j);
287                 } else {
288                         printk("ok.\n");
289                 }
290         }
291 #endif
292
293         if (net_debug  &&  version_printed++ == 0)
294                 printk(version);
295
296         printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
297
298         /* Fill in the 'dev' fields. */
299         dev->base_addr = ioaddr;
300         dev->irq = irq;
301
302         /* Retrieve and print the ethernet address. */
303         for (i = 0; i < 6; i++)
304                 dev->dev_addr[i] = SA_prom[i+6];
305         printk("%pM", dev->dev_addr);
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->set_multicast_list = set_multicast_list;
341         dev->flags &= ~IFF_MULTICAST;
342
343         return 0;
344 out:
345         release_region(ioaddr, SEEQ8005_IO_EXTENT);
346         return retval;
347 }
348
349
350 /* Open/initialize the board.  This is called (in the current kernel)
351    sometime after booting when the 'ifconfig' program is run.
352
353    This routine should set everything up anew at each open, even
354    registers that "should" only need to be set once at boot, so that
355    there is non-reboot way to recover if something goes wrong.
356    */
357 static int seeq8005_open(struct net_device *dev)
358 {
359         struct net_local *lp = netdev_priv(dev);
360
361         {
362                  int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
363                  if (irqval) {
364                          printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
365                                          dev->irq, irqval);
366                          return -EAGAIN;
367                  }
368         }
369
370         /* Reset the hardware here.  Don't forget to set the station address. */
371         seeq8005_init(dev, 1);
372
373         lp->open_time = jiffies;
374
375         netif_start_queue(dev);
376         return 0;
377 }
378
379 static void seeq8005_timeout(struct net_device *dev)
380 {
381         int ioaddr = dev->base_addr;
382         printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
383                    tx_done(dev) ? "IRQ conflict" : "network cable problem");
384         /* Try to restart the adaptor. */
385         seeq8005_init(dev, 1);
386         dev->trans_start = jiffies;
387         netif_wake_queue(dev);
388 }
389
390 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev)
391 {
392         short length = skb->len;
393         unsigned char *buf;
394
395         if (length < ETH_ZLEN) {
396                 if (skb_padto(skb, ETH_ZLEN))
397                         return 0;
398                 length = ETH_ZLEN;
399         }
400         buf = skb->data;
401
402         /* Block a timer-based transmit from overlapping */
403         netif_stop_queue(dev);
404
405         hardware_send_packet(dev, buf, length);
406         dev->trans_start = jiffies;
407         dev->stats.tx_bytes += length;
408         dev_kfree_skb (skb);
409         /* You might need to clean up and record Tx statistics here. */
410
411         return 0;
412 }
413
414 /*
415  * wait_for_buffer
416  *
417  * This routine waits for the SEEQ chip to assert that the FIFO is ready
418  * by checking for a window interrupt, and then clearing it. This has to
419  * occur in the interrupt handler!
420  */
421 inline void wait_for_buffer(struct net_device * dev)
422 {
423         int ioaddr = dev->base_addr;
424         unsigned long tmp;
425         int status;
426
427         tmp = jiffies + HZ;
428         while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
429                 cpu_relax();
430
431         if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
432                 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
433 }
434
435 /* The typical workload of the driver:
436    Handle the network interface interrupts. */
437 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id)
438 {
439         struct net_device *dev = dev_id;
440         struct net_local *lp;
441         int ioaddr, status, boguscount = 0;
442         int handled = 0;
443
444         ioaddr = dev->base_addr;
445         lp = netdev_priv(dev);
446
447         status = inw(SEEQ_STATUS);
448         do {
449                 if (net_debug >2) {
450                         printk("%s: int, status=0x%04x\n",dev->name,status);
451                 }
452
453                 if (status & SEEQSTAT_WINDOW_INT) {
454                         handled = 1;
455                         outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
456                         if (net_debug) {
457                                 printk("%s: window int!\n",dev->name);
458                         }
459                 }
460                 if (status & SEEQSTAT_TX_INT) {
461                         handled = 1;
462                         outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
463                         dev->stats.tx_packets++;
464                         netif_wake_queue(dev);  /* Inform upper layers. */
465                 }
466                 if (status & SEEQSTAT_RX_INT) {
467                         handled = 1;
468                         /* Got a packet(s). */
469                         seeq8005_rx(dev);
470                 }
471                 status = inw(SEEQ_STATUS);
472         } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
473
474         if(net_debug>2) {
475                 printk("%s: eoi\n",dev->name);
476         }
477         return IRQ_RETVAL(handled);
478 }
479
480 /* We have a good packet(s), get it/them out of the buffers. */
481 static void seeq8005_rx(struct net_device *dev)
482 {
483         struct net_local *lp = netdev_priv(dev);
484         int boguscount = 10;
485         int pkt_hdr;
486         int ioaddr = dev->base_addr;
487
488         do {
489                 int next_packet;
490                 int pkt_len;
491                 int i;
492                 int status;
493
494                 status = inw(SEEQ_STATUS);
495                 outw( lp->receive_ptr, SEEQ_DMAAR);
496                 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
497                 wait_for_buffer(dev);
498                 next_packet = ntohs(inw(SEEQ_BUFFER));
499                 pkt_hdr = inw(SEEQ_BUFFER);
500
501                 if (net_debug>2) {
502                         printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
503                 }
504
505                 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) {    /* Read all the frames? */
506                         return;                                                 /* Done for now */
507                 }
508
509                 if ((pkt_hdr & SEEQPKTS_DONE)==0)
510                         break;
511
512                 if (next_packet < lp->receive_ptr) {
513                         pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
514                 } else {
515                         pkt_len = next_packet - lp->receive_ptr - 4;
516                 }
517
518                 if (next_packet < ((DEFAULT_TEA+1)<<8)) {                       /* is the next_packet address sane? */
519                         printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
520                         seeq8005_init(dev,1);
521                         return;
522                 }
523
524                 lp->receive_ptr = next_packet;
525
526                 if (net_debug>2) {
527                         printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
528                 }
529
530                 if (pkt_hdr & SEEQPKTS_ANY_ERROR) {                             /* There was an error. */
531                         dev->stats.rx_errors++;
532                         if (pkt_hdr & SEEQPKTS_SHORT) dev->stats.rx_frame_errors++;
533                         if (pkt_hdr & SEEQPKTS_DRIB) dev->stats.rx_frame_errors++;
534                         if (pkt_hdr & SEEQPKTS_OVERSIZE) dev->stats.rx_over_errors++;
535                         if (pkt_hdr & SEEQPKTS_CRC_ERR) dev->stats.rx_crc_errors++;
536                         /* skip over this packet */
537                         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
538                         outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
539                 } else {
540                         /* Malloc up new buffer. */
541                         struct sk_buff *skb;
542                         unsigned char *buf;
543
544                         skb = dev_alloc_skb(pkt_len);
545                         if (skb == NULL) {
546                                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
547                                 dev->stats.rx_dropped++;
548                                 break;
549                         }
550                         skb_reserve(skb, 2);    /* align data on 16 byte */
551                         buf = skb_put(skb,pkt_len);
552
553                         insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
554
555                         if (net_debug>2) {
556                                 char * p = buf;
557                                 printk("%s: recv ",dev->name);
558                                 for(i=0;i<14;i++) {
559                                         printk("%02x ",*(p++)&0xff);
560                                 }
561                                 printk("\n");
562                         }
563
564                         skb->protocol=eth_type_trans(skb,dev);
565                         netif_rx(skb);
566                         dev->stats.rx_packets++;
567                         dev->stats.rx_bytes += pkt_len;
568                 }
569         } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
570
571         /* If any worth-while packets have been received, netif_rx()
572            has done a mark_bh(NET_BH) for us and will work on them
573            when we get to the bottom-half routine. */
574         return;
575 }
576
577 /* The inverse routine to net_open(). */
578 static int seeq8005_close(struct net_device *dev)
579 {
580         struct net_local *lp = netdev_priv(dev);
581         int ioaddr = dev->base_addr;
582
583         lp->open_time = 0;
584
585         netif_stop_queue(dev);
586
587         /* Flush the Tx and disable Rx here. */
588         outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
589
590         free_irq(dev->irq, dev);
591
592         /* Update the statistics here. */
593
594         return 0;
595
596 }
597
598 /* Set or clear the multicast filter for this adaptor.
599    num_addrs == -1      Promiscuous mode, receive all packets
600    num_addrs == 0       Normal mode, clear multicast list
601    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
602                         best-effort filtering.
603  */
604 static void set_multicast_list(struct net_device *dev)
605 {
606 /*
607  * I _could_ do up to 6 addresses here, but won't (yet?)
608  */
609
610 #if 0
611         int ioaddr = dev->base_addr;
612 /*
613  * hmm, not even sure if my matching works _anyway_ - seem to be receiving
614  * _everything_ . . .
615  */
616
617         if (num_addrs) {                        /* Enable promiscuous mode */
618                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL,  SEEQ_CFG1);
619                 dev->flags|=IFF_PROMISC;
620         } else {                                /* Disable promiscuous mode, use normal mode */
621                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
622         }
623 #endif
624 }
625
626 void seeq8005_init(struct net_device *dev, int startp)
627 {
628         struct net_local *lp = netdev_priv(dev);
629         int ioaddr = dev->base_addr;
630         int i;
631
632         outw(SEEQCFG2_RESET, SEEQ_CFG2);        /* reset device */
633         udelay(5);
634
635         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
636         outw( 0, SEEQ_DMAAR);                   /* load start address into both low and high byte */
637 /*      wait_for_buffer(dev); */                /* I think that you only need a wait for memory buffer */
638         outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
639
640         for(i=0;i<6;i++) {                      /* set Station address */
641                 outb(dev->dev_addr[i], SEEQ_BUFFER);
642                 udelay(2);
643         }
644
645         outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1);  /* set xmit end area pointer to 16K */
646         outb( DEFAULT_TEA, SEEQ_BUFFER);        /* this gives us 16K of send buffer and 48K of recv buffer */
647
648         lp->receive_ptr = (DEFAULT_TEA+1)<<8;   /* so we can find our packet_header */
649         outw( lp->receive_ptr, SEEQ_RPR);       /* Receive Pointer Register is set to recv buffer memory */
650
651         outw( 0x00ff, SEEQ_REA);                /* Receive Area End */
652
653         if (net_debug>4) {
654                 printk("%s: SA0 = ",dev->name);
655
656                 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
657                 outw( 0, SEEQ_DMAAR);
658                 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
659
660                 for(i=0;i<6;i++) {
661                         printk("%02x ",inb(SEEQ_BUFFER));
662                 }
663                 printk("\n");
664         }
665
666         outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
667         outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
668         outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
669
670         if (net_debug>4) {
671                 int old_cfg1;
672                 old_cfg1 = inw(SEEQ_CFG1);
673                 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
674                 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
675                 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
676                 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
677                 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
678
679         }
680 }
681
682
683 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
684 {
685         int ioaddr = dev->base_addr;
686         int status = inw(SEEQ_STATUS);
687         int transmit_ptr = 0;
688         unsigned long tmp;
689
690         if (net_debug>4) {
691                 printk("%s: send 0x%04x\n",dev->name,length);
692         }
693
694         /* Set FIFO to writemode and set packet-buffer address */
695         outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
696         outw( transmit_ptr, SEEQ_DMAAR);
697
698         /* output SEEQ Packet header barfage */
699         outw( htons(length + 4), SEEQ_BUFFER);
700         outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
701
702         /* blat the buffer */
703         outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
704         /* paranoia !! */
705         outw( 0, SEEQ_BUFFER);
706         outw( 0, SEEQ_BUFFER);
707
708         /* set address of start of transmit chain */
709         outw( transmit_ptr, SEEQ_TPR);
710
711         /* drain FIFO */
712         tmp = jiffies;
713         while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && time_before(jiffies, tmp + HZ))
714                 mb();
715
716         /* doit ! */
717         outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
718
719 }
720
721
722 #ifdef MODULE
723
724 static struct net_device *dev_seeq;
725 MODULE_LICENSE("GPL");
726 module_param(io, int, 0);
727 module_param(irq, int, 0);
728 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
729 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
730
731 int __init init_module(void)
732 {
733         dev_seeq = seeq8005_probe(-1);
734         if (IS_ERR(dev_seeq))
735                 return PTR_ERR(dev_seeq);
736         return 0;
737 }
738
739 void __exit cleanup_module(void)
740 {
741         unregister_netdev(dev_seeq);
742         release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
743         free_netdev(dev_seeq);
744 }
745
746 #endif /* MODULE */
747
748 /*
749  * Local variables:
750  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
751  *  version-control: t
752  *  kept-new-versions: 5
753  *  tab-width: 4
754  * End:
755  */