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
35
36
37
38
39
40
41
42
43#include <linux/module.h>
44#include <linux/kernel.h>
45#include <linux/string.h>
46#include <linux/errno.h>
47#include <linux/ioport.h>
48#include <linux/slab.h>
49#include <linux/interrupt.h>
50#include <linux/delay.h>
51#include <linux/netdevice.h>
52#include <linux/etherdevice.h>
53#include <linux/skbuff.h>
54#include <linux/init.h>
55#include <linux/bitops.h>
56
57#include <asm/io.h>
58#include <asm/dma.h>
59#include <asm/pgtable.h>
60#include <asm/cacheflush.h>
61
62static char version[] __initdata =
63 "82596.c $Revision: 1.5 $\n";
64
65#define DRV_NAME "82596"
66
67
68
69
70#define DEB_INIT 0x0001
71#define DEB_PROBE 0x0002
72#define DEB_SERIOUS 0x0004
73#define DEB_ERRORS 0x0008
74#define DEB_MULTI 0x0010
75#define DEB_TDR 0x0020
76#define DEB_OPEN 0x0040
77#define DEB_RESET 0x0080
78#define DEB_ADDCMD 0x0100
79#define DEB_STATUS 0x0200
80#define DEB_STARTTX 0x0400
81#define DEB_RXADDR 0x0800
82#define DEB_TXADDR 0x1000
83#define DEB_RXFRAME 0x2000
84#define DEB_INTS 0x4000
85#define DEB_STRUCT 0x8000
86#define DEB_ANY 0xffff
87
88
89#define DEB(x,y) if (i596_debug & (x)) y
90
91
92#if defined(CONFIG_MVME16x_NET) || defined(CONFIG_MVME16x_NET_MODULE)
93#define ENABLE_MVME16x_NET
94#endif
95#if defined(CONFIG_BVME6000_NET) || defined(CONFIG_BVME6000_NET_MODULE)
96#define ENABLE_BVME6000_NET
97#endif
98#if defined(CONFIG_APRICOT) || defined(CONFIG_APRICOT_MODULE)
99#define ENABLE_APRICOT
100#endif
101
102#ifdef ENABLE_MVME16x_NET
103#include <asm/mvme16xhw.h>
104#endif
105#ifdef ENABLE_BVME6000_NET
106#include <asm/bvme6000hw.h>
107#endif
108
109
110
111
112
113
114#ifdef __mc68000__
115#define WSWAPrfd(x) ((struct i596_rfd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
116#define WSWAPrbd(x) ((struct i596_rbd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
117#define WSWAPiscp(x) ((struct i596_iscp *)(((u32)(x)<<16) | ((((u32)(x)))>>16)))
118#define WSWAPscb(x) ((struct i596_scb *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
119#define WSWAPcmd(x) ((struct i596_cmd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
120#define WSWAPtbd(x) ((struct i596_tbd *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
121#define WSWAPchar(x) ((char *) (((u32)(x)<<16) | ((((u32)(x)))>>16)))
122#define ISCP_BUSY 0x00010000
123#define MACH_IS_APRICOT 0
124#else
125#define WSWAPrfd(x) ((struct i596_rfd *)((long)x))
126#define WSWAPrbd(x) ((struct i596_rbd *)((long)x))
127#define WSWAPiscp(x) ((struct i596_iscp *)((long)x))
128#define WSWAPscb(x) ((struct i596_scb *)((long)x))
129#define WSWAPcmd(x) ((struct i596_cmd *)((long)x))
130#define WSWAPtbd(x) ((struct i596_tbd *)((long)x))
131#define WSWAPchar(x) ((char *)((long)x))
132#define ISCP_BUSY 0x0001
133#define MACH_IS_APRICOT 1
134#endif
135
136
137
138
139
140
141
142#define PORT_RESET 0x00
143#define PORT_SELFTEST 0x01
144#define PORT_ALTSCP 0x02
145#define PORT_ALTDUMP 0x03
146
147static int i596_debug = (DEB_SERIOUS|DEB_PROBE);
148
149MODULE_AUTHOR("Richard Hirst");
150MODULE_DESCRIPTION("i82596 driver");
151MODULE_LICENSE("GPL");
152
153module_param(i596_debug, int, 0);
154MODULE_PARM_DESC(i596_debug, "i82596 debug mask");
155
156
157
158
159
160static int rx_copybreak = 100;
161
162#define PKT_BUF_SZ 1536
163#define MAX_MC_CNT 64
164
165#define I596_TOTAL_SIZE 17
166
167#define I596_NULL ((void *)0xffffffff)
168
169#define CMD_EOL 0x8000
170#define CMD_SUSP 0x4000
171#define CMD_INTR 0x2000
172
173#define CMD_FLEX 0x0008
174
175enum commands {
176 CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
177 CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7
178};
179
180#define STAT_C 0x8000
181#define STAT_B 0x4000
182#define STAT_OK 0x2000
183#define STAT_A 0x1000
184
185#define CUC_START 0x0100
186#define CUC_RESUME 0x0200
187#define CUC_SUSPEND 0x0300
188#define CUC_ABORT 0x0400
189#define RX_START 0x0010
190#define RX_RESUME 0x0020
191#define RX_SUSPEND 0x0030
192#define RX_ABORT 0x0040
193
194#define TX_TIMEOUT 5
195
196
197struct i596_reg {
198 unsigned short porthi;
199 unsigned short portlo;
200 unsigned long ca;
201};
202
203#define EOF 0x8000
204#define SIZE_MASK 0x3fff
205
206struct i596_tbd {
207 unsigned short size;
208 unsigned short pad;
209 struct i596_tbd *next;
210 char *data;
211};
212
213
214
215
216
217
218
219
220
221
222
223struct i596_cmd {
224 struct i596_cmd *v_next;
225 unsigned short status;
226 unsigned short command;
227 struct i596_cmd *b_next;
228};
229
230struct tx_cmd {
231 struct i596_cmd cmd;
232 struct i596_tbd *tbd;
233 unsigned short size;
234 unsigned short pad;
235 struct sk_buff *skb;
236};
237
238struct tdr_cmd {
239 struct i596_cmd cmd;
240 unsigned short status;
241 unsigned short pad;
242};
243
244struct mc_cmd {
245 struct i596_cmd cmd;
246 short mc_cnt;
247 char mc_addrs[MAX_MC_CNT*6];
248};
249
250struct sa_cmd {
251 struct i596_cmd cmd;
252 char eth_addr[8];
253};
254
255struct cf_cmd {
256 struct i596_cmd cmd;
257 char i596_config[16];
258};
259
260struct i596_rfd {
261 unsigned short stat;
262 unsigned short cmd;
263 struct i596_rfd *b_next;
264 struct i596_rbd *rbd;
265 unsigned short count;
266 unsigned short size;
267 struct i596_rfd *v_next;
268 struct i596_rfd *v_prev;
269};
270
271struct i596_rbd {
272 unsigned short count;
273 unsigned short zero1;
274 struct i596_rbd *b_next;
275 unsigned char *b_data;
276 unsigned short size;
277 unsigned short zero2;
278 struct sk_buff *skb;
279 struct i596_rbd *v_next;
280 struct i596_rbd *b_addr;
281 unsigned char *v_data;
282};
283
284#define TX_RING_SIZE 64
285#define RX_RING_SIZE 16
286
287struct i596_scb {
288 unsigned short status;
289 unsigned short command;
290 struct i596_cmd *cmd;
291 struct i596_rfd *rfd;
292 unsigned long crc_err;
293 unsigned long align_err;
294 unsigned long resource_err;
295 unsigned long over_err;
296 unsigned long rcvdt_err;
297 unsigned long short_err;
298 unsigned short t_on;
299 unsigned short t_off;
300};
301
302struct i596_iscp {
303 unsigned long stat;
304 struct i596_scb *scb;
305};
306
307struct i596_scp {
308 unsigned long sysbus;
309 unsigned long pad;
310 struct i596_iscp *iscp;
311};
312
313struct i596_private {
314 volatile struct i596_scp scp;
315 volatile struct i596_iscp iscp;
316 volatile struct i596_scb scb;
317 struct sa_cmd sa_cmd;
318 struct cf_cmd cf_cmd;
319 struct tdr_cmd tdr_cmd;
320 struct mc_cmd mc_cmd;
321 unsigned long stat;
322 int last_restart __attribute__((aligned(4)));
323 struct i596_rfd *rfd_head;
324 struct i596_rbd *rbd_head;
325 struct i596_cmd *cmd_tail;
326 struct i596_cmd *cmd_head;
327 int cmd_backlog;
328 unsigned long last_cmd;
329 struct i596_rfd rfds[RX_RING_SIZE];
330 struct i596_rbd rbds[RX_RING_SIZE];
331 struct tx_cmd tx_cmds[TX_RING_SIZE];
332 struct i596_tbd tbds[TX_RING_SIZE];
333 int next_tx_cmd;
334 spinlock_t lock;
335};
336
337static char init_setup[] =
338{
339 0x8E,
340 0xC8,
341#ifdef CONFIG_VME
342 0xc0,
343#else
344 0x80,
345#endif
346 0x2E,
347 0x00,
348 0x60,
349 0x00,
350 0xf2,
351 0x00,
352 0x00,
353 0x40,
354 0xff,
355 0x00,
356 0x7f };
357
358static int i596_open(struct net_device *dev);
359static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
360static irqreturn_t i596_interrupt(int irq, void *dev_id);
361static int i596_close(struct net_device *dev);
362static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
363static void i596_tx_timeout (struct net_device *dev);
364static void print_eth(unsigned char *buf, char *str);
365static void set_multicast_list(struct net_device *dev);
366
367static int rx_ring_size = RX_RING_SIZE;
368static int ticks_limit = 25;
369static int max_cmd_backlog = TX_RING_SIZE-1;
370
371
372static inline void CA(struct net_device *dev)
373{
374#ifdef ENABLE_MVME16x_NET
375 if (MACH_IS_MVME16x) {
376 ((struct i596_reg *) dev->base_addr)->ca = 1;
377 }
378#endif
379#ifdef ENABLE_BVME6000_NET
380 if (MACH_IS_BVME6000) {
381 volatile u32 i;
382
383 i = *(volatile u32 *) (dev->base_addr);
384 }
385#endif
386#ifdef ENABLE_APRICOT
387 if (MACH_IS_APRICOT) {
388 outw(0, (short) (dev->base_addr) + 4);
389 }
390#endif
391}
392
393
394static inline void MPU_PORT(struct net_device *dev, int c, volatile void *x)
395{
396#ifdef ENABLE_MVME16x_NET
397 if (MACH_IS_MVME16x) {
398 struct i596_reg *p = (struct i596_reg *) (dev->base_addr);
399 p->porthi = ((c) | (u32) (x)) & 0xffff;
400 p->portlo = ((c) | (u32) (x)) >> 16;
401 }
402#endif
403#ifdef ENABLE_BVME6000_NET
404 if (MACH_IS_BVME6000) {
405 u32 v = (u32) (c) | (u32) (x);
406 v = ((u32) (v) << 16) | ((u32) (v) >> 16);
407 *(volatile u32 *) dev->base_addr = v;
408 udelay(1);
409 *(volatile u32 *) dev->base_addr = v;
410 }
411#endif
412}
413
414
415static inline int wait_istat(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
416{
417 while (--delcnt && lp->iscp.stat)
418 udelay(10);
419 if (!delcnt) {
420 printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
421 dev->name, str, lp->scb.status, lp->scb.command);
422 return -1;
423 }
424 else
425 return 0;
426}
427
428
429static inline int wait_cmd(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
430{
431 while (--delcnt && lp->scb.command)
432 udelay(10);
433 if (!delcnt) {
434 printk(KERN_ERR "%s: %s, status %4.4x, cmd %4.4x.\n",
435 dev->name, str, lp->scb.status, lp->scb.command);
436 return -1;
437 }
438 else
439 return 0;
440}
441
442
443static inline int wait_cfg(struct net_device *dev, struct i596_cmd *cmd, int delcnt, char *str)
444{
445 volatile struct i596_cmd *c = cmd;
446
447 while (--delcnt && c->command)
448 udelay(10);
449 if (!delcnt) {
450 printk(KERN_ERR "%s: %s.\n", dev->name, str);
451 return -1;
452 }
453 else
454 return 0;
455}
456
457
458static void i596_display_data(struct net_device *dev)
459{
460 struct i596_private *lp = dev->ml_priv;
461 struct i596_cmd *cmd;
462 struct i596_rfd *rfd;
463 struct i596_rbd *rbd;
464
465 printk(KERN_ERR "lp and scp at %p, .sysbus = %08lx, .iscp = %p\n",
466 &lp->scp, lp->scp.sysbus, lp->scp.iscp);
467 printk(KERN_ERR "iscp at %p, iscp.stat = %08lx, .scb = %p\n",
468 &lp->iscp, lp->iscp.stat, lp->iscp.scb);
469 printk(KERN_ERR "scb at %p, scb.status = %04x, .command = %04x,"
470 " .cmd = %p, .rfd = %p\n",
471 &lp->scb, lp->scb.status, lp->scb.command,
472 lp->scb.cmd, lp->scb.rfd);
473 printk(KERN_ERR " errors: crc %lx, align %lx, resource %lx,"
474 " over %lx, rcvdt %lx, short %lx\n",
475 lp->scb.crc_err, lp->scb.align_err, lp->scb.resource_err,
476 lp->scb.over_err, lp->scb.rcvdt_err, lp->scb.short_err);
477 cmd = lp->cmd_head;
478 while (cmd != I596_NULL) {
479 printk(KERN_ERR "cmd at %p, .status = %04x, .command = %04x, .b_next = %p\n",
480 cmd, cmd->status, cmd->command, cmd->b_next);
481 cmd = cmd->v_next;
482 }
483 rfd = lp->rfd_head;
484 printk(KERN_ERR "rfd_head = %p\n", rfd);
485 do {
486 printk(KERN_ERR " %p .stat %04x, .cmd %04x, b_next %p, rbd %p,"
487 " count %04x\n",
488 rfd, rfd->stat, rfd->cmd, rfd->b_next, rfd->rbd,
489 rfd->count);
490 rfd = rfd->v_next;
491 } while (rfd != lp->rfd_head);
492 rbd = lp->rbd_head;
493 printk(KERN_ERR "rbd_head = %p\n", rbd);
494 do {
495 printk(KERN_ERR " %p .count %04x, b_next %p, b_data %p, size %04x\n",
496 rbd, rbd->count, rbd->b_next, rbd->b_data, rbd->size);
497 rbd = rbd->v_next;
498 } while (rbd != lp->rbd_head);
499}
500
501
502#if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
503static irqreturn_t i596_error(int irq, void *dev_id)
504{
505 struct net_device *dev = dev_id;
506#ifdef ENABLE_MVME16x_NET
507 if (MACH_IS_MVME16x) {
508 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
509
510 pcc2[0x28] = 1;
511 pcc2[0x2b] = 0x1d;
512 }
513#endif
514#ifdef ENABLE_BVME6000_NET
515 if (MACH_IS_BVME6000) {
516 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
517
518 *ethirq = 1;
519 *ethirq = 3;
520 }
521#endif
522 printk(KERN_ERR "%s: Error interrupt\n", dev->name);
523 i596_display_data(dev);
524 return IRQ_HANDLED;
525}
526#endif
527
528static inline void init_rx_bufs(struct net_device *dev)
529{
530 struct i596_private *lp = dev->ml_priv;
531 int i;
532 struct i596_rfd *rfd;
533 struct i596_rbd *rbd;
534
535
536
537 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
538 struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ);
539
540 if (skb == NULL)
541 panic("82596: alloc_skb() failed");
542 skb->dev = dev;
543 rbd->v_next = rbd+1;
544 rbd->b_next = WSWAPrbd(virt_to_bus(rbd+1));
545 rbd->b_addr = WSWAPrbd(virt_to_bus(rbd));
546 rbd->skb = skb;
547 rbd->v_data = skb->data;
548 rbd->b_data = WSWAPchar(virt_to_bus(skb->data));
549 rbd->size = PKT_BUF_SZ;
550#ifdef __mc68000__
551 cache_clear(virt_to_phys(skb->data), PKT_BUF_SZ);
552#endif
553 }
554 lp->rbd_head = lp->rbds;
555 rbd = lp->rbds + rx_ring_size - 1;
556 rbd->v_next = lp->rbds;
557 rbd->b_next = WSWAPrbd(virt_to_bus(lp->rbds));
558
559
560
561 for (i = 0, rfd = lp->rfds; i < rx_ring_size; i++, rfd++) {
562 rfd->rbd = I596_NULL;
563 rfd->v_next = rfd+1;
564 rfd->v_prev = rfd-1;
565 rfd->b_next = WSWAPrfd(virt_to_bus(rfd+1));
566 rfd->cmd = CMD_FLEX;
567 }
568 lp->rfd_head = lp->rfds;
569 lp->scb.rfd = WSWAPrfd(virt_to_bus(lp->rfds));
570 rfd = lp->rfds;
571 rfd->rbd = lp->rbd_head;
572 rfd->v_prev = lp->rfds + rx_ring_size - 1;
573 rfd = lp->rfds + rx_ring_size - 1;
574 rfd->v_next = lp->rfds;
575 rfd->b_next = WSWAPrfd(virt_to_bus(lp->rfds));
576 rfd->cmd = CMD_EOL|CMD_FLEX;
577}
578
579static inline void remove_rx_bufs(struct net_device *dev)
580{
581 struct i596_private *lp = dev->ml_priv;
582 struct i596_rbd *rbd;
583 int i;
584
585 for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
586 if (rbd->skb == NULL)
587 break;
588 dev_kfree_skb(rbd->skb);
589 }
590}
591
592
593static void rebuild_rx_bufs(struct net_device *dev)
594{
595 struct i596_private *lp = dev->ml_priv;
596 int i;
597
598
599
600 for (i = 0; i < rx_ring_size; i++) {
601 lp->rfds[i].rbd = I596_NULL;
602 lp->rfds[i].cmd = CMD_FLEX;
603 }
604 lp->rfds[rx_ring_size-1].cmd = CMD_EOL|CMD_FLEX;
605 lp->rfd_head = lp->rfds;
606 lp->scb.rfd = WSWAPrfd(virt_to_bus(lp->rfds));
607 lp->rbd_head = lp->rbds;
608 lp->rfds[0].rbd = WSWAPrbd(virt_to_bus(lp->rbds));
609}
610
611
612static int init_i596_mem(struct net_device *dev)
613{
614 struct i596_private *lp = dev->ml_priv;
615#if !defined(ENABLE_MVME16x_NET) && !defined(ENABLE_BVME6000_NET) || defined(ENABLE_APRICOT)
616 short ioaddr = dev->base_addr;
617#endif
618 unsigned long flags;
619
620 MPU_PORT(dev, PORT_RESET, NULL);
621
622 udelay(100);
623
624#if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
625#ifdef ENABLE_MVME16x_NET
626 if (MACH_IS_MVME16x) {
627 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
628
629
630 pcc2[0x28] = 1;
631 pcc2[0x2a] = 0x48;
632
633
634
635
636 pcc2[0x2b] = 0x08;
637 }
638#endif
639#ifdef ENABLE_BVME6000_NET
640 if (MACH_IS_BVME6000) {
641 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
642
643 *ethirq = 1;
644 }
645#endif
646
647
648
649 MPU_PORT(dev, PORT_ALTSCP, (void *)virt_to_bus((void *)&lp->scp));
650
651#elif defined(ENABLE_APRICOT)
652
653 {
654 u32 scp = virt_to_bus(&lp->scp);
655
656
657 outw(0, ioaddr);
658 outw(0, ioaddr);
659 outb(4, ioaddr + 0xf);
660 outw(scp | 2, ioaddr);
661 outw(scp >> 16, ioaddr);
662 }
663#endif
664
665 lp->last_cmd = jiffies;
666
667#ifdef ENABLE_MVME16x_NET
668 if (MACH_IS_MVME16x)
669 lp->scp.sysbus = 0x00000054;
670#endif
671#ifdef ENABLE_BVME6000_NET
672 if (MACH_IS_BVME6000)
673 lp->scp.sysbus = 0x0000004c;
674#endif
675#ifdef ENABLE_APRICOT
676 if (MACH_IS_APRICOT)
677 lp->scp.sysbus = 0x00440000;
678#endif
679
680 lp->scp.iscp = WSWAPiscp(virt_to_bus((void *)&lp->iscp));
681 lp->iscp.scb = WSWAPscb(virt_to_bus((void *)&lp->scb));
682 lp->iscp.stat = ISCP_BUSY;
683 lp->cmd_backlog = 0;
684
685 lp->cmd_head = lp->scb.cmd = I596_NULL;
686
687#ifdef ENABLE_BVME6000_NET
688 if (MACH_IS_BVME6000) {
689 lp->scb.t_on = 7 * 25;
690 lp->scb.t_off = 1 * 25;
691 }
692#endif
693
694 DEB(DEB_INIT,printk(KERN_DEBUG "%s: starting i82596.\n", dev->name));
695
696#if defined(ENABLE_APRICOT)
697 (void) inb(ioaddr + 0x10);
698 outb(4, ioaddr + 0xf);
699#endif
700 CA(dev);
701
702 if (wait_istat(dev,lp,1000,"initialization timed out"))
703 goto failed;
704 DEB(DEB_INIT,printk(KERN_DEBUG "%s: i82596 initialization successful\n", dev->name));
705
706
707 rebuild_rx_bufs(dev);
708 lp->scb.command = 0;
709
710#ifdef ENABLE_MVME16x_NET
711 if (MACH_IS_MVME16x) {
712 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
713
714
715 pcc2[0x2a] = 0x55;
716 pcc2[0x2b] = 0x15;
717 }
718#endif
719#ifdef ENABLE_BVME6000_NET
720 if (MACH_IS_BVME6000) {
721 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
722
723 *ethirq = 3;
724 }
725#endif
726
727
728 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdConfigure\n", dev->name));
729 memcpy(lp->cf_cmd.i596_config, init_setup, 14);
730 lp->cf_cmd.cmd.command = CmdConfigure;
731 i596_add_cmd(dev, &lp->cf_cmd.cmd);
732
733 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdSASetup\n", dev->name));
734 memcpy(lp->sa_cmd.eth_addr, dev->dev_addr, 6);
735 lp->sa_cmd.cmd.command = CmdSASetup;
736 i596_add_cmd(dev, &lp->sa_cmd.cmd);
737
738 DEB(DEB_INIT,printk(KERN_DEBUG "%s: queuing CmdTDR\n", dev->name));
739 lp->tdr_cmd.cmd.command = CmdTDR;
740 i596_add_cmd(dev, &lp->tdr_cmd.cmd);
741
742 spin_lock_irqsave (&lp->lock, flags);
743
744 if (wait_cmd(dev,lp,1000,"timed out waiting to issue RX_START")) {
745 spin_unlock_irqrestore (&lp->lock, flags);
746 goto failed;
747 }
748 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Issuing RX_START\n", dev->name));
749 lp->scb.command = RX_START;
750 CA(dev);
751
752 spin_unlock_irqrestore (&lp->lock, flags);
753
754 if (wait_cmd(dev,lp,1000,"RX_START not processed"))
755 goto failed;
756 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Receive unit started OK\n", dev->name));
757 return 0;
758
759failed:
760 printk(KERN_CRIT "%s: Failed to initialise 82596\n", dev->name);
761 MPU_PORT(dev, PORT_RESET, NULL);
762 return -1;
763}
764
765static inline int i596_rx(struct net_device *dev)
766{
767 struct i596_private *lp = dev->ml_priv;
768 struct i596_rfd *rfd;
769 struct i596_rbd *rbd;
770 int frames = 0;
771
772 DEB(DEB_RXFRAME,printk(KERN_DEBUG "i596_rx(), rfd_head %p, rbd_head %p\n",
773 lp->rfd_head, lp->rbd_head));
774
775 rfd = lp->rfd_head;
776
777 while ((rfd->stat) & STAT_C) {
778 if (rfd->rbd == I596_NULL)
779 rbd = I596_NULL;
780 else if (rfd->rbd == lp->rbd_head->b_addr)
781 rbd = lp->rbd_head;
782 else {
783 printk(KERN_CRIT "%s: rbd chain broken!\n", dev->name);
784
785 rbd = I596_NULL;
786 }
787 DEB(DEB_RXFRAME, printk(KERN_DEBUG " rfd %p, rfd.rbd %p, rfd.stat %04x\n",
788 rfd, rfd->rbd, rfd->stat));
789
790 if (rbd != I596_NULL && ((rfd->stat) & STAT_OK)) {
791
792 int pkt_len = rbd->count & 0x3fff;
793 struct sk_buff *skb = rbd->skb;
794 int rx_in_place = 0;
795
796 DEB(DEB_RXADDR,print_eth(rbd->v_data, "received"));
797 frames++;
798
799
800
801
802
803 if (pkt_len > rx_copybreak) {
804 struct sk_buff *newskb;
805
806
807 newskb = dev_alloc_skb(PKT_BUF_SZ);
808 if (newskb == NULL) {
809 skb = NULL;
810 goto memory_squeeze;
811 }
812
813 skb_put(skb, pkt_len);
814 rx_in_place = 1;
815 rbd->skb = newskb;
816 newskb->dev = dev;
817 rbd->v_data = newskb->data;
818 rbd->b_data = WSWAPchar(virt_to_bus(newskb->data));
819#ifdef __mc68000__
820 cache_clear(virt_to_phys(newskb->data), PKT_BUF_SZ);
821#endif
822 }
823 else
824 skb = dev_alloc_skb(pkt_len + 2);
825memory_squeeze:
826 if (skb == NULL) {
827
828 printk(KERN_WARNING "%s: i596_rx Memory squeeze, dropping packet.\n", dev->name);
829 dev->stats.rx_dropped++;
830 }
831 else {
832 if (!rx_in_place) {
833
834 skb_reserve(skb, 2);
835 memcpy(skb_put(skb,pkt_len), rbd->v_data, pkt_len);
836 }
837 skb->protocol=eth_type_trans(skb,dev);
838 skb->len = pkt_len;
839#ifdef __mc68000__
840 cache_clear(virt_to_phys(rbd->skb->data),
841 pkt_len);
842#endif
843 netif_rx(skb);
844 dev->stats.rx_packets++;
845 dev->stats.rx_bytes+=pkt_len;
846 }
847 }
848 else {
849 DEB(DEB_ERRORS, printk(KERN_DEBUG "%s: Error, rfd.stat = 0x%04x\n",
850 dev->name, rfd->stat));
851 dev->stats.rx_errors++;
852 if ((rfd->stat) & 0x0001)
853 dev->stats.collisions++;
854 if ((rfd->stat) & 0x0080)
855 dev->stats.rx_length_errors++;
856 if ((rfd->stat) & 0x0100)
857 dev->stats.rx_over_errors++;
858 if ((rfd->stat) & 0x0200)
859 dev->stats.rx_fifo_errors++;
860 if ((rfd->stat) & 0x0400)
861 dev->stats.rx_frame_errors++;
862 if ((rfd->stat) & 0x0800)
863 dev->stats.rx_crc_errors++;
864 if ((rfd->stat) & 0x1000)
865 dev->stats.rx_length_errors++;
866 }
867
868
869
870 if (rbd != I596_NULL && (rbd->count & 0x4000)) {
871 rbd->count = 0;
872 lp->rbd_head = rbd->v_next;
873 }
874
875
876
877 rfd->rbd = I596_NULL;
878 rfd->stat = 0;
879 rfd->cmd = CMD_EOL|CMD_FLEX;
880 rfd->count = 0;
881
882
883
884 rfd->v_prev->cmd = CMD_FLEX;
885
886
887
888 lp->scb.rfd = rfd->b_next;
889 lp->rfd_head = rfd->v_next;
890 rfd = lp->rfd_head;
891 }
892
893 DEB(DEB_RXFRAME,printk(KERN_DEBUG "frames %d\n", frames));
894
895 return 0;
896}
897
898
899static void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
900{
901 struct i596_cmd *ptr;
902
903 while (lp->cmd_head != I596_NULL) {
904 ptr = lp->cmd_head;
905 lp->cmd_head = ptr->v_next;
906 lp->cmd_backlog--;
907
908 switch ((ptr->command) & 0x7) {
909 case CmdTx:
910 {
911 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
912 struct sk_buff *skb = tx_cmd->skb;
913
914 dev_kfree_skb(skb);
915
916 dev->stats.tx_errors++;
917 dev->stats.tx_aborted_errors++;
918
919 ptr->v_next = ptr->b_next = I596_NULL;
920 tx_cmd->cmd.command = 0;
921 break;
922 }
923 default:
924 ptr->v_next = ptr->b_next = I596_NULL;
925 }
926 }
927
928 wait_cmd(dev,lp,100,"i596_cleanup_cmd timed out");
929 lp->scb.cmd = I596_NULL;
930}
931
932static void i596_reset(struct net_device *dev, struct i596_private *lp,
933 int ioaddr)
934{
935 unsigned long flags;
936
937 DEB(DEB_RESET,printk(KERN_DEBUG "i596_reset\n"));
938
939 spin_lock_irqsave (&lp->lock, flags);
940
941 wait_cmd(dev,lp,100,"i596_reset timed out");
942
943 netif_stop_queue(dev);
944
945 lp->scb.command = CUC_ABORT | RX_ABORT;
946 CA(dev);
947
948
949 wait_cmd(dev,lp,1000,"i596_reset 2 timed out");
950 spin_unlock_irqrestore (&lp->lock, flags);
951
952 i596_cleanup_cmd(dev,lp);
953 i596_rx(dev);
954
955 netif_start_queue(dev);
956 init_i596_mem(dev);
957}
958
959static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
960{
961 struct i596_private *lp = dev->ml_priv;
962 int ioaddr = dev->base_addr;
963 unsigned long flags;
964
965 DEB(DEB_ADDCMD,printk(KERN_DEBUG "i596_add_cmd\n"));
966
967 cmd->status = 0;
968 cmd->command |= (CMD_EOL | CMD_INTR);
969 cmd->v_next = cmd->b_next = I596_NULL;
970
971 spin_lock_irqsave (&lp->lock, flags);
972
973 if (lp->cmd_head != I596_NULL) {
974 lp->cmd_tail->v_next = cmd;
975 lp->cmd_tail->b_next = WSWAPcmd(virt_to_bus(&cmd->status));
976 } else {
977 lp->cmd_head = cmd;
978 wait_cmd(dev,lp,100,"i596_add_cmd timed out");
979 lp->scb.cmd = WSWAPcmd(virt_to_bus(&cmd->status));
980 lp->scb.command = CUC_START;
981 CA(dev);
982 }
983 lp->cmd_tail = cmd;
984 lp->cmd_backlog++;
985
986 spin_unlock_irqrestore (&lp->lock, flags);
987
988 if (lp->cmd_backlog > max_cmd_backlog) {
989 unsigned long tickssofar = jiffies - lp->last_cmd;
990
991 if (tickssofar < ticks_limit)
992 return;
993
994 printk(KERN_NOTICE "%s: command unit timed out, status resetting.\n", dev->name);
995
996 i596_reset(dev, lp, ioaddr);
997 }
998}
999
1000static int i596_open(struct net_device *dev)
1001{
1002 int res = 0;
1003
1004 DEB(DEB_OPEN,printk(KERN_DEBUG "%s: i596_open() irq %d.\n", dev->name, dev->irq));
1005
1006 if (request_irq(dev->irq, i596_interrupt, 0, "i82596", dev)) {
1007 printk(KERN_ERR "%s: IRQ %d not free\n", dev->name, dev->irq);
1008 return -EAGAIN;
1009 }
1010#ifdef ENABLE_MVME16x_NET
1011 if (MACH_IS_MVME16x) {
1012 if (request_irq(0x56, i596_error, 0, "i82596_error", dev))
1013 return -EAGAIN;
1014 }
1015#endif
1016 init_rx_bufs(dev);
1017
1018 netif_start_queue(dev);
1019
1020
1021 if (init_i596_mem(dev)) {
1022 res = -EAGAIN;
1023 free_irq(dev->irq, dev);
1024 }
1025
1026 return res;
1027}
1028
1029static void i596_tx_timeout (struct net_device *dev)
1030{
1031 struct i596_private *lp = dev->ml_priv;
1032 int ioaddr = dev->base_addr;
1033
1034
1035 DEB(DEB_ERRORS,printk(KERN_ERR "%s: transmit timed out, status resetting.\n",
1036 dev->name));
1037
1038 dev->stats.tx_errors++;
1039
1040
1041 if (lp->last_restart == dev->stats.tx_packets) {
1042 DEB(DEB_ERRORS,printk(KERN_ERR "Resetting board.\n"));
1043
1044 i596_reset (dev, lp, ioaddr);
1045 } else {
1046
1047 DEB(DEB_ERRORS,printk(KERN_ERR "Kicking board.\n"));
1048 lp->scb.command = CUC_START | RX_START;
1049 CA (dev);
1050 lp->last_restart = dev->stats.tx_packets;
1051 }
1052
1053 dev->trans_start = jiffies;
1054 netif_wake_queue (dev);
1055}
1056
1057
1058static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
1059{
1060 struct i596_private *lp = dev->ml_priv;
1061 struct tx_cmd *tx_cmd;
1062 struct i596_tbd *tbd;
1063 short length = skb->len;
1064 dev->trans_start = jiffies;
1065
1066 DEB(DEB_STARTTX,printk(KERN_DEBUG "%s: i596_start_xmit(%x,%p) called\n",
1067 dev->name, skb->len, skb->data));
1068
1069 if (skb->len < ETH_ZLEN) {
1070 if (skb_padto(skb, ETH_ZLEN))
1071 return 0;
1072 length = ETH_ZLEN;
1073 }
1074 netif_stop_queue(dev);
1075
1076 tx_cmd = lp->tx_cmds + lp->next_tx_cmd;
1077 tbd = lp->tbds + lp->next_tx_cmd;
1078
1079 if (tx_cmd->cmd.command) {
1080 printk(KERN_NOTICE "%s: xmit ring full, dropping packet.\n",
1081 dev->name);
1082 dev->stats.tx_dropped++;
1083
1084 dev_kfree_skb(skb);
1085 } else {
1086 if (++lp->next_tx_cmd == TX_RING_SIZE)
1087 lp->next_tx_cmd = 0;
1088 tx_cmd->tbd = WSWAPtbd(virt_to_bus(tbd));
1089 tbd->next = I596_NULL;
1090
1091 tx_cmd->cmd.command = CMD_FLEX | CmdTx;
1092 tx_cmd->skb = skb;
1093
1094 tx_cmd->pad = 0;
1095 tx_cmd->size = 0;
1096 tbd->pad = 0;
1097 tbd->size = EOF | length;
1098
1099 tbd->data = WSWAPchar(virt_to_bus(skb->data));
1100
1101#ifdef __mc68000__
1102 cache_push(virt_to_phys(skb->data), length);
1103#endif
1104 DEB(DEB_TXADDR,print_eth(skb->data, "tx-queued"));
1105 i596_add_cmd(dev, &tx_cmd->cmd);
1106
1107 dev->stats.tx_packets++;
1108 dev->stats.tx_bytes += length;
1109 }
1110
1111 netif_start_queue(dev);
1112
1113 return 0;
1114}
1115
1116static void print_eth(unsigned char *add, char *str)
1117{
1118 printk(KERN_DEBUG "i596 0x%p, %pM --> %pM %02X%02X, %s\n",
1119 add, add + 6, add, add[12], add[13], str);
1120}
1121
1122static int io = 0x300;
1123static int irq = 10;
1124
1125static const struct net_device_ops i596_netdev_ops = {
1126 .ndo_open = i596_open,
1127 .ndo_stop = i596_close,
1128 .ndo_start_xmit = i596_start_xmit,
1129 .ndo_set_multicast_list = set_multicast_list,
1130 .ndo_tx_timeout = i596_tx_timeout,
1131 .ndo_change_mtu = eth_change_mtu,
1132 .ndo_set_mac_address = eth_mac_addr,
1133 .ndo_validate_addr = eth_validate_addr,
1134};
1135
1136struct net_device * __init i82596_probe(int unit)
1137{
1138 struct net_device *dev;
1139 int i;
1140 struct i596_private *lp;
1141 char eth_addr[8];
1142 static int probed;
1143 int err;
1144
1145 if (probed)
1146 return ERR_PTR(-ENODEV);
1147 probed++;
1148
1149 dev = alloc_etherdev(0);
1150 if (!dev)
1151 return ERR_PTR(-ENOMEM);
1152
1153 if (unit >= 0) {
1154 sprintf(dev->name, "eth%d", unit);
1155 netdev_boot_setup_check(dev);
1156 } else {
1157 dev->base_addr = io;
1158 dev->irq = irq;
1159 }
1160
1161#ifdef ENABLE_MVME16x_NET
1162 if (MACH_IS_MVME16x) {
1163 if (mvme16x_config & MVME16x_CONFIG_NO_ETHERNET) {
1164 printk(KERN_NOTICE "Ethernet probe disabled - chip not present\n");
1165 err = -ENODEV;
1166 goto out;
1167 }
1168 memcpy(eth_addr, (void *) 0xfffc1f2c, 6);
1169 dev->base_addr = MVME_I596_BASE;
1170 dev->irq = (unsigned) MVME16x_IRQ_I596;
1171 goto found;
1172 }
1173#endif
1174#ifdef ENABLE_BVME6000_NET
1175 if (MACH_IS_BVME6000) {
1176 volatile unsigned char *rtc = (unsigned char *) BVME_RTC_BASE;
1177 unsigned char msr = rtc[3];
1178 int i;
1179
1180 rtc[3] |= 0x80;
1181 for (i = 0; i < 6; i++)
1182 eth_addr[i] = rtc[i * 4 + 7];
1183 rtc[3] = msr;
1184 dev->base_addr = BVME_I596_BASE;
1185 dev->irq = (unsigned) BVME_IRQ_I596;
1186 goto found;
1187 }
1188#endif
1189#ifdef ENABLE_APRICOT
1190 {
1191 int checksum = 0;
1192 int ioaddr = 0x300;
1193
1194
1195
1196
1197 if (!request_region(ioaddr, I596_TOTAL_SIZE, DRV_NAME)) {
1198 printk(KERN_ERR "82596: IO address 0x%04x in use\n", ioaddr);
1199 err = -EBUSY;
1200 goto out;
1201 }
1202
1203 dev->base_addr = ioaddr;
1204
1205 for (i = 0; i < 8; i++) {
1206 eth_addr[i] = inb(ioaddr + 8 + i);
1207 checksum += eth_addr[i];
1208 }
1209
1210
1211
1212
1213
1214
1215
1216 if ((checksum % 0x100) ||
1217 (memcmp(eth_addr, "\x00\x00\x49", 3) != 0)) {
1218 err = -ENODEV;
1219 goto out1;
1220 }
1221
1222 dev->irq = 10;
1223 goto found;
1224 }
1225#endif
1226 err = -ENODEV;
1227 goto out;
1228
1229found:
1230 dev->mem_start = (int)__get_free_pages(GFP_ATOMIC, 0);
1231 if (!dev->mem_start) {
1232 err = -ENOMEM;
1233 goto out1;
1234 }
1235
1236 DEB(DEB_PROBE,printk(KERN_INFO "%s: 82596 at %#3lx,", dev->name, dev->base_addr));
1237
1238 for (i = 0; i < 6; i++)
1239 DEB(DEB_PROBE,printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]));
1240
1241 DEB(DEB_PROBE,printk(" IRQ %d.\n", dev->irq));
1242
1243 DEB(DEB_PROBE,printk(KERN_INFO "%s", version));
1244
1245
1246 dev->netdev_ops = &i596_netdev_ops;
1247 dev->watchdog_timeo = TX_TIMEOUT;
1248
1249 dev->ml_priv = (void *)(dev->mem_start);
1250
1251 lp = dev->ml_priv;
1252 DEB(DEB_INIT,printk(KERN_DEBUG "%s: lp at 0x%08lx (%zd bytes), "
1253 "lp->scb at 0x%08lx\n",
1254 dev->name, (unsigned long)lp,
1255 sizeof(struct i596_private), (unsigned long)&lp->scb));
1256 memset((void *) lp, 0, sizeof(struct i596_private));
1257
1258#ifdef __mc68000__
1259 cache_push(virt_to_phys((void *)(dev->mem_start)), 4096);
1260 cache_clear(virt_to_phys((void *)(dev->mem_start)), 4096);
1261 kernel_set_cachemode((void *)(dev->mem_start), 4096, IOMAP_NOCACHE_SER);
1262#endif
1263 lp->scb.command = 0;
1264 lp->scb.cmd = I596_NULL;
1265 lp->scb.rfd = I596_NULL;
1266 spin_lock_init(&lp->lock);
1267
1268 err = register_netdev(dev);
1269 if (err)
1270 goto out2;
1271 return dev;
1272out2:
1273#ifdef __mc68000__
1274
1275
1276
1277 kernel_set_cachemode((void *)(dev->mem_start), 4096,
1278 IOMAP_FULL_CACHING);
1279#endif
1280 free_page ((u32)(dev->mem_start));
1281out1:
1282#ifdef ENABLE_APRICOT
1283 release_region(dev->base_addr, I596_TOTAL_SIZE);
1284#endif
1285out:
1286 free_netdev(dev);
1287 return ERR_PTR(err);
1288}
1289
1290static irqreturn_t i596_interrupt(int irq, void *dev_id)
1291{
1292 struct net_device *dev = dev_id;
1293 struct i596_private *lp;
1294 short ioaddr;
1295 unsigned short status, ack_cmd = 0;
1296 int handled = 0;
1297
1298#ifdef ENABLE_BVME6000_NET
1299 if (MACH_IS_BVME6000) {
1300 if (*(char *) BVME_LOCAL_IRQ_STAT & BVME_ETHERR) {
1301 i596_error(irq, dev_id);
1302 return IRQ_HANDLED;
1303 }
1304 }
1305#endif
1306 if (dev == NULL) {
1307 printk(KERN_ERR "i596_interrupt(): irq %d for unknown device.\n", irq);
1308 return IRQ_NONE;
1309 }
1310
1311 ioaddr = dev->base_addr;
1312 lp = dev->ml_priv;
1313
1314 spin_lock (&lp->lock);
1315
1316 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1317 status = lp->scb.status;
1318
1319 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1320 dev->name, irq, status));
1321
1322 ack_cmd = status & 0xf000;
1323
1324 if ((status & 0x8000) || (status & 0x2000)) {
1325 struct i596_cmd *ptr;
1326
1327 handled = 1;
1328 if ((status & 0x8000))
1329 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt completed command.\n", dev->name));
1330 if ((status & 0x2000))
1331 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt command unit inactive %x.\n", dev->name, status & 0x0700));
1332
1333 while ((lp->cmd_head != I596_NULL) && (lp->cmd_head->status & STAT_C)) {
1334 ptr = lp->cmd_head;
1335
1336 DEB(DEB_STATUS,printk(KERN_DEBUG "cmd_head->status = %04x, ->command = %04x\n",
1337 lp->cmd_head->status, lp->cmd_head->command));
1338 lp->cmd_head = ptr->v_next;
1339 lp->cmd_backlog--;
1340
1341 switch ((ptr->command) & 0x7) {
1342 case CmdTx:
1343 {
1344 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1345 struct sk_buff *skb = tx_cmd->skb;
1346
1347 if ((ptr->status) & STAT_OK) {
1348 DEB(DEB_TXADDR,print_eth(skb->data, "tx-done"));
1349 } else {
1350 dev->stats.tx_errors++;
1351 if ((ptr->status) & 0x0020)
1352 dev->stats.collisions++;
1353 if (!((ptr->status) & 0x0040))
1354 dev->stats.tx_heartbeat_errors++;
1355 if ((ptr->status) & 0x0400)
1356 dev->stats.tx_carrier_errors++;
1357 if ((ptr->status) & 0x0800)
1358 dev->stats.collisions++;
1359 if ((ptr->status) & 0x1000)
1360 dev->stats.tx_aborted_errors++;
1361 }
1362
1363 dev_kfree_skb_irq(skb);
1364
1365 tx_cmd->cmd.command = 0;
1366 break;
1367 }
1368 case CmdTDR:
1369 {
1370 unsigned short status = ((struct tdr_cmd *)ptr)->status;
1371
1372 if (status & 0x8000) {
1373 DEB(DEB_TDR,printk(KERN_INFO "%s: link ok.\n", dev->name));
1374 } else {
1375 if (status & 0x4000)
1376 printk(KERN_ERR "%s: Transceiver problem.\n", dev->name);
1377 if (status & 0x2000)
1378 printk(KERN_ERR "%s: Termination problem.\n", dev->name);
1379 if (status & 0x1000)
1380 printk(KERN_ERR "%s: Short circuit.\n", dev->name);
1381
1382 DEB(DEB_TDR,printk(KERN_INFO "%s: Time %d.\n", dev->name, status & 0x07ff));
1383 }
1384 break;
1385 }
1386 case CmdConfigure:
1387 case CmdMulticastList:
1388
1389 ptr->command = 0;
1390 break;
1391 }
1392 ptr->v_next = ptr->b_next = I596_NULL;
1393 lp->last_cmd = jiffies;
1394 }
1395
1396 ptr = lp->cmd_head;
1397 while ((ptr != I596_NULL) && (ptr != lp->cmd_tail)) {
1398 ptr->command &= 0x1fff;
1399 ptr = ptr->v_next;
1400 }
1401
1402 if ((lp->cmd_head != I596_NULL))
1403 ack_cmd |= CUC_START;
1404 lp->scb.cmd = WSWAPcmd(virt_to_bus(&lp->cmd_head->status));
1405 }
1406 if ((status & 0x1000) || (status & 0x4000)) {
1407 if ((status & 0x4000))
1408 DEB(DEB_INTS,printk(KERN_DEBUG "%s: i596 interrupt received a frame.\n", dev->name));
1409 i596_rx(dev);
1410
1411 if (status & 0x1000) {
1412 if (netif_running(dev)) {
1413 DEB(DEB_ERRORS,printk(KERN_ERR "%s: i596 interrupt receive unit inactive, status 0x%x\n", dev->name, status));
1414 ack_cmd |= RX_START;
1415 dev->stats.rx_errors++;
1416 dev->stats.rx_fifo_errors++;
1417 rebuild_rx_bufs(dev);
1418 }
1419 }
1420 }
1421 wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1422 lp->scb.command = ack_cmd;
1423
1424#ifdef ENABLE_MVME16x_NET
1425 if (MACH_IS_MVME16x) {
1426
1427
1428 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
1429
1430 pcc2[0x2a] |= 0x08;
1431 }
1432#endif
1433#ifdef ENABLE_BVME6000_NET
1434 if (MACH_IS_BVME6000) {
1435 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
1436
1437 *ethirq = 1;
1438 *ethirq = 3;
1439 }
1440#endif
1441#ifdef ENABLE_APRICOT
1442 (void) inb(ioaddr + 0x10);
1443 outb(4, ioaddr + 0xf);
1444#endif
1445 CA(dev);
1446
1447 DEB(DEB_INTS,printk(KERN_DEBUG "%s: exiting interrupt.\n", dev->name));
1448
1449 spin_unlock (&lp->lock);
1450 return IRQ_RETVAL(handled);
1451}
1452
1453static int i596_close(struct net_device *dev)
1454{
1455 struct i596_private *lp = dev->ml_priv;
1456 unsigned long flags;
1457
1458 netif_stop_queue(dev);
1459
1460 DEB(DEB_INIT,printk(KERN_DEBUG "%s: Shutting down ethercard, status was %4.4x.\n",
1461 dev->name, lp->scb.status));
1462
1463 spin_lock_irqsave(&lp->lock, flags);
1464
1465 wait_cmd(dev,lp,100,"close1 timed out");
1466 lp->scb.command = CUC_ABORT | RX_ABORT;
1467 CA(dev);
1468
1469 wait_cmd(dev,lp,100,"close2 timed out");
1470
1471 spin_unlock_irqrestore(&lp->lock, flags);
1472 DEB(DEB_STRUCT,i596_display_data(dev));
1473 i596_cleanup_cmd(dev,lp);
1474
1475#ifdef ENABLE_MVME16x_NET
1476 if (MACH_IS_MVME16x) {
1477 volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
1478
1479
1480 pcc2[0x28] = 1;
1481 pcc2[0x2a] = 0x40;
1482 pcc2[0x2b] = 0x40;
1483 }
1484#endif
1485#ifdef ENABLE_BVME6000_NET
1486 if (MACH_IS_BVME6000) {
1487 volatile unsigned char *ethirq = (unsigned char *) BVME_ETHIRQ_REG;
1488
1489 *ethirq = 1;
1490 }
1491#endif
1492
1493 free_irq(dev->irq, dev);
1494 remove_rx_bufs(dev);
1495
1496 return 0;
1497}
1498
1499
1500
1501
1502
1503static void set_multicast_list(struct net_device *dev)
1504{
1505 struct i596_private *lp = dev->ml_priv;
1506 int config = 0, cnt;
1507
1508 DEB(DEB_MULTI,printk(KERN_DEBUG "%s: set multicast list, %d entries, promisc %s, allmulti %s\n",
1509 dev->name, dev->mc_count,
1510 dev->flags & IFF_PROMISC ? "ON" : "OFF",
1511 dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1512
1513 if (wait_cfg(dev, &lp->cf_cmd.cmd, 1000, "config change request timed out"))
1514 return;
1515
1516 if ((dev->flags & IFF_PROMISC) && !(lp->cf_cmd.i596_config[8] & 0x01)) {
1517 lp->cf_cmd.i596_config[8] |= 0x01;
1518 config = 1;
1519 }
1520 if (!(dev->flags & IFF_PROMISC) && (lp->cf_cmd.i596_config[8] & 0x01)) {
1521 lp->cf_cmd.i596_config[8] &= ~0x01;
1522 config = 1;
1523 }
1524 if ((dev->flags & IFF_ALLMULTI) && (lp->cf_cmd.i596_config[11] & 0x20)) {
1525 lp->cf_cmd.i596_config[11] &= ~0x20;
1526 config = 1;
1527 }
1528 if (!(dev->flags & IFF_ALLMULTI) && !(lp->cf_cmd.i596_config[11] & 0x20)) {
1529 lp->cf_cmd.i596_config[11] |= 0x20;
1530 config = 1;
1531 }
1532 if (config) {
1533 lp->cf_cmd.cmd.command = CmdConfigure;
1534 i596_add_cmd(dev, &lp->cf_cmd.cmd);
1535 }
1536
1537 cnt = dev->mc_count;
1538 if (cnt > MAX_MC_CNT)
1539 {
1540 cnt = MAX_MC_CNT;
1541 printk(KERN_ERR "%s: Only %d multicast addresses supported",
1542 dev->name, cnt);
1543 }
1544
1545 if (dev->mc_count > 0) {
1546 struct dev_mc_list *dmi;
1547 unsigned char *cp;
1548 struct mc_cmd *cmd;
1549
1550 if (wait_cfg(dev, &lp->mc_cmd.cmd, 1000, "multicast list change request timed out"))
1551 return;
1552 cmd = &lp->mc_cmd;
1553 cmd->cmd.command = CmdMulticastList;
1554 cmd->mc_cnt = dev->mc_count * 6;
1555 cp = cmd->mc_addrs;
1556 for (dmi = dev->mc_list; cnt && dmi != NULL; dmi = dmi->next, cnt--, cp += 6) {
1557 memcpy(cp, dmi->dmi_addr, 6);
1558 if (i596_debug > 1)
1559 DEB(DEB_MULTI,printk(KERN_INFO "%s: Adding address %pM\n",
1560 dev->name, cp));
1561 }
1562 i596_add_cmd(dev, &cmd->cmd);
1563 }
1564}
1565
1566#ifdef MODULE
1567static struct net_device *dev_82596;
1568
1569#ifdef ENABLE_APRICOT
1570module_param(irq, int, 0);
1571MODULE_PARM_DESC(irq, "Apricot IRQ number");
1572#endif
1573
1574static int debug = -1;
1575module_param(debug, int, 0);
1576MODULE_PARM_DESC(debug, "i82596 debug mask");
1577
1578int __init init_module(void)
1579{
1580 if (debug >= 0)
1581 i596_debug = debug;
1582 dev_82596 = i82596_probe(-1);
1583 if (IS_ERR(dev_82596))
1584 return PTR_ERR(dev_82596);
1585 return 0;
1586}
1587
1588void __exit cleanup_module(void)
1589{
1590 unregister_netdev(dev_82596);
1591#ifdef __mc68000__
1592
1593
1594
1595
1596 kernel_set_cachemode((void *)(dev_82596->mem_start), 4096,
1597 IOMAP_FULL_CACHING);
1598#endif
1599 free_page ((u32)(dev_82596->mem_start));
1600#ifdef ENABLE_APRICOT
1601
1602 release_region(dev_82596->base_addr, I596_TOTAL_SIZE);
1603#endif
1604 free_netdev(dev_82596);
1605}
1606
1607#endif
1608
