?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Merge branch 'ath6kl-next' of master.kernel.org:/pub/scm/linux/kernel/git...
[linux-2.6/next.git] / drivers / net / seeq8005.c
blobd2fce98f557fbf2195c704e1d7b56a1339c916aa
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 */
linux-next