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