1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <linux/module.h>
35#include <linux/kernel.h>
36#include <linux/sched.h>
37#include <linux/types.h>
38#include <linux/fcntl.h>
39#include <linux/interrupt.h>
40#include <linux/ptrace.h>
41#include <linux/ioport.h>
42#include <linux/in.h>
43#include <linux/slab.h>
44#include <linux/string.h>
45#include <linux/errno.h>
46#include <linux/init.h>
47#include <linux/netdevice.h>
48#include <linux/etherdevice.h>
49#include <linux/skbuff.h>
50
51#include <asm/system.h>
52#include <asm/bitops.h>
53#include <asm/io.h>
54#include <asm/dma.h>
55#include <asm/ecard.h>
56
57#define __ETHER1_C
58#include "ether1.h"
59
60static unsigned int net_debug = NET_DEBUG;
61
62#define BUFFER_SIZE 0x10000
63#define TX_AREA_START 0x00100
64#define TX_AREA_END 0x05000
65#define RX_AREA_START 0x05000
66#define RX_AREA_END 0x0fc00
67
68static int ether1_open(struct net_device *dev);
69static int ether1_sendpacket(struct sk_buff *skb, struct net_device *dev);
70static void ether1_interrupt(int irq, void *dev_id, struct pt_regs *regs);
71static int ether1_close(struct net_device *dev);
72static struct net_device_stats *ether1_getstats(struct net_device *dev);
73static void ether1_setmulticastlist(struct net_device *dev);
74static void ether1_timeout(struct net_device *dev);
75
76
77
78static char version[] __initdata = "ether1 ethernet driver (c) 2000 Russell King v1.07\n";
79
80#define BUS_16 16
81#define BUS_8 8
82
83static const card_ids __init ether1_cids[] = {
84 { MANU_ACORN, PROD_ACORN_ETHER1 },
85 { 0xffff, 0xffff }
86};
87
88
89
90#define DISABLEIRQS 1
91#define NORMALIRQS 0
92
93#define ether1_inw(dev, addr, type, offset, svflgs) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset), svflgs)
94#define ether1_outw(dev, val, addr, type, offset, svflgs) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset), svflgs)
95
96static inline unsigned short
97ether1_inw_p (struct net_device *dev, int addr, int svflgs)
98{
99 unsigned long flags;
100 unsigned short ret;
101
102 if (svflgs) {
103 save_flags_cli (flags);
104 }
105 outb (addr >> 12, REG_PAGE);
106 ret = inw (ETHER1_RAM + ((addr & 4095) >> 1));
107 if (svflgs)
108 restore_flags (flags);
109 return ret;
110}
111
112static inline void
113ether1_outw_p (struct net_device *dev, unsigned short val, int addr, int svflgs)
114{
115 unsigned long flags;
116
117 if (svflgs) {
118 save_flags_cli (flags);
119 }
120 outb (addr >> 12, REG_PAGE);
121 outw (val, ETHER1_RAM + ((addr & 4095) >> 1));
122 if (svflgs)
123 restore_flags (flags);
124}
125
126
127
128
129
130
131
132
133
134
135static void
136ether1_writebuffer (struct net_device *dev, void *data, unsigned int start, unsigned int length)
137{
138 unsigned int page, thislen, offset, addr;
139
140 offset = start & 4095;
141 page = start >> 12;
142 addr = ioaddr(ETHER1_RAM + (offset >> 1));
143
144 if (offset + length > 4096)
145 thislen = 4096 - offset;
146 else
147 thislen = length;
148
149 do {
150 int used;
151
152 outb(page, REG_PAGE);
153 length -= thislen;
154
155 __asm__ __volatile__(
156 "subs %3, %3, #2
157 bmi 2f
1581: ldr %0, [%1], #2
159 mov %0, %0, lsl #16
160 orr %0, %0, %0, lsr #16
161 str %0, [%2], #4
162 subs %3, %3, #2
163 bmi 2f
164 ldr %0, [%1], #2
165 mov %0, %0, lsl #16
166 orr %0, %0, %0, lsr #16
167 str %0, [%2], #4
168 subs %3, %3, #2
169 bmi 2f
170 ldr %0, [%1], #2
171 mov %0, %0, lsl #16
172 orr %0, %0, %0, lsr #16
173 str %0, [%2], #4
174 subs %3, %3, #2
175 bmi 2f
176 ldr %0, [%1], #2
177 mov %0, %0, lsl #16
178 orr %0, %0, %0, lsr #16
179 str %0, [%2], #4
180 subs %3, %3, #2
181 bpl 1b
1822: adds %3, %3, #1
183 ldreqb %0, [%1]
184 streqb %0, [%2]"
185 : "=&r" (used), "=&r" (data)
186 : "r" (addr), "r" (thislen), "1" (data));
187
188 addr = ioaddr(ETHER1_RAM);
189
190 thislen = length;
191 if (thislen > 4096)
192 thislen = 4096;
193 page++;
194 } while (thislen);
195}
196
197static void
198ether1_readbuffer (struct net_device *dev, void *data, unsigned int start, unsigned int length)
199{
200 unsigned int page, thislen, offset, addr;
201
202 offset = start & 4095;
203 page = start >> 12;
204 addr = ioaddr(ETHER1_RAM + (offset >> 1));
205
206 if (offset + length > 4096)
207 thislen = 4096 - offset;
208 else
209 thislen = length;
210
211 do {
212 int used;
213
214 outb(page, REG_PAGE);
215 length -= thislen;
216
217 __asm__ __volatile__(
218 "subs %3, %3, #2
219 bmi 2f
2201: ldr %0, [%2], #4
221 strb %0, [%1], #1
222 mov %0, %0, lsr #8
223 strb %0, [%1], #1
224 subs %3, %3, #2
225 bmi 2f
226 ldr %0, [%2], #4
227 strb %0, [%1], #1
228 mov %0, %0, lsr #8
229 strb %0, [%1], #1
230 subs %3, %3, #2
231 bmi 2f
232 ldr %0, [%2], #4
233 strb %0, [%1], #1
234 mov %0, %0, lsr #8
235 strb %0, [%1], #1
236 subs %3, %3, #2
237 bmi 2f
238 ldr %0, [%2], #4
239 strb %0, [%1], #1
240 mov %0, %0, lsr #8
241 strb %0, [%1], #1
242 subs %3, %3, #2
243 bpl 1b
2442: adds %3, %3, #1
245 ldreqb %0, [%2]
246 streqb %0, [%1]"
247 : "=&r" (used), "=&r" (data)
248 : "r" (addr), "r" (thislen), "1" (data));
249
250 addr = ioaddr(ETHER1_RAM);
251
252 thislen = length;
253 if (thislen > 4096)
254 thislen = 4096;
255 page++;
256 } while (thislen);
257}
258
259static int __init
260ether1_ramtest(struct net_device *dev, unsigned char byte)
261{
262 unsigned char *buffer = kmalloc (BUFFER_SIZE, GFP_KERNEL);
263 int i, ret = BUFFER_SIZE;
264 int max_errors = 15;
265 int bad = -1;
266 int bad_start = 0;
267
268 if (!buffer)
269 return 1;
270
271 memset (buffer, byte, BUFFER_SIZE);
272 ether1_writebuffer (dev, buffer, 0, BUFFER_SIZE);
273 memset (buffer, byte ^ 0xff, BUFFER_SIZE);
274 ether1_readbuffer (dev, buffer, 0, BUFFER_SIZE);
275
276 for (i = 0; i < BUFFER_SIZE; i++) {
277 if (buffer[i] != byte) {
278 if (max_errors >= 0 && bad != buffer[i]) {
279 if (bad != -1)
280 printk ("\n");
281 printk (KERN_CRIT "%s: RAM failed with (%02X instead of %02X) at 0x%04X",
282 dev->name, buffer[i], byte, i);
283 ret = -ENODEV;
284 max_errors --;
285 bad = buffer[i];
286 bad_start = i;
287 }
288 } else {
289 if (bad != -1) {
290 if (bad_start == i - 1)
291 printk ("\n");
292 else
293 printk (" - 0x%04X\n", i - 1);
294 bad = -1;
295 }
296 }
297 }
298
299 if (bad != -1)
300 printk (" - 0x%04X\n", BUFFER_SIZE);
301 kfree (buffer);
302
303 return ret;
304}
305
306static int
307ether1_reset (struct net_device *dev)
308{
309 outb (CTRL_RST|CTRL_ACK, REG_CONTROL);
310 return BUS_16;
311}
312
313static int __init
314ether1_init_2(struct net_device *dev)
315{
316 int i;
317 dev->mem_start = 0;
318
319 i = ether1_ramtest (dev, 0x5a);
320
321 if (i > 0)
322 i = ether1_ramtest (dev, 0x1e);
323
324 if (i <= 0)
325 return -ENODEV;
326
327 dev->mem_end = i;
328 return 0;
329}
330
331
332
333
334
335
336
337#define NOP_ADDR (TX_AREA_START)
338#define NOP_SIZE (0x06)
339static nop_t init_nop = {
340 0,
341 CMD_NOP,
342 NOP_ADDR
343};
344
345
346#define TDR_ADDR (0x003a)
347#define TDR_SIZE (0x08)
348static tdr_t init_tdr = {
349 0,
350 CMD_TDR | CMD_INTR,
351 NOP_ADDR,
352 0
353};
354
355
356#define MC_ADDR (0x002e)
357#define MC_SIZE (0x0c)
358static mc_t init_mc = {
359 0,
360 CMD_SETMULTICAST,
361 TDR_ADDR,
362 0,
363 { { 0, } }
364};
365
366
367#define SA_ADDR (0x0022)
368#define SA_SIZE (0x0c)
369static sa_t init_sa = {
370 0,
371 CMD_SETADDRESS,
372 MC_ADDR,
373 { 0, }
374};
375
376
377#define CFG_ADDR (0x0010)
378#define CFG_SIZE (0x12)
379static cfg_t init_cfg = {
380 0,
381 CMD_CONFIG,
382 SA_ADDR,
383 8,
384 8,
385 CFG8_SRDY,
386 CFG9_PREAMB8 | CFG9_ADDRLENBUF | CFG9_ADDRLEN(6),
387 0,
388 0x60,
389 0,
390 CFG13_RETRY(15) | CFG13_SLOTH(2),
391 0,
392};
393
394
395#define SCB_ADDR (0x0000)
396#define SCB_SIZE (0x10)
397static scb_t init_scb = {
398 0,
399 SCB_CMDACKRNR | SCB_CMDACKCNA | SCB_CMDACKFR | SCB_CMDACKCX,
400 CFG_ADDR,
401 RX_AREA_START,
402 0,
403 0,
404 0,
405 0
406};
407
408
409#define ISCP_ADDR (0xffee)
410#define ISCP_SIZE (0x08)
411static iscp_t init_iscp = {
412 1,
413 SCB_ADDR,
414 0x0000,
415 0x0000
416};
417
418
419#define SCP_ADDR (0xfff6)
420#define SCP_SIZE (0x0a)
421static scp_t init_scp = {
422 SCP_SY_16BBUS,
423 { 0, 0 },
424 ISCP_ADDR,
425 0
426};
427
428#define RFD_SIZE (0x16)
429static rfd_t init_rfd = {
430 0,
431 0,
432 0,
433 0,
434 { 0, },
435 { 0, },
436 0
437};
438
439#define RBD_SIZE (0x0a)
440static rbd_t init_rbd = {
441 0,
442 0,
443 0,
444 0,
445 ETH_FRAME_LEN + 8
446};
447
448#define TX_SIZE (0x08)
449#define TBD_SIZE (0x08)
450
451static int
452ether1_init_for_open (struct net_device *dev)
453{
454 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
455 int i, status, addr, next, next2;
456 int failures = 0;
457
458 outb (CTRL_RST|CTRL_ACK, REG_CONTROL);
459
460 for (i = 0; i < 6; i++)
461 init_sa.sa_addr[i] = dev->dev_addr[i];
462
463
464 ether1_writebuffer (dev, &init_scp, SCP_ADDR, SCP_SIZE);
465 ether1_writebuffer (dev, &init_iscp, ISCP_ADDR, ISCP_SIZE);
466 ether1_writebuffer (dev, &init_scb, SCB_ADDR, SCB_SIZE);
467 ether1_writebuffer (dev, &init_cfg, CFG_ADDR, CFG_SIZE);
468 ether1_writebuffer (dev, &init_sa, SA_ADDR, SA_SIZE);
469 ether1_writebuffer (dev, &init_mc, MC_ADDR, MC_SIZE);
470 ether1_writebuffer (dev, &init_tdr, TDR_ADDR, TDR_SIZE);
471 ether1_writebuffer (dev, &init_nop, NOP_ADDR, NOP_SIZE);
472
473 if (ether1_inw (dev, CFG_ADDR, cfg_t, cfg_command, NORMALIRQS) != CMD_CONFIG) {
474 printk (KERN_ERR "%s: detected either RAM fault or compiler bug\n",
475 dev->name);
476 return 1;
477 }
478
479
480
481
482
483
484
485 addr = RX_AREA_START;
486 do {
487 next = addr + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10;
488 next2 = next + RFD_SIZE + RBD_SIZE + ETH_FRAME_LEN + 10;
489
490 if (next2 >= RX_AREA_END) {
491 next = RX_AREA_START;
492 init_rfd.rfd_command = RFD_CMDEL | RFD_CMDSUSPEND;
493 priv->rx_tail = addr;
494 } else
495 init_rfd.rfd_command = 0;
496 if (addr == RX_AREA_START)
497 init_rfd.rfd_rbdoffset = addr + RFD_SIZE;
498 else
499 init_rfd.rfd_rbdoffset = 0;
500 init_rfd.rfd_link = next;
501 init_rbd.rbd_link = next + RFD_SIZE;
502 init_rbd.rbd_bufl = addr + RFD_SIZE + RBD_SIZE;
503
504 ether1_writebuffer (dev, &init_rfd, addr, RFD_SIZE);
505 ether1_writebuffer (dev, &init_rbd, addr + RFD_SIZE, RBD_SIZE);
506 addr = next;
507 } while (next2 < RX_AREA_END);
508
509 priv->tx_link = NOP_ADDR;
510 priv->tx_head = NOP_ADDR + NOP_SIZE;
511 priv->tx_tail = TDR_ADDR;
512 priv->rx_head = RX_AREA_START;
513
514
515 priv->resetting = 1;
516 priv->initialising = 1;
517 outb (CTRL_RST, REG_CONTROL);
518 outb (0, REG_CONTROL);
519 outb (CTRL_CA, REG_CONTROL);
520
521
522 i = jiffies + HZ/2;
523 while (ether1_inw (dev, ISCP_ADDR, iscp_t, iscp_busy, DISABLEIRQS) == 1) {
524 if (time_after(jiffies, i)) {
525 printk (KERN_WARNING "%s: can't initialise 82586: iscp is busy\n", dev->name);
526 return 1;
527 }
528 }
529
530
531 i += HZ/10;
532 while (((status = ether1_inw (dev, CFG_ADDR, cfg_t, cfg_status, DISABLEIRQS))
533 & STAT_COMPLETE) == 0) {
534 if (time_after(jiffies, i))
535 break;
536 }
537
538 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
539 printk (KERN_WARNING "%s: can't initialise 82586: config status %04X\n", dev->name, status);
540 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name,
541 ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS),
542 ether1_inw (dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS),
543 ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS),
544 ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS));
545 failures += 1;
546 }
547
548 i += HZ/10;
549 while (((status = ether1_inw (dev, SA_ADDR, sa_t, sa_status, DISABLEIRQS))
550 & STAT_COMPLETE) == 0) {
551 if (time_after(jiffies, i))
552 break;
553 }
554
555 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
556 printk (KERN_WARNING "%s: can't initialise 82586: set address status %04X\n", dev->name, status);
557 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name,
558 ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS),
559 ether1_inw (dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS),
560 ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS),
561 ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS));
562 failures += 1;
563 }
564
565 i += HZ/10;
566 while (((status = ether1_inw (dev, MC_ADDR, mc_t, mc_status, DISABLEIRQS))
567 & STAT_COMPLETE) == 0) {
568 if (time_after(jiffies, i))
569 break;
570 }
571
572 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
573 printk (KERN_WARNING "%s: can't initialise 82586: set multicast status %04X\n", dev->name, status);
574 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name,
575 ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS),
576 ether1_inw (dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS),
577 ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS),
578 ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS));
579 failures += 1;
580 }
581
582 i += HZ;
583 while (((status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_status, DISABLEIRQS))
584 & STAT_COMPLETE) == 0) {
585 if (time_after(jiffies, i))
586 break;
587 }
588
589 if ((status & (STAT_COMPLETE | STAT_OK)) != (STAT_COMPLETE | STAT_OK)) {
590 printk (KERN_WARNING "%s: can't tdr (ignored)\n", dev->name);
591 printk (KERN_DEBUG "%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev->name,
592 ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS),
593 ether1_inw (dev, SCB_ADDR, scb_t, scb_command, NORMALIRQS),
594 ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS),
595 ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset, NORMALIRQS));
596 } else {
597 status = ether1_inw (dev, TDR_ADDR, tdr_t, tdr_result, DISABLEIRQS);
598 if (status & TDR_XCVRPROB)
599 printk (KERN_WARNING "%s: i/f failed tdr: transceiver problem\n", dev->name);
600 else if ((status & (TDR_SHORT|TDR_OPEN)) && (status & TDR_TIME)) {
601#ifdef FANCY
602 printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d.%d us away\n", dev->name,
603 status & TDR_SHORT ? "short" : "open", (status & TDR_TIME) / 10,
604 (status & TDR_TIME) % 10);
605#else
606 printk (KERN_WARNING "%s: i/f failed tdr: cable %s %d clks away\n", dev->name,
607 status & TDR_SHORT ? "short" : "open", (status & TDR_TIME));
608#endif
609 }
610 }
611
612 if (failures)
613 ether1_reset (dev);
614 return failures ? 1 : 0;
615}
616
617
618
619static int
620ether1_txalloc (struct net_device *dev, int size)
621{
622 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
623 int start, tail;
624
625 size = (size + 1) & ~1;
626 tail = priv->tx_tail;
627
628 if (priv->tx_head + size > TX_AREA_END) {
629 if (tail > priv->tx_head)
630 return -1;
631 start = TX_AREA_START;
632 if (start + size > tail)
633 return -1;
634 priv->tx_head = start + size;
635 } else {
636 if (priv->tx_head < tail && (priv->tx_head + size) > tail)
637 return -1;
638 start = priv->tx_head;
639 priv->tx_head += size;
640 }
641
642 return start;
643}
644
645static int
646ether1_open (struct net_device *dev)
647{
648 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
649
650 if (request_irq(dev->irq, ether1_interrupt, 0, "ether1", dev))
651 return -EAGAIN;
652
653 memset (&priv->stats, 0, sizeof (struct net_device_stats));
654
655 if (ether1_init_for_open (dev)) {
656 free_irq (dev->irq, dev);
657 return -EAGAIN;
658 }
659
660 netif_start_queue(dev);
661
662 return 0;
663}
664
665static void
666ether1_timeout(struct net_device *dev)
667{
668 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
669
670 printk(KERN_WARNING "%s: transmit timeout, network cable problem?\n",
671 dev->name);
672 printk(KERN_WARNING "%s: resetting device\n", dev->name);
673
674 ether1_reset (dev);
675
676 if (ether1_init_for_open (dev))
677 printk (KERN_ERR "%s: unable to restart interface\n", dev->name);
678
679 priv->stats.tx_errors++;
680 netif_wake_queue(dev);
681}
682
683static int
684ether1_sendpacket (struct sk_buff *skb, struct net_device *dev)
685{
686 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
687 int len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
688 int tmp, tst, nopaddr, txaddr, tbdaddr, dataddr;
689 unsigned long flags;
690 tx_t tx;
691 tbd_t tbd;
692 nop_t nop;
693
694 if (priv->restart) {
695 printk(KERN_WARNING "%s: resetting device\n", dev->name);
696
697 ether1_reset(dev);
698
699 if (ether1_init_for_open(dev))
700 printk(KERN_ERR "%s: unable to restart interface\n", dev->name);
701 else
702 priv->restart = 0;
703 }
704
705
706
707
708 txaddr = ether1_txalloc (dev, TX_SIZE);
709 tbdaddr = ether1_txalloc (dev, TBD_SIZE);
710 dataddr = ether1_txalloc (dev, len);
711 nopaddr = ether1_txalloc (dev, NOP_SIZE);
712
713 tx.tx_status = 0;
714 tx.tx_command = CMD_TX | CMD_INTR;
715 tx.tx_link = nopaddr;
716 tx.tx_tbdoffset = tbdaddr;
717 tbd.tbd_opts = TBD_EOL | len;
718 tbd.tbd_link = I82586_NULL;
719 tbd.tbd_bufl = dataddr;
720 tbd.tbd_bufh = 0;
721 nop.nop_status = 0;
722 nop.nop_command = CMD_NOP;
723 nop.nop_link = nopaddr;
724
725 save_flags_cli(flags);
726 ether1_writebuffer (dev, &tx, txaddr, TX_SIZE);
727 ether1_writebuffer (dev, &tbd, tbdaddr, TBD_SIZE);
728 ether1_writebuffer (dev, skb->data, dataddr, len);
729 ether1_writebuffer (dev, &nop, nopaddr, NOP_SIZE);
730 tmp = priv->tx_link;
731 priv->tx_link = nopaddr;
732
733
734 ether1_outw (dev, txaddr, tmp, nop_t, nop_link, NORMALIRQS);
735
736 restore_flags(flags);
737
738
739 dev->trans_start = jiffies;
740
741
742 tmp = priv->tx_head;
743 tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN);
744 priv->tx_head = tmp;
745 dev_kfree_skb (skb);
746
747 if (tst == -1)
748 netif_stop_queue(dev);
749
750 return 0;
751}
752
753static void
754ether1_xmit_done (struct net_device *dev)
755{
756 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
757 nop_t nop;
758 int caddr, tst;
759
760 caddr = priv->tx_tail;
761
762again:
763 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
764
765 switch (nop.nop_command & CMD_MASK) {
766 case CMD_TDR:
767
768 if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
769 != (unsigned short)I82586_NULL) {
770 ether1_outw(dev, SCB_CMDCUCSTART | SCB_CMDRXSTART, SCB_ADDR, scb_t,
771 scb_command, NORMALIRQS);
772 outb (CTRL_CA, REG_CONTROL);
773 }
774 priv->tx_tail = NOP_ADDR;
775 return;
776
777 case CMD_NOP:
778 if (nop.nop_link == caddr) {
779 if (priv->initialising == 0)
780 printk (KERN_WARNING "%s: strange command complete with no tx command!\n", dev->name);
781 else
782 priv->initialising = 0;
783 return;
784 }
785 if (caddr == nop.nop_link)
786 return;
787 caddr = nop.nop_link;
788 goto again;
789
790 case CMD_TX:
791 if (nop.nop_status & STAT_COMPLETE)
792 break;
793 printk (KERN_ERR "%s: strange command complete without completed command\n", dev->name);
794 priv->restart = 1;
795 return;
796
797 default:
798 printk (KERN_WARNING "%s: strange command %d complete! (offset %04X)", dev->name,
799 nop.nop_command & CMD_MASK, caddr);
800 priv->restart = 1;
801 return;
802 }
803
804 while (nop.nop_status & STAT_COMPLETE) {
805 if (nop.nop_status & STAT_OK) {
806 priv->stats.tx_packets ++;
807 priv->stats.collisions += (nop.nop_status & STAT_COLLISIONS);
808 } else {
809 priv->stats.tx_errors ++;
810
811 if (nop.nop_status & STAT_COLLAFTERTX)
812 priv->stats.collisions ++;
813 if (nop.nop_status & STAT_NOCARRIER)
814 priv->stats.tx_carrier_errors ++;
815 if (nop.nop_status & STAT_TXLOSTCTS)
816 printk (KERN_WARNING "%s: cts lost\n", dev->name);
817 if (nop.nop_status & STAT_TXSLOWDMA)
818 priv->stats.tx_fifo_errors ++;
819 if (nop.nop_status & STAT_COLLEXCESSIVE)
820 priv->stats.collisions += 16;
821 }
822
823 if (nop.nop_link == caddr) {
824 printk (KERN_ERR "%s: tx buffer chaining error: tx command points to itself\n", dev->name);
825 break;
826 }
827
828 caddr = nop.nop_link;
829 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
830 if ((nop.nop_command & CMD_MASK) != CMD_NOP) {
831 printk (KERN_ERR "%s: tx buffer chaining error: no nop after tx command\n", dev->name);
832 break;
833 }
834
835 if (caddr == nop.nop_link)
836 break;
837
838 caddr = nop.nop_link;
839 ether1_readbuffer (dev, &nop, caddr, NOP_SIZE);
840 if ((nop.nop_command & CMD_MASK) != CMD_TX) {
841 printk (KERN_ERR "%s: tx buffer chaining error: no tx command after nop\n", dev->name);
842 break;
843 }
844 }
845 priv->tx_tail = caddr;
846
847 caddr = priv->tx_head;
848 tst = ether1_txalloc (dev, TX_SIZE + TBD_SIZE + NOP_SIZE + ETH_FRAME_LEN);
849 priv->tx_head = caddr;
850 if (tst != -1)
851 netif_wake_queue(dev);
852}
853
854static void
855ether1_recv_done (struct net_device *dev)
856{
857 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
858 int status;
859 int nexttail, rbdaddr;
860 rbd_t rbd;
861
862 do {
863 status = ether1_inw (dev, priv->rx_head, rfd_t, rfd_status, NORMALIRQS);
864 if ((status & RFD_COMPLETE) == 0)
865 break;
866
867 rbdaddr = ether1_inw (dev, priv->rx_head, rfd_t, rfd_rbdoffset, NORMALIRQS);
868 ether1_readbuffer (dev, &rbd, rbdaddr, RBD_SIZE);
869
870 if ((rbd.rbd_status & (RBD_EOF | RBD_ACNTVALID)) == (RBD_EOF | RBD_ACNTVALID)) {
871 int length = rbd.rbd_status & RBD_ACNT;
872 struct sk_buff *skb;
873
874 length = (length + 1) & ~1;
875 skb = dev_alloc_skb (length + 2);
876
877 if (skb) {
878 skb->dev = dev;
879 skb_reserve (skb, 2);
880
881 ether1_readbuffer (dev, skb_put (skb, length), rbd.rbd_bufl, length);
882
883 skb->protocol = eth_type_trans (skb, dev);
884 netif_rx (skb);
885 priv->stats.rx_packets ++;
886 } else
887 priv->stats.rx_dropped ++;
888 } else {
889 printk(KERN_WARNING "%s: %s\n", dev->name,
890 (rbd.rbd_status & RBD_EOF) ? "oversized packet" : "acnt not valid");
891 priv->stats.rx_dropped ++;
892 }
893
894 nexttail = ether1_inw (dev, priv->rx_tail, rfd_t, rfd_link, NORMALIRQS);
895
896 if (nexttail != priv->rx_head)
897 printk(KERN_ERR "%s: receiver buffer chaining error (%04X != %04X)\n",
898 dev->name, nexttail, priv->rx_head);
899 ether1_outw (dev, RFD_CMDEL | RFD_CMDSUSPEND, nexttail, rfd_t, rfd_command, NORMALIRQS);
900 ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_command, NORMALIRQS);
901 ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_status, NORMALIRQS);
902 ether1_outw (dev, 0, priv->rx_tail, rfd_t, rfd_rbdoffset, NORMALIRQS);
903
904 priv->rx_tail = nexttail;
905 priv->rx_head = ether1_inw (dev, priv->rx_head, rfd_t, rfd_link, NORMALIRQS);
906 } while (1);
907}
908
909static void
910ether1_interrupt (int irq, void *dev_id, struct pt_regs *regs)
911{
912 struct net_device *dev = (struct net_device *)dev_id;
913 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
914 int status;
915
916 status = ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS);
917
918 if (status) {
919 ether1_outw(dev, status & (SCB_STRNR | SCB_STCNA | SCB_STFR | SCB_STCX),
920 SCB_ADDR, scb_t, scb_command, NORMALIRQS);
921 outb (CTRL_CA | CTRL_ACK, REG_CONTROL);
922 if (status & SCB_STCX) {
923 ether1_xmit_done (dev);
924 }
925 if (status & SCB_STCNA) {
926 if (priv->resetting == 0)
927 printk (KERN_WARNING "%s: CU went not ready ???\n", dev->name);
928 else
929 priv->resetting += 1;
930 if (ether1_inw (dev, SCB_ADDR, scb_t, scb_cbl_offset, NORMALIRQS)
931 != (unsigned short)I82586_NULL) {
932 ether1_outw (dev, SCB_CMDCUCSTART, SCB_ADDR, scb_t, scb_command, NORMALIRQS);
933 outb (CTRL_CA, REG_CONTROL);
934 }
935 if (priv->resetting == 2)
936 priv->resetting = 0;
937 }
938 if (status & SCB_STFR) {
939 ether1_recv_done (dev);
940 }
941 if (status & SCB_STRNR) {
942 if (ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS) & SCB_STRXSUSP) {
943 printk (KERN_WARNING "%s: RU went not ready: RU suspended\n", dev->name);
944 ether1_outw (dev, SCB_CMDRXRESUME, SCB_ADDR, scb_t, scb_command, NORMALIRQS);
945 outb (CTRL_CA, REG_CONTROL);
946 priv->stats.rx_dropped ++;
947 } else
948 printk(KERN_WARNING "%s: RU went not ready: %04X\n", dev->name,
949 ether1_inw (dev, SCB_ADDR, scb_t, scb_status, NORMALIRQS));
950 printk (KERN_WARNING "RU ptr = %04X\n", ether1_inw (dev, SCB_ADDR, scb_t, scb_rfa_offset,
951 NORMALIRQS));
952 }
953 } else
954 outb (CTRL_ACK, REG_CONTROL);
955}
956
957static int
958ether1_close (struct net_device *dev)
959{
960 ether1_reset (dev);
961
962 free_irq(dev->irq, dev);
963
964 return 0;
965}
966
967static struct net_device_stats *
968ether1_getstats (struct net_device *dev)
969{
970 struct ether1_priv *priv = (struct ether1_priv *)dev->priv;
971 return &priv->stats;
972}
973
974
975
976
977
978
979
980
981static void
982ether1_setmulticastlist (struct net_device *dev)
983{
984}
985
986
987
988static void __init ether1_banner(void)
989{
990 static unsigned int version_printed = 0;
991
992 if (net_debug && version_printed++ == 0)
993 printk(KERN_INFO "%s", version);
994}
995
996static struct net_device * __init ether1_init_one(struct expansion_card *ec)
997{
998 struct net_device *dev;
999 struct ether1_priv *priv;
1000 int i;
1001
1002 ether1_banner();
1003
1004 ecard_claim(ec);
1005
1006 dev = init_etherdev(NULL, sizeof(struct ether1_priv));
1007 if (!dev)
1008 goto out;
1009
1010 SET_MODULE_OWNER(dev);
1011
1012 dev->base_addr = ecard_address(ec, ECARD_IOC, ECARD_FAST);
1013 dev->irq = ec->irq;
1014
1015
1016
1017
1018 request_region(dev->base_addr, 16, dev->name);
1019 request_region(dev->base_addr + 0x800, 4096, dev->name);
1020
1021 priv = (struct ether1_priv *)dev->priv;
1022 if ((priv->bus_type = ether1_reset(dev)) == 0)
1023 goto release;
1024
1025 printk(KERN_INFO "%s: ether1 in slot %d, ",
1026 dev->name, ec->slot_no);
1027
1028 for (i = 0; i < 6; i++) {
1029 dev->dev_addr[i] = inb(IDPROM_ADDRESS + i);
1030 printk ("%2.2x%c", dev->dev_addr[i], i == 5 ? '\n' : ':');
1031 }
1032
1033 if (ether1_init_2(dev))
1034 goto release;
1035
1036 dev->open = ether1_open;
1037 dev->stop = ether1_close;
1038 dev->hard_start_xmit = ether1_sendpacket;
1039 dev->get_stats = ether1_getstats;
1040 dev->set_multicast_list = ether1_setmulticastlist;
1041 dev->tx_timeout = ether1_timeout;
1042 dev->watchdog_timeo = 5 * HZ / 100;
1043 return 0;
1044
1045release:
1046 release_region(dev->base_addr, 16);
1047 release_region(dev->base_addr + 0x800, 4096);
1048 unregister_netdev(dev);
1049 kfree(dev);
1050out:
1051 ecard_release(ec);
1052 return dev;
1053}
1054
1055static struct expansion_card *e_card[MAX_ECARDS];
1056static struct net_device *e_dev[MAX_ECARDS];
1057
1058static int __init ether1_init(void)
1059{
1060 int i, ret = -ENODEV;
1061
1062 ecard_startfind();
1063
1064 for (i = 0; i < MAX_ECARDS; i++) {
1065 struct expansion_card *ec;
1066 struct net_device *dev;
1067
1068 ec = ecard_find(0, ether1_cids);
1069 if (!ec)
1070 break;
1071
1072 dev = ether1_init_one(ec);
1073 if (!dev)
1074 break;
1075
1076 e_card[i] = ec;
1077 e_dev[i] = dev;
1078 ret = 0;
1079 }
1080
1081 return ret;
1082}
1083
1084static void __exit ether1_exit(void)
1085{
1086 int i;
1087
1088 for (i = 0; i < MAX_ECARDS; i++) {
1089 if (e_dev[i]) {
1090 unregister_netdev(e_dev[i]);
1091 release_region(e_dev[i]->base_addr, 16);
1092 release_region(e_dev[i]->base_addr + 0x800, 4096);
1093 kfree(e_dev[i]);
1094 e_dev[i] = NULL;
1095 }
1096 if (e_card[i]) {
1097 ecard_release(e_card[i]);
1098 e_card[i] = NULL;
1099 }
1100 }
1101}
1102
1103module_init(ether1_init);
1104module_exit(ether1_exit);
1105
1106MODULE_LICENSE("GPL");
1107
