This source file includes following definitions.
- ni52_close
- ni52_open
- check586
- alloc586
- ni52_probe
- ni52_probe1
- init586
- alloc_rfa
- ni52_interrupt
- ni52_rcv_int
- ni52_rnr_int
- ni52_xmt_int
- startrecv586
- ni52_send_packet
- ni52_get_stats
- set_multicast_list
- init_module
- cleanup_module
- ni52_dump
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99 static int debuglevel = 0;
100 static int automatic_resume = 0;
101 static int rfdadd = 0;
102 static int fifo=0x8;
103
104
105
106 #include <linux/module.h>
107 #include <linux/kernel.h>
108 #include <linux/string.h>
109 #include <linux/errno.h>
110 #include <linux/ioport.h>
111 #include <linux/malloc.h>
112 #include <linux/interrupt.h>
113 #include <linux/delay.h>
114 #include <asm/bitops.h>
115 #include <asm/io.h>
116
117 #include <linux/netdevice.h>
118 #include <linux/etherdevice.h>
119 #include <linux/skbuff.h>
120
121 #include "ni52.h"
122
123 #define DEBUG
124 #define SYSBUSVAL 1
125
126 #define ni_attn586() {outb(0,dev->base_addr+NI52_ATTENTION);}
127 #define ni_reset586() {outb(0,dev->base_addr+NI52_RESET);}
128 #define ni_disint() {outb(0,dev->base_addr+NI52_INTDIS);}
129 #define ni_enaint() {outb(0,dev->base_addr+NI52_INTENA);}
130
131 #define make32(ptr16) (p->memtop + (short) (ptr16) )
132 #define make24(ptr32) ((char *) (ptr32) - p->base)
133 #define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop ))
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149 #define RECV_BUFF_SIZE 1524
150 #define XMIT_BUFF_SIZE 1524
151 #define NUM_XMIT_BUFFS 1
152 #define NUM_RECV_BUFFS_8 4
153 #define NUM_RECV_BUFFS_16 9
154 #define NO_NOPCOMMANDS
155
156
157
158
159 #define DELAY(x) __delay((loops_per_sec>>5)*(x));
160 #define DELAY_16(); { __delay( (loops_per_sec>>16)+1 ); }
161 #define DELAY_18(); { __delay( (loops_per_sec>>18)+1 ); }
162
163
164 #define WAIT_4_SCB_CMD() { int i; \
165 for(i=0;i<16384;i++) { \
166 if(!p->scb->cmd_cuc) break; \
167 DELAY_18(); \
168 if(i == 16383) { \
169 printk("%s: scb_cmd timed out: %04x,%04x .. disabeling i82586!!\n",dev->name,p->scb->cmd_cuc,p->scb->cus); \
170 if(!p->reseted) { p->reseted = 1; ni_reset586(); } } } }
171
172 #define WAIT_4_SCB_CMD_RUC() { int i; \
173 for(i=0;i<16384;i++) { \
174 if(!p->scb->cmd_ruc) break; \
175 DELAY_18(); \
176 if(i == 16383) { \
177 printk("%s: scb_cmd (ruc) timed out: %04x,%04x .. disabeling i82586!!\n",dev->name,p->scb->cmd_ruc,p->scb->rus); \
178 if(!p->reseted) { p->reseted = 1; ni_reset586(); } } } }
179
180 #define WAIT_4_STAT_COMPL(addr) { int i; \
181 for(i=0;i<32767;i++) { \
182 if((addr)->cmd_status & STAT_COMPL) break; \
183 DELAY_16(); DELAY_16(); } }
184
185 #define NI52_TOTAL_SIZE 16
186 #define NI52_ADDR0 0x02
187 #define NI52_ADDR1 0x07
188 #define NI52_ADDR2 0x01
189
190 static int ni52_probe1(struct device *dev,int ioaddr);
191 static void ni52_interrupt(int irq,struct pt_regs *reg_ptr);
192 static int ni52_open(struct device *dev);
193 static int ni52_close(struct device *dev);
194 static int ni52_send_packet(struct sk_buff *,struct device *);
195 static struct enet_statistics *ni52_get_stats(struct device *dev);
196 static void set_multicast_list(struct device *dev);
197 #if 0
198 static void ni52_dump(struct device *,void *);
199 #endif
200
201
202 static int init586(struct device *dev);
203 static int check586(struct device *dev,char *where,unsigned size);
204 static void alloc586(struct device *dev);
205 static void startrecv586(struct device *dev);
206 static void *alloc_rfa(struct device *dev,void *ptr);
207 static void ni52_rcv_int(struct device *dev);
208 static void ni52_xmt_int(struct device *dev);
209 static void ni52_rnr_int(struct device *dev);
210
211 struct priv
212 {
213 struct enet_statistics stats;
214 unsigned long base;
215 char *memtop;
216 int lock,reseted;
217 volatile struct rfd_struct *rfd_last,*rfd_top,*rfd_first;
218 volatile struct scp_struct *scp;
219 volatile struct iscp_struct *iscp;
220 volatile struct scb_struct *scb;
221 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS];
222 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS];
223 #if (NUM_XMIT_BUFFS == 1)
224 volatile struct nop_cmd_struct *nop_cmds[2];
225 #else
226 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS];
227 #endif
228 volatile int nop_point,num_recv_buffs;
229 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS];
230 volatile int xmit_count,xmit_last;
231 };
232
233
234
235
236 static int ni52_close(struct device *dev)
237 {
238 free_irq(dev->irq);
239 irq2dev_map[dev->irq] = NULL;
240
241 ni_reset586();
242
243 dev->start = 0;
244 dev->tbusy = 0;
245
246 MOD_DEC_USE_COUNT;
247
248 return 0;
249 }
250
251
252
253
254 static int ni52_open(struct device *dev)
255 {
256 ni_disint();
257 alloc586(dev);
258 init586(dev);
259 startrecv586(dev);
260 ni_enaint();
261
262 if(request_irq(dev->irq, &ni52_interrupt,0,"ni5210"))
263 {
264 ni_reset586();
265 return -EAGAIN;
266 }
267 irq2dev_map[dev->irq] = dev;
268
269 dev->interrupt = 0;
270 dev->tbusy = 0;
271 dev->start = 1;
272
273 MOD_INC_USE_COUNT;
274
275 return 0;
276 }
277
278
279
280
281 static int check586(struct device *dev,char *where,unsigned size)
282 {
283 struct priv pb;
284 struct priv *p = &pb;
285 char *iscp_addrs[2];
286 int i;
287
288 p->base = (unsigned long) where + size - 0x01000000;
289 p->memtop = where + size;
290 p->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
291 memset((char *)p->scp,0, sizeof(struct scp_struct));
292 for(i=0;i<sizeof(struct scp_struct);i++)
293 if(((char *)p->scp)[i])
294 return 0;
295 p->scp->sysbus = SYSBUSVAL;
296 if(p->scp->sysbus != SYSBUSVAL)
297 return 0;
298
299 iscp_addrs[0] = where;
300 iscp_addrs[1]= (char *) p->scp - sizeof(struct iscp_struct);
301
302 for(i=0;i<2;i++)
303 {
304 p->iscp = (struct iscp_struct *) iscp_addrs[i];
305 memset((char *)p->iscp,0, sizeof(struct iscp_struct));
306
307 p->scp->iscp = make24(p->iscp);
308 p->iscp->busy = 1;
309
310 ni_reset586();
311 ni_attn586();
312 DELAY(1);
313
314 if(p->iscp->busy)
315 return 0;
316 }
317 return 1;
318 }
319
320
321
322
323 void alloc586(struct device *dev)
324 {
325 struct priv *p = (struct priv *) dev->priv;
326
327 ni_reset586();
328 DELAY(1);
329
330 p->scp = (struct scp_struct *) (p->base + SCP_DEFAULT_ADDRESS);
331 p->scb = (struct scb_struct *) (dev->mem_start);
332 p->iscp = (struct iscp_struct *) ((char *)p->scp - sizeof(struct iscp_struct));
333
334 memset((char *) p->iscp,0,sizeof(struct iscp_struct));
335 memset((char *) p->scp ,0,sizeof(struct scp_struct));
336
337 p->scp->iscp = make24(p->iscp);
338 p->scp->sysbus = SYSBUSVAL;
339 p->iscp->scb_offset = make16(p->scb);
340
341 p->iscp->busy = 1;
342 ni_reset586();
343 ni_attn586();
344
345 DELAY(1);
346
347 if(p->iscp->busy)
348 printk("%s: Init-Problems (alloc).\n",dev->name);
349
350 p->reseted = 0;
351
352 memset((char *)p->scb,0,sizeof(struct scb_struct));
353 }
354
355
356
357
358 int ni52_probe(struct device *dev)
359 {
360 #ifndef MODULE
361 int *port;
362 static int ports[] = {0x300, 0x280, 0x360 , 0x320 , 0x340, 0};
363 #endif
364 int base_addr = dev->base_addr;
365
366 if (base_addr > 0x1ff)
367 if( (inb(base_addr+NI52_MAGIC1) == NI52_MAGICVAL1) &&
368 (inb(base_addr+NI52_MAGIC2) == NI52_MAGICVAL2))
369 return ni52_probe1(dev, base_addr);
370 else if (base_addr > 0)
371 return ENXIO;
372
373 #ifdef MODULE
374 printk("%s: no autoprobing allowed for modules.\n",dev->name);
375 #else
376 for (port = ports; *port; port++) {
377 int ioaddr = *port;
378 if (check_region(ioaddr, NI52_TOTAL_SIZE))
379 continue;
380 if( !(inb(ioaddr+NI52_MAGIC1) == NI52_MAGICVAL1) ||
381 !(inb(ioaddr+NI52_MAGIC2) == NI52_MAGICVAL2))
382 continue;
383
384 dev->base_addr = ioaddr;
385 if (ni52_probe1(dev, ioaddr) == 0)
386 return 0;
387 }
388
389 #ifdef FULL_IO_PROBE
390 for(dev->base_addr=0x200;dev->base_addr<0x400;dev->base_addr+=8)
391 {
392 int ioaddr = dev->base_addr;
393 if (check_region(ioaddr, NI52_TOTAL_SIZE))
394 continue;
395 if( !(inb(ioaddr+NI52_MAGIC1) == NI52_MAGICVAL1) ||
396 !(inb(ioaddr+NI52_MAGIC2) == NI52_MAGICVAL2))
397 continue;
398 if (ni52_probe1(dev, ioaddr) == 0)
399 return 0;
400 }
401 #endif
402
403 #endif
404
405 dev->base_addr = base_addr;
406 return ENODEV;
407 }
408
409 static int ni52_probe1(struct device *dev,int ioaddr)
410 {
411 int i,size;
412
413 for(i=0;i<ETH_ALEN;i++)
414 dev->dev_addr[i] = inb(dev->base_addr+i);
415
416 if(dev->dev_addr[0] != NI52_ADDR0 || dev->dev_addr[1] != NI52_ADDR1
417 || dev->dev_addr[2] != NI52_ADDR2)
418 return ENODEV;
419
420 printk("%s: NI5210 found at %#3lx, ",dev->name,dev->base_addr);
421
422 request_region(ioaddr,NI52_TOTAL_SIZE,"ni5210");
423
424
425
426
427 #ifdef MODULE
428 size = dev->mem_end - dev->mem_start;
429 if(size != 0x2000 && size != 0x4000)
430 {
431 printk("\n%s: Illegal memory size %d. Allowed is 0x2000 or 0x4000 bytes.\n",dev->name,size);
432 return ENODEV;
433 }
434 if(!check586(dev,(char *) dev->mem_start,size))
435 {
436 printk("?memcheck, Can't find memory at 0x%lx with size %d!\n",dev->mem_start,size);
437 return ENODEV;
438 }
439 #else
440 if(dev->mem_start != 0)
441 {
442 size = 0x4000;
443 if(!check586(dev,(char *) dev->mem_start,size)) {
444 size = 0x2000;
445 if(!check586(dev,(char *) dev->mem_start,size)) {
446 printk("?memprobe, Can't find memory at 0x%lx!\n",dev->mem_start);
447 return ENODEV;
448 }
449 }
450 }
451 else
452 {
453 static long memaddrs[] = { 0xc8000,0xca000,0xcc000,0xce000,0xd0000,0xd2000,
454 0xd4000,0xd6000,0xd8000,0xda000,0xdc000, 0 };
455 for(i=0;;i++)
456 {
457 if(!memaddrs[i]) {
458 printk("?memprobe, Can't find io-memory!\n");
459 return ENODEV;
460 }
461 dev->mem_start = memaddrs[i];
462 size = 0x2000;
463 if(check586(dev,(char *)dev->mem_start,size))
464 break;
465 size = 0x4000;
466 if(check586(dev,(char *)dev->mem_start,size))
467 break;
468 }
469 }
470 dev->mem_end = dev->mem_start + size;
471 #endif
472
473 dev->priv = (void *) kmalloc(sizeof(struct priv),GFP_KERNEL);
474 if(dev->priv == NULL)
475 {
476 printk("%s: Ooops .. can't allocate private driver memory.\n",dev->name);
477 return -ENOMEM;
478 }
479
480 memset((char *) dev->priv,0,sizeof(struct priv));
481
482 ((struct priv *) (dev->priv))->memtop = (char *) dev->mem_start + size;
483 ((struct priv *) (dev->priv))->base = dev->mem_start + size - 0x01000000;
484 alloc586(dev);
485
486
487 if(size == 0x2000)
488 ((struct priv *) dev->priv)->num_recv_buffs = NUM_RECV_BUFFS_8;
489 else
490 ((struct priv *) dev->priv)->num_recv_buffs = NUM_RECV_BUFFS_16;
491
492 printk("Memaddr: 0x%lx, Memsize: %d, ",dev->mem_start,size);
493
494 if(dev->irq < 2)
495 {
496 autoirq_setup(0);
497 ni_reset586();
498 ni_attn586();
499 if(!(dev->irq = autoirq_report(2)))
500 {
501 printk("?autoirq, Failed to detect IRQ line!\n");
502 return 1;
503 }
504 printk("IRQ %d (autodetected).\n",dev->irq);
505 }
506 else {
507 if(dev->irq == 2)
508 dev->irq = 9;
509 printk("IRQ %d (assigned and not checked!).\n",dev->irq);
510 }
511
512 dev->open = &ni52_open;
513 dev->stop = &ni52_close;
514 dev->get_stats = &ni52_get_stats;
515 dev->hard_start_xmit = &ni52_send_packet;
516 dev->set_multicast_list = &set_multicast_list;
517
518 dev->if_port = 0;
519
520 ether_setup(dev);
521
522 dev->tbusy = 0;
523 dev->interrupt = 0;
524 dev->start = 0;
525
526 return 0;
527 }
528
529
530
531
532
533
534 static int init586(struct device *dev)
535 {
536 void *ptr;
537 int i,result=0;
538 struct priv *p = (struct priv *) dev->priv;
539 volatile struct configure_cmd_struct *cfg_cmd;
540 volatile struct iasetup_cmd_struct *ias_cmd;
541 volatile struct tdr_cmd_struct *tdr_cmd;
542 volatile struct mcsetup_cmd_struct *mc_cmd;
543 struct dev_mc_list *dmi=dev->mc_list;
544 int num_addrs=dev->mc_count;
545
546 ptr = (void *) ((char *)p->scb + sizeof(struct scb_struct));
547
548 cfg_cmd = (struct configure_cmd_struct *)ptr;
549 cfg_cmd->cmd_status = 0;
550 cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST;
551 cfg_cmd->cmd_link = 0xffff;
552
553 cfg_cmd->byte_cnt = 0x0a;
554 cfg_cmd->fifo = fifo;
555 cfg_cmd->sav_bf = 0x40;
556 cfg_cmd->adr_len = 0x2e;
557 cfg_cmd->priority = 0x00;
558 cfg_cmd->ifs = 0x60;
559 cfg_cmd->time_low = 0x00;
560 cfg_cmd->time_high = 0xf2;
561 cfg_cmd->promisc = 0;
562 if(dev->flags & IFF_ALLMULTI) {
563 int len = ((char *) p->iscp - (char *) ptr - 8) / 6;
564 if(num_addrs > len) {
565 printk("%s: switching to promisc. mode\n",dev->name);
566 dev->flags|=IFF_PROMISC;
567 }
568 }
569 if(dev->flags&IFF_PROMISC)
570 {
571 cfg_cmd->promisc=1;
572 dev->flags|=IFF_PROMISC;
573 }
574 cfg_cmd->carr_coll = 0x00;
575
576 p->scb->cbl_offset = make16(cfg_cmd);
577 p->scb->cmd_ruc = 0;
578
579 p->scb->cmd_cuc = CUC_START;
580 ni_attn586();
581
582 WAIT_4_STAT_COMPL(cfg_cmd);
583
584 if((cfg_cmd->cmd_status & (STAT_OK|STAT_COMPL)) != (STAT_COMPL|STAT_OK))
585 {
586 printk("%s: configure command failed: %x\n",dev->name,cfg_cmd->cmd_status);
587 return 1;
588 }
589
590
591
592
593 ias_cmd = (struct iasetup_cmd_struct *)ptr;
594
595 ias_cmd->cmd_status = 0;
596 ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST;
597 ias_cmd->cmd_link = 0xffff;
598
599 memcpy((char *)&ias_cmd->iaddr,(char *) dev->dev_addr,ETH_ALEN);
600
601 p->scb->cbl_offset = make16(ias_cmd);
602
603 p->scb->cmd_cuc = CUC_START;
604 ni_attn586();
605
606 WAIT_4_STAT_COMPL(ias_cmd);
607
608 if((ias_cmd->cmd_status & (STAT_OK|STAT_COMPL)) != (STAT_OK|STAT_COMPL)) {
609 printk("%s (ni52): individual address setup command failed: %04x\n",dev->name,ias_cmd->cmd_status);
610 return 1;
611 }
612
613
614
615
616 tdr_cmd = (struct tdr_cmd_struct *)ptr;
617
618 tdr_cmd->cmd_status = 0;
619 tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST;
620 tdr_cmd->cmd_link = 0xffff;
621 tdr_cmd->status = 0;
622
623 p->scb->cbl_offset = make16(tdr_cmd);
624 p->scb->cmd_cuc = CUC_START;
625 ni_attn586();
626
627 WAIT_4_STAT_COMPL(tdr_cmd);
628
629 if(!(tdr_cmd->cmd_status & STAT_COMPL))
630 {
631 printk("%s: Problems while running the TDR.\n",dev->name);
632 }
633 else
634 {
635 DELAY_16();
636 result = tdr_cmd->status;
637
638 p->scb->cmd_cuc = p->scb->cus & STAT_MASK;
639 ni_attn586();
640
641 if(result & TDR_LNK_OK)
642 ;
643 else if(result & TDR_XCVR_PRB)
644 printk("%s: TDR: Transceiver problem. Check the cable(s)!\n",dev->name);
645 else if(result & TDR_ET_OPN)
646 printk("%s: TDR: No correct termination %d clocks away.\n",dev->name,result & TDR_TIMEMASK);
647 else if(result & TDR_ET_SRT)
648 {
649 if (result & TDR_TIMEMASK)
650 printk("%s: TDR: Detected a short circuit %d clocks away.\n",dev->name,result & TDR_TIMEMASK);
651 }
652 else
653 printk("%s: TDR: Unknown status %04x\n",dev->name,result);
654 }
655
656
657
658
659 if(num_addrs && !(dev->flags & IFF_PROMISC) )
660 {
661 mc_cmd = (struct mcsetup_cmd_struct *) ptr;
662 mc_cmd->cmd_status = 0;
663 mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST;
664 mc_cmd->cmd_link = 0xffff;
665 mc_cmd->mc_cnt = num_addrs * 6;
666
667 for(i=0;i<num_addrs;i++,dmi=dmi->next)
668 memcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr,6);
669
670 p->scb->cbl_offset = make16(mc_cmd);
671 p->scb->cmd_cuc = CUC_START;
672 ni_attn586();
673
674 WAIT_4_STAT_COMPL(mc_cmd);
675
676 if( (mc_cmd->cmd_status & (STAT_COMPL|STAT_OK)) != (STAT_COMPL|STAT_OK) )
677 printk("%s: Can't apply multicast-address-list.\n",dev->name);
678 }
679
680
681
682
683 #if (NUM_XMIT_BUFFS == 1)
684 for(i=0;i<2;i++)
685 {
686 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
687 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
688 p->nop_cmds[i]->cmd_status = 0;
689 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
690 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
691 }
692 #else
693 for(i=0;i<NUM_XMIT_BUFFS;i++)
694 {
695 p->nop_cmds[i] = (struct nop_cmd_struct *)ptr;
696 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
697 p->nop_cmds[i]->cmd_status = 0;
698 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
699 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
700 }
701 #endif
702
703 ptr = alloc_rfa(dev,(void *)ptr);
704
705
706
707
708 for(i=0;i<NUM_XMIT_BUFFS;i++)
709 {
710 p->xmit_cmds[i] = (struct transmit_cmd_struct *)ptr;
711 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
712 p->xmit_cbuffs[i] = (char *)ptr;
713 ptr = (char *) ptr + XMIT_BUFF_SIZE;
714 p->xmit_buffs[i] = (struct tbd_struct *)ptr;
715 ptr = (char *) ptr + sizeof(struct tbd_struct);
716 if((void *)ptr > (void *)p->iscp)
717 {
718 printk("%s: not enough shared-mem for your configuration!\n",dev->name);
719 return 1;
720 }
721 memset((char *)(p->xmit_cmds[i]) ,0, sizeof(struct transmit_cmd_struct));
722 memset((char *)(p->xmit_buffs[i]),0, sizeof(struct tbd_struct));
723 p->xmit_cmds[i]->cmd_link = make16(p->nop_cmds[(i+1)%NUM_XMIT_BUFFS]);
724 p->xmit_cmds[i]->cmd_status = STAT_COMPL;
725 p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT;
726 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
727 p->xmit_buffs[i]->next = 0xffff;
728 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
729 }
730
731 p->xmit_count = 0;
732 p->xmit_last = 0;
733 #ifndef NO_NOPCOMMANDS
734 p->nop_point = 0;
735 #endif
736
737
738
739
740 #ifndef NO_NOPCOMMANDS
741 p->scb->cbl_offset = make16(p->nop_cmds[0]);
742 p->scb->cmd_cuc = CUC_START;
743 ni_attn586();
744 WAIT_4_SCB_CMD();
745 #else
746 p->xmit_cmds[0]->cmd_link = make16(p->xmit_cmds[0]);
747 p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_SUSPEND | CMD_INT;
748 #endif
749
750
751
752
753 p->scb->cmd_cuc = p->scb->cus & STAT_MASK;
754 ni_attn586();
755 DELAY_16();
756
757 ni_enaint();
758
759 return 0;
760 }
761
762
763
764
765
766
767 static void *alloc_rfa(struct device *dev,void *ptr)
768 {
769 volatile struct rfd_struct *rfd = (struct rfd_struct *)ptr;
770 volatile struct rbd_struct *rbd;
771 int i;
772 struct priv *p = (struct priv *) dev->priv;
773
774 memset((char *) rfd,0,sizeof(struct rfd_struct)*(p->num_recv_buffs+rfdadd));
775 p->rfd_first = rfd;
776
777 for(i = 0; i < (p->num_recv_buffs+rfdadd); i++) {
778 rfd[i].next = make16(rfd + (i+1) % (p->num_recv_buffs+rfdadd) );
779 rfd[i].rbd_offset = 0xffff;
780 }
781 rfd[p->num_recv_buffs-1+rfdadd].last = RFD_SUSP;
782
783 ptr = (void *) (rfd + (p->num_recv_buffs + rfdadd) );
784
785 rbd = (struct rbd_struct *) ptr;
786 ptr = (void *) (rbd + p->num_recv_buffs);
787
788
789 memset((char *) rbd,0,sizeof(struct rbd_struct)*(p->num_recv_buffs));
790
791 for(i=0;i<p->num_recv_buffs;i++)
792 {
793 rbd[i].next = make16((rbd + (i+1) % p->num_recv_buffs));
794 rbd[i].size = RECV_BUFF_SIZE;
795 rbd[i].buffer = make24(ptr);
796 ptr = (char *) ptr + RECV_BUFF_SIZE;
797 }
798
799 p->rfd_top = p->rfd_first;
800 p->rfd_last = p->rfd_first + (p->num_recv_buffs - 1 + rfdadd);
801
802 p->scb->rfa_offset = make16(p->rfd_first);
803 p->rfd_first->rbd_offset = make16(rbd);
804
805 return ptr;
806 }
807
808
809
810
811
812
813 static void ni52_interrupt(int irq,struct pt_regs *reg_ptr)
814 {
815 struct device *dev = (struct device *) irq2dev_map[irq];
816 unsigned short stat;
817 int cnt=0;
818 struct priv *p;
819
820 if (!dev) {
821 printk ("ni5210-interrupt: irq %d for unknown device.\n",irq);
822 return;
823 }
824 p = (struct priv *) dev->priv;
825
826 if(debuglevel > 1)
827 printk("I");
828
829 dev->interrupt = 1;
830
831 WAIT_4_SCB_CMD();
832
833 while((stat=p->scb->cus & STAT_MASK))
834 {
835 p->scb->cmd_cuc = stat;
836 ni_attn586();
837
838 if(stat & STAT_FR)
839 ni52_rcv_int(dev);
840
841 if(stat & STAT_RNR)
842 {
843 printk("(R)");
844 if(p->scb->rus & RU_SUSPEND)
845 {
846 WAIT_4_SCB_CMD();
847 p->scb->cmd_ruc = RUC_RESUME;
848 ni_attn586();
849 WAIT_4_SCB_CMD_RUC();
850 }
851 else
852 {
853 printk("%s: Receiver-Unit went 'NOT READY': %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->rus);
854 ni52_rnr_int(dev);
855 }
856 }
857
858 if(stat & STAT_CX)
859 ni52_xmt_int(dev);
860
861 #ifndef NO_NOPCOMMANDS
862 if(stat & STAT_CNA)
863 {
864 if(dev->start)
865 printk("%s: oops! CU has left active state. stat: %04x/%02x.\n",dev->name,(int) stat,(int) p->scb->cus);
866 }
867 #endif
868
869 if(debuglevel > 1)
870 printk("%d",cnt++);
871
872 WAIT_4_SCB_CMD();
873 if(p->scb->cmd_cuc)
874 {
875 printk("%s: Acknowledge timed out.\n",dev->name);
876 ni_disint();
877 break;
878 }
879 }
880
881 if(debuglevel > 1)
882 printk("i");
883
884 dev->interrupt = 0;
885 }
886
887
888
889
890
891 static void ni52_rcv_int(struct device *dev)
892 {
893 int status,cnt=0;
894 unsigned short totlen;
895 struct sk_buff *skb;
896 struct rbd_struct *rbd;
897 struct priv *p = (struct priv *) dev->priv;
898
899 if(debuglevel > 0)
900 printk("R");
901
902 for(;(status = p->rfd_top->stat_high) & RFD_COMPL;)
903 {
904 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset);
905
906 if(status & RFD_OK)
907 {
908 if( (totlen = rbd->status) & RBD_LAST)
909 {
910 totlen &= RBD_MASK;
911 rbd->status = 0;
912 skb = (struct sk_buff *) dev_alloc_skb(totlen+2);
913 if(skb != NULL)
914 {
915 skb->dev = dev;
916 skb_reserve(skb,2);
917 skb_put(skb,totlen);
918 eth_copy_and_sum(skb,(char *) p->base+(unsigned long) rbd->buffer,totlen,0);
919 skb->protocol=eth_type_trans(skb,dev);
920 netif_rx(skb);
921 p->stats.rx_packets++;
922 }
923 else
924 p->stats.rx_dropped++;
925 }
926 else
927 {
928 int rstat;
929
930 totlen = 0;
931 while(!((rstat=rbd->status) & RBD_LAST))
932 {
933 totlen += rstat & RBD_MASK;
934 if(!rstat)
935 {
936 printk("%s: Whoops .. no end mark in RBD list\n",dev->name);
937 break;
938 }
939 rbd->status = 0;
940 rbd = (struct rbd_struct *) make32(rbd->next);
941 }
942 totlen += rstat & RBD_MASK;
943 rbd->status = 0;
944 printk("%s: received oversized frame! length: %d\n",dev->name,totlen);
945 p->stats.rx_dropped++;
946 }
947 }
948 else
949 {
950 printk("%s: oops! rfd-error-status: %04x\n",dev->name,status);
951 p->stats.rx_errors++;
952 }
953 p->rfd_top->stat_high = 0;
954 p->rfd_top->last = RFD_SUSP;
955 p->rfd_top->rbd_offset = 0xffff;
956 p->rfd_last->last = 0;
957 p->rfd_last = p->rfd_top;
958 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next);
959 p->scb->rfa_offset = make16(p->rfd_top);
960
961 if(debuglevel > 0)
962 printk("%d",cnt++);
963 }
964
965 if(automatic_resume)
966 {
967 WAIT_4_SCB_CMD();
968 p->scb->cmd_ruc = RUC_RESUME;
969 ni_attn586();
970 WAIT_4_SCB_CMD_RUC();
971 }
972
973 #ifdef WAIT_4_BUSY
974 {
975 int i;
976 for(i=0;i<1024;i++)
977 {
978 if(p->rfd_top->status)
979 break;
980 DELAY_16();
981 if(i == 1023)
982 printk("%s: RU hasn't fetched next RFD (not busy/complete)\n",dev->name);
983 }
984 }
985 #endif
986
987 #ifdef 0
988 if(!at_least_one)
989 {
990 int i;
991 volatile struct rfd_struct *rfds=p->rfd_top;
992 volatile struct rbd_struct *rbds;
993 printk("%s: received a FC intr. without having a frame: %04x %d\n",dev->name,status,old_at_least);
994 for(i=0;i< (p->num_recv_buffs+4);i++)
995 {
996 rbds = (struct rbd_struct *) make32(rfds->rbd_offset);
997 printk("%04x:%04x ",rfds->status,rbds->status);
998 rfds = (struct rfd_struct *) make32(rfds->next);
999 }
1000 printk("\nerrs: %04x %04x stat: %04x\n",(int)p->scb->rsc_errs,(int)p->scb->ovrn_errs,(int)p->scb->status);
1001 printk("\nerrs: %04x %04x rus: %02x, cus: %02x\n",(int)p->scb->rsc_errs,(int)p->scb->ovrn_errs,(int)p->scb->rus,(int)p->scb->cus);
1002 }
1003 old_at_least = at_least_one;
1004 #endif
1005
1006 if(debuglevel > 0)
1007 printk("r");
1008 }
1009
1010
1011
1012
1013
1014 static void ni52_rnr_int(struct device *dev)
1015 {
1016 struct priv *p = (struct priv *) dev->priv;
1017
1018 p->stats.rx_errors++;
1019
1020 WAIT_4_SCB_CMD();
1021 p->scb->cmd_ruc = RUC_ABORT;
1022 ni_attn586();
1023 WAIT_4_SCB_CMD_RUC();
1024
1025 alloc_rfa(dev,(char *)p->rfd_first);
1026
1027 startrecv586(dev);
1028
1029 printk("%s: Receive-Unit restarted. Status: %04x\n",dev->name,p->scb->rus);
1030
1031 }
1032
1033
1034
1035
1036
1037 static void ni52_xmt_int(struct device *dev)
1038 {
1039 int status;
1040 struct priv *p = (struct priv *) dev->priv;
1041
1042 if(debuglevel > 0)
1043 printk("X");
1044
1045 status = p->xmit_cmds[p->xmit_last]->cmd_status;
1046 if(!(status & STAT_COMPL))
1047 printk("%s: strange .. xmit-int without a 'COMPLETE'\n",dev->name);
1048
1049 if(status & STAT_OK)
1050 {
1051 p->stats.tx_packets++;
1052 p->stats.collisions += (status & TCMD_MAXCOLLMASK);
1053 }
1054 else
1055 {
1056 p->stats.tx_errors++;
1057 if(status & TCMD_LATECOLL) {
1058 printk("%s: late collision detected.\n",dev->name);
1059 p->stats.collisions++;
1060 }
1061 else if(status & TCMD_NOCARRIER) {
1062 p->stats.tx_carrier_errors++;
1063 printk("%s: no carrier detected.\n",dev->name);
1064 }
1065 else if(status & TCMD_LOSTCTS)
1066 printk("%s: loss of CTS detected.\n",dev->name);
1067 else if(status & TCMD_UNDERRUN) {
1068 p->stats.tx_fifo_errors++;
1069 printk("%s: DMA underrun detected.\n",dev->name);
1070 }
1071 else if(status & TCMD_MAXCOLL) {
1072 printk("%s: Max. collisions exceeded.\n",dev->name);
1073 p->stats.collisions += 16;
1074 }
1075 }
1076
1077 #if (NUM_XMIT_BUFFS > 1)
1078 if( (++p->xmit_last) == NUM_XMIT_BUFFS)
1079 p->xmit_last = 0;
1080 #endif
1081
1082 dev->tbusy = 0;
1083 mark_bh(NET_BH);
1084 }
1085
1086
1087
1088
1089
1090 static void startrecv586(struct device *dev)
1091 {
1092 struct priv *p = (struct priv *) dev->priv;
1093
1094 WAIT_4_SCB_CMD();
1095 WAIT_4_SCB_CMD_RUC();
1096 p->scb->rfa_offset = make16(p->rfd_first);
1097 p->scb->cmd_ruc = RUC_START;
1098 ni_attn586();
1099 WAIT_4_SCB_CMD_RUC();
1100 }
1101
1102
1103
1104
1105
1106 static int ni52_send_packet(struct sk_buff *skb, struct device *dev)
1107 {
1108 int len,i;
1109 #ifndef NO_NOPCOMMANDS
1110 int next_nop;
1111 #endif
1112 struct priv *p = (struct priv *) dev->priv;
1113
1114 if(dev->tbusy)
1115 {
1116 int tickssofar = jiffies - dev->trans_start;
1117 if (tickssofar < 5)
1118 return 1;
1119
1120 #ifndef NO_NOPCOMMANDS
1121 if(p->scb->cus & CU_ACTIVE)
1122 {
1123 dev->tbusy = 0;
1124 #ifdef DEBUG
1125 printk("%s: strange ... timeout with CU active?!?\n",dev->name);
1126 printk("%s: X0: %04x N0: %04x N1: %04x %d\n",dev->name,(int)p->xmit_cmds[0]->cmd_status,(int)p->nop_cmds[0]->cmd_status,(int)p->nop_cmds[1]->cmd_status,(int)p->nop_point);
1127 #endif
1128 p->scb->cmd_cuc = CUC_ABORT;
1129 ni_attn586();
1130 WAIT_4_SCB_CMD();
1131 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]);
1132 p->scb->cmd_cuc = CUC_START;
1133 ni_attn586();
1134 WAIT_4_SCB_CMD();
1135 dev->trans_start = jiffies;
1136 return 0;
1137 }
1138 else
1139 #endif
1140 {
1141 #ifdef DEBUG
1142 printk("%s: xmitter timed out, try to restart! stat: %02x\n",dev->name,p->scb->cus);
1143 printk("%s: command-stats: %04x %04x\n",dev->name,p->xmit_cmds[0]->cmd_status,p->xmit_cmds[1]->cmd_status);
1144 printk("%s: check, whether you set the right interrupt number!\n",dev->name);
1145 #endif
1146 ni52_close(dev);
1147 ni52_open(dev);
1148 }
1149 dev->trans_start = jiffies;
1150 return 0;
1151 }
1152
1153 if(skb == NULL)
1154 {
1155 dev_tint(dev);
1156 return 0;
1157 }
1158
1159 if (skb->len <= 0)
1160 return 0;
1161 if(skb->len > XMIT_BUFF_SIZE)
1162 {
1163 printk("%s: Sorry, max. framelength is %d bytes. The length of your frame is %ld bytes.\n",dev->name,XMIT_BUFF_SIZE,skb->len);
1164 return 0;
1165 }
1166
1167 if (set_bit(0, (void*)&dev->tbusy)) {
1168 printk("%s: Transmitter access conflict.\n", dev->name);
1169 return 1;
1170 }
1171 #if(NUM_XMIT_BUFFS > 1)
1172 else if(set_bit(0,(void *) &p->lock)) {
1173 printk("%s: Queue was locked\n",dev->name);
1174 return 1;
1175 }
1176 #endif
1177 else
1178 {
1179 memcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
1180 len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
1181
1182 #if (NUM_XMIT_BUFFS == 1)
1183 # ifdef NO_NOPCOMMANDS
1184
1185 #ifdef DEBUG
1186 if(p->scb->cus & CU_ACTIVE)
1187 {
1188 printk("%s: Hmmm .. CU is still running and we wanna send a new packet.\n",dev->name);
1189 printk("%s: stat: %04x %04x\n",dev->name,p->scb->cus,p->xmit_cmds[0]->cmd_status);
1190 }
1191 #endif
1192
1193 p->xmit_buffs[0]->size = TBD_LAST | len;
1194 for(i=0;i<16;i++)
1195 {
1196 p->xmit_cmds[0]->cmd_status = 0;
1197 WAIT_4_SCB_CMD();
1198 if( (p->scb->cus & CU_STATUS) == CU_SUSPEND)
1199 p->scb->cmd_cuc = CUC_RESUME;
1200 else
1201 {
1202 p->scb->cbl_offset = make16(p->xmit_cmds[0]);
1203 p->scb->cmd_cuc = CUC_START;
1204 }
1205
1206 ni_attn586();
1207 dev->trans_start = jiffies;
1208 if(!i)
1209 dev_kfree_skb(skb,FREE_WRITE);
1210 WAIT_4_SCB_CMD();
1211 if( (p->scb->cus & CU_ACTIVE))
1212 break;
1213 if(p->xmit_cmds[0]->cmd_status)
1214 break;
1215 if(i==15)
1216 printk("%s: Can't start transmit-command.\n",dev->name);
1217 }
1218 # else
1219 next_nop = (p->nop_point + 1) & 0x1;
1220 p->xmit_buffs[0]->size = TBD_LAST | len;
1221
1222 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link
1223 = make16((p->nop_cmds[next_nop]));
1224 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0;
1225
1226 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0]));
1227 dev->trans_start = jiffies;
1228 p->nop_point = next_nop;
1229 dev_kfree_skb(skb,FREE_WRITE);
1230 # endif
1231 #else
1232 p->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
1233 if( (next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS )
1234 next_nop = 0;
1235
1236 p->xmit_cmds[p->xmit_count]->cmd_status = 0;
1237
1238 p->nop_cmds[next_nop]->cmd_link = make16((p->nop_cmds[next_nop]));
1239 p->nop_cmds[next_nop]->cmd_status = 0;
1240
1241 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count]));
1242 dev->trans_start = jiffies;
1243 p->xmit_count = next_nop;
1244
1245 {
1246 long flags;
1247 save_flags(flags);
1248 cli();
1249 if(p->xmit_count != p->xmit_last)
1250 dev->tbusy = 0;
1251 p->lock = 0;
1252 restore_flags(flags);
1253 }
1254 dev_kfree_skb(skb,FREE_WRITE);
1255 #endif
1256 }
1257 return 0;
1258 }
1259
1260
1261
1262
1263
1264 static struct enet_statistics *ni52_get_stats(struct device *dev)
1265 {
1266 struct priv *p = (struct priv *) dev->priv;
1267 unsigned short crc,aln,rsc,ovrn;
1268
1269 crc = p->scb->crc_errs;
1270 p->scb->crc_errs = 0;
1271 aln = p->scb->aln_errs;
1272 p->scb->aln_errs = 0;
1273 rsc = p->scb->rsc_errs;
1274 p->scb->rsc_errs = 0;
1275 ovrn = p->scb->ovrn_errs;
1276 p->scb->ovrn_errs = 0;
1277
1278 p->stats.rx_crc_errors += crc;
1279 p->stats.rx_fifo_errors += ovrn;
1280 p->stats.rx_frame_errors += aln;
1281 p->stats.rx_dropped += rsc;
1282
1283 return &p->stats;
1284 }
1285
1286
1287
1288
1289 static void set_multicast_list(struct device *dev)
1290 {
1291 if(!dev->start)
1292 {
1293 printk("%s: Can't apply promiscuous/multicastmode to a not running interface.\n",dev->name);
1294 return;
1295 }
1296
1297 dev->start = 0;
1298
1299 ni_disint();
1300 alloc586(dev);
1301 init586(dev);
1302 startrecv586(dev);
1303 ni_enaint();
1304
1305 dev->start = 1;
1306 }
1307
1308 #ifdef MODULE
1309 static struct device dev_ni52 = {
1310 " ",
1311 0, 0, 0, 0,
1312 0x300, 9,
1313 0, 0, 0, NULL, ni52_probe };
1314
1315
1316 int irq=9;
1317 int io=0x300;
1318 long memstart=0;
1319 long memend=0;
1320
1321 int init_module(void)
1322 {
1323 if(io <= 0x0 || !memend || !memstart || irq < 2) {
1324 printk("ni52: Autoprobing not allowed for modules.\nni52: Set symbols 'io' 'irq' 'memstart' and 'memend'\n");
1325 return -ENODEV;
1326 }
1327 dev_ni52.irq = irq;
1328 dev_ni52.base_addr = io;
1329 dev_ni52.mem_end = memend;
1330 dev_ni52.mem_start = memstart;
1331 if (register_netdev(&dev_ni52) != 0)
1332 return -EIO;
1333 return 0;
1334 }
1335
1336 void cleanup_module(void)
1337 {
1338 release_region(dev_ni52.base_addr, NI52_TOTAL_SIZE);
1339 kfree(dev_ni52.priv);
1340 dev_ni52.priv = NULL;
1341 unregister_netdev(&dev_ni52);
1342 }
1343 #endif
1344
1345 #if 0
1346
1347
1348
1349 void ni52_dump(struct device *dev,void *ptr)
1350 {
1351 struct priv *p = (struct priv *) dev->priv;
1352 struct dump_cmd_struct *dump_cmd = (struct dump_cmd_struct *) ptr;
1353 int i;
1354
1355 p->scb->cmd_cuc = CUC_ABORT;
1356 ni_attn586();
1357 WAIT_4_SCB_CMD();
1358 WAIT_4_SCB_CMD_RUC();
1359
1360 dump_cmd->cmd_status = 0;
1361 dump_cmd->cmd_cmd = CMD_DUMP | CMD_LAST;
1362 dump_cmd->dump_offset = make16((dump_cmd + 1));
1363 dump_cmd->cmd_link = 0xffff;
1364
1365 p->scb->cbl_offset = make16(dump_cmd);
1366 p->scb->cmd_cuc = CUC_START;
1367 ni_attn586();
1368 WAIT_4_STAT_COMPL(dump_cmd);
1369
1370 if( (dump_cmd->cmd_status & (STAT_COMPL|STAT_OK)) != (STAT_COMPL|STAT_OK) )
1371 printk("%s: Can't get dump information.\n",dev->name);
1372
1373 for(i=0;i<170;i++) {
1374 printk("%02x ",(int) ((unsigned char *) (dump_cmd + 1))[i]);
1375 if(i % 24 == 23)
1376 printk("\n");
1377 }
1378 printk("\n");
1379 }
1380 #endif
1381
1382
1383
1384
1385
1386