Merge git://git.kernel.org/pub/scm/linux/kernel/git/sam/kbuild-fixes
[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         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 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;
394         netif_wake_queue(dev);
395 }
396
397 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev)
398 {
399         short length = skb->len;
400         unsigned char *buf;
401
402         if (length < ETH_ZLEN) {
403                 if (skb_padto(skb, ETH_ZLEN))
404                         return 0;
405                 length = ETH_ZLEN;
406         }
407         buf = skb->data;
408
409         /* Block a timer-based transmit from overlapping */
410         netif_stop_queue(dev);
411
412         hardware_send_packet(dev, buf, length);
413         dev->trans_start = jiffies;
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 0;
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         return;
582 }
583
584 /* The inverse routine to net_open(). */
585 static int seeq8005_close(struct net_device *dev)
586 {
587         struct net_local *lp = netdev_priv(dev);
588         int ioaddr = dev->base_addr;
589
590         lp->open_time = 0;
591
592         netif_stop_queue(dev);
593
594         /* Flush the Tx and disable Rx here. */
595         outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
596
597         free_irq(dev->irq, dev);
598
599         /* Update the statistics here. */
600
601         return 0;
602
603 }
604
605 /* Set or clear the multicast filter for this adaptor.
606    num_addrs == -1      Promiscuous mode, receive all packets
607    num_addrs == 0       Normal mode, clear multicast list
608    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
609                         best-effort filtering.
610  */
611 static void set_multicast_list(struct net_device *dev)
612 {
613 /*
614  * I _could_ do up to 6 addresses here, but won't (yet?)
615  */
616
617 #if 0
618         int ioaddr = dev->base_addr;
619 /*
620  * hmm, not even sure if my matching works _anyway_ - seem to be receiving
621  * _everything_ . . .
622  */
623
624         if (num_addrs) {                        /* Enable promiscuous mode */
625                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL,  SEEQ_CFG1);
626                 dev->flags|=IFF_PROMISC;
627         } else {                                /* Disable promiscuous mode, use normal mode */
628                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
629         }
630 #endif
631 }
632
633 void seeq8005_init(struct net_device *dev, int startp)
634 {
635         struct net_local *lp = netdev_priv(dev);
636         int ioaddr = dev->base_addr;
637         int i;
638
639         outw(SEEQCFG2_RESET, SEEQ_CFG2);        /* reset device */
640         udelay(5);
641
642         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
643         outw( 0, SEEQ_DMAAR);                   /* load start address into both low and high byte */
644 /*      wait_for_buffer(dev); */                /* I think that you only need a wait for memory buffer */
645         outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
646
647         for(i=0;i<6;i++) {                      /* set Station address */
648                 outb(dev->dev_addr[i], SEEQ_BUFFER);
649                 udelay(2);
650         }
651
652         outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1);  /* set xmit end area pointer to 16K */
653         outb( DEFAULT_TEA, SEEQ_BUFFER);        /* this gives us 16K of send buffer and 48K of recv buffer */
654
655         lp->receive_ptr = (DEFAULT_TEA+1)<<8;   /* so we can find our packet_header */
656         outw( lp->receive_ptr, SEEQ_RPR);       /* Receive Pointer Register is set to recv buffer memory */
657
658         outw( 0x00ff, SEEQ_REA);                /* Receive Area End */
659
660         if (net_debug>4) {
661                 printk("%s: SA0 = ",dev->name);
662
663                 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
664                 outw( 0, SEEQ_DMAAR);
665                 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
666
667                 for(i=0;i<6;i++) {
668                         printk("%02x ",inb(SEEQ_BUFFER));
669                 }
670                 printk("\n");
671         }
672
673         outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
674         outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
675         outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
676
677         if (net_debug>4) {
678                 int old_cfg1;
679                 old_cfg1 = inw(SEEQ_CFG1);
680                 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
681                 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
682                 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
683                 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
684                 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
685
686         }
687 }
688
689
690 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
691 {
692         int ioaddr = dev->base_addr;
693         int status = inw(SEEQ_STATUS);
694         int transmit_ptr = 0;
695         unsigned long tmp;
696
697         if (net_debug>4) {
698                 printk("%s: send 0x%04x\n",dev->name,length);
699         }
700
701         /* Set FIFO to writemode and set packet-buffer address */
702         outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
703         outw( transmit_ptr, SEEQ_DMAAR);
704
705         /* output SEEQ Packet header barfage */
706         outw( htons(length + 4), SEEQ_BUFFER);
707         outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
708
709         /* blat the buffer */
710         outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
711         /* paranoia !! */
712         outw( 0, SEEQ_BUFFER);
713         outw( 0, SEEQ_BUFFER);
714
715         /* set address of start of transmit chain */
716         outw( transmit_ptr, SEEQ_TPR);
717
718         /* drain FIFO */
719         tmp = jiffies;
720         while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && time_before(jiffies, tmp + HZ))
721                 mb();
722
723         /* doit ! */
724         outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
725
726 }
727
728
729 #ifdef MODULE
730
731 static struct net_device *dev_seeq;
732 MODULE_LICENSE("GPL");
733 module_param(io, int, 0);
734 module_param(irq, int, 0);
735 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
736 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
737
738 int __init init_module(void)
739 {
740         dev_seeq = seeq8005_probe(-1);
741         if (IS_ERR(dev_seeq))
742                 return PTR_ERR(dev_seeq);
743         return 0;
744 }
745
746 void __exit cleanup_module(void)
747 {
748         unregister_netdev(dev_seeq);
749         release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
750         free_netdev(dev_seeq);
751 }
752
753 #endif /* MODULE */