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