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