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