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