This source file includes following definitions.
- d_link_read_status
- d_link_read_byte
- d_link_open
- d_link_close
- d_link_start_xmit
- d_link_interrupt
- d_link_tx_intr
- d_link_rx_intr
- d_link_init
- adapter_init
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 static char *version =
54 "d_link.c: $Revision: 0.21 $, Bjorn Ekwall (bj0rn@blox.se)\n";
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 #include <linux/config.h>
81 #include <linux/kernel.h>
82 #include <linux/sched.h>
83 #include <linux/types.h>
84 #include <linux/fcntl.h>
85 #include <linux/string.h>
86 #include <linux/interrupt.h>
87 #include <asm/io.h>
88 #include <netinet/in.h>
89 #include <linux/ptrace.h>
90 #include <asm/system.h>
91 #include <errno.h>
92
93 #include "inet.h"
94 #include "dev.h"
95 #include "eth.h"
96 #include "ip.h"
97 #include "route.h"
98 #include "protocol.h"
99 #include "tcp.h"
100 #include "skbuff.h"
101 #include "sock.h"
102 #include "arp.h"
103
104
105
106 #ifndef D_LINK_DEBUG
107 #define D_LINK_DEBUG 0
108 #endif
109 static unsigned int d_link_debug = D_LINK_DEBUG;
110
111 #ifdef D_LINK_DEBUG
112 #define PRINTK(x) if (d_link_debug >= 2) printk x
113 #else
114 #define PRINTK(x)
115 #endif
116
117
118
119
120
121
122
123
124
125 #define DATA_PORT (dev->base_addr + 0)
126 #define STATUS_PORT (dev->base_addr + 1)
127 #define COMMAND_PORT (dev->base_addr + 2)
128
129
130
131
132 #define SELECT_NIC 0x04
133 #define SELECT_PRN 0x1c
134 #define NML_PRN 0xec
135 #define IRQEN 0x10
136
137
138
139
140 #define TX_INTR 0x88
141 #define RX_INTR 0x40
142
143 #define OTHER_INTR 0x00
144
145
146
147
148
149
150
151 #define WRITE_DATA 0x00
152 #define READ_DATA 0x01
153 #define STATUS 0x02
154 #define COMMAND 0x03
155 #define NULL_COMMAND 0x04
156 #define RX_LEN 0x05
157 #define TX_ADDR 0x06
158 #define RW_ADDR 0x07
159 #define HI_NIBBLE 0x08
160
161
162
163
164
165
166 #define RX_ALL 0x01
167 #define RX_BP 0x02
168 #define RX_MBP 0x03
169
170 #define TX_ENABLE 0x04
171 #define RX_ENABLE 0x08
172
173 #define RESET 0x80
174 #define STOP_RESET 0x00
175
176
177
178
179
180 #define RX_PAGE2_SELECT 0x10
181 #define RX_BASE_PAGE 0x20
182 #define FLIP_IRQ 0x40
183
184
185 #define TX_PAGE2_SELECT 0x02
186
187
188
189
190
191
192
193
194
195
196
197
198 #define MEM_2K 0x0800
199 #define MEM_4K 0x1000
200 #define NODE_ADDRESS 0x2000
201
202 #define RUNT 64
203
204
205
206
207
208
209
210
211 struct netstats {
212 int tx_packets;
213 int rx_packets;
214 int tx_errors;
215 int rx_errors;
216 int missed_packets;
217 int soft_tx_errors;
218 int soft_rx_errors;
219 int soft_trx_err_bits;
220 };
221 static struct netstats *localstats;
222
223
224
225
226
227
228 static int d_link_read_status(struct device *dev);
229 static unsigned char d_link_read_byte(int type, struct device *dev);
230
231
232 static int d_link_open(struct device *dev);
233 static int d_link_close(struct device *dev);
234 static int d_link_start_xmit(struct sk_buff *skb, struct device *dev);
235
236
237 static void d_link_interrupt(int reg_ptr);
238 static void d_link_tx_intr(struct device *dev);
239 static void d_link_rx_intr(struct device *dev);
240
241
242 int d_link_init(struct device *dev);
243 static void adapter_init(struct device *dev, int startp);
244
245
246 static struct sigaction d_link_sigaction = {
247 &d_link_interrupt,
248 0,
249 0,
250 NULL,
251 };
252
253
254
255
256 static volatile int rx_page = 0;
257 static struct device *realdev;
258 #ifdef D_LINK_FIFO
259 static volatile int free_tx_page = 0x03;
260 static volatile unsigned int busy_tx_page = 0x00;
261 static volatile int transmit_next_from;
262 #endif
263
264
265
266
267
268
269
270
271 #define select_prn() \
272 outb_p(SELECT_PRN, COMMAND_PORT)
273
274 #define select_nic() \
275 outb_p(SELECT_NIC, COMMAND_PORT)
276
277 #define d_link_put_byte(data) \
278 outb_p(((data) << 4) | WRITE_DATA , DATA_PORT); \
279 outb_p(((data) & 0xf0) | WRITE_DATA | HI_NIBBLE, DATA_PORT)
280
281
282
283
284
285 #define d_link_put_command(cmd) \
286 outb_p(( rx_page << 4) | COMMAND , DATA_PORT); \
287 outb_p(( rx_page & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT); \
288 outb_p(((rx_page | cmd) << 4) | COMMAND , DATA_PORT); \
289 outb_p(((rx_page | cmd) & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT)
290
291 #define d_link_setup_address(addr,type) \
292 outb_p((((addr) << 4) & 0xf0) | type , DATA_PORT); \
293 outb_p(( (addr) & 0xf0) | type | HI_NIBBLE, DATA_PORT); \
294 outb_p((((addr) >> 4) & 0xf0) | type , DATA_PORT); \
295 outb_p((((addr) >> 8) & 0xf0) | type | HI_NIBBLE, DATA_PORT)
296
297 static int
298 d_link_read_status(struct device *dev)
299 {
300 int status;
301
302 select_nic();
303 outb_p(STATUS, DATA_PORT);
304 SLOW_DOWN_IO;
305 status = inb_p(STATUS_PORT);
306 outb_p(NULL_COMMAND, DATA_PORT);
307 outb_p(NULL_COMMAND | HI_NIBBLE, DATA_PORT);
308
309 return status;
310 }
311
312 static unsigned char
313 d_link_read_byte(int type, struct device *dev) {
314 unsigned char lo;
315
316 outb_p((type), DATA_PORT);
317 SLOW_DOWN_IO;
318 lo = inb_p(STATUS_PORT);
319 outb_p((type) | HI_NIBBLE, DATA_PORT);
320 SLOW_DOWN_IO;
321 return ((lo & 0xf0) >> 4) | (inb_p(STATUS_PORT) & 0xf0);
322 }
323
324 #ifdef D_LINK_FIFO
325
326 # define AT_FIFO_OUTPUT (busy_tx_page & 0x0f)
327 # define ANY_QUEUED_IN_FIFO (busy_tx_page & 0xf0)
328
329 # define PULL_FROM_FIFO { busy_tx_page >>= 4;}
330 # define PUSH_INTO_FIFO(page) { \
331 if (busy_tx_page) \
332 busy_tx_page |= (page << 4); \
333 else \
334 busy_tx_page = page; \
335 }
336 #endif
337
338
339
340
341
342
343
344
345
346 static int
347 d_link_open(struct device *dev)
348 {
349 adapter_init(dev, 1);
350 dev->tbusy = 0;
351 dev->interrupt = 0;
352 dev->start = 1;
353 return 0;
354 }
355
356
357
358
359 static int
360 d_link_close(struct device *dev)
361 {
362 dev->start = 0;
363
364 adapter_init(dev, 0);
365
366 irqaction(dev->irq, NULL);
367
368 return 0;
369 }
370
371
372
373
374
375 static int
376 d_link_start_xmit(struct sk_buff *skb, struct device *dev)
377 {
378 static int tx_page = 0;
379 int transmit_from;
380 int len;
381 int tickssofar;
382 unsigned char *buffer = (unsigned char *)(skb + 1);
383
384
385
386
387
388
389
390 if (skb == NULL) {
391 dev_tint(dev);
392 return 0;
393 }
394
395
396 if (!skb->arp && dev->rebuild_header(skb + 1, dev)) {
397 skb->dev = dev;
398 arp_queue (skb);
399 return 0;
400 }
401
402 #ifdef D_LINK_FIFO
403 if (free_tx_page == 0) {
404 #else
405 if (dev->tbusy) {
406 #endif
407 tickssofar = jiffies - dev->trans_start;
408
409 if (tickssofar < 5) {
410 return 1;
411 }
412
413
414 printk("%s: transmit timed out (%d), %s?\n",
415 dev->name,
416 tickssofar,
417 "network cable problem"
418 );
419
420
421
422
423 }
424
425
426 PRINTK(("d_link_start_xmit:len=%d\n", skb->len));
427 cli();
428 select_nic();
429
430 #ifdef D_LINK_FIFO
431
432 tx_page = free_tx_page & (-free_tx_page);
433
434 free_tx_page &= ~tx_page;
435 dev->tbusy = !free_tx_page;
436
437 PUSH_INTO_FIFO(tx_page);
438 #else
439 tx_page ^= TX_PAGE2_SELECT;
440 #endif
441
442 if ((len = skb->len) < RUNT)
443 len = RUNT;
444
445 if (tx_page & TX_PAGE2_SELECT)
446 transmit_from = MEM_4K - len;
447 else
448 transmit_from = MEM_2K - len;
449
450 d_link_setup_address(transmit_from, RW_ADDR);
451
452 for ( ; len > 0; --len, ++buffer) {
453 d_link_put_byte(*buffer);
454 }
455
456 #ifdef D_LINK_FIFO
457 if (ANY_QUEUED_IN_FIFO == 0) {
458 d_link_setup_address(transmit_from, TX_ADDR);
459 d_link_put_command(TX_ENABLE);
460 dev->trans_start = jiffies;
461 } else {
462 transmit_next_from = transmit_from;
463 }
464 #else
465 d_link_setup_address(transmit_from, TX_ADDR);
466 d_link_put_command(TX_ENABLE);
467 dev->trans_start = jiffies;
468 #endif
469
470 sti();
471
472 if (skb->free) {
473 kfree_skb (skb, FREE_WRITE);
474 }
475
476 return 0;
477 }
478
479
480
481
482
483 static void
484 d_link_interrupt(int reg_ptr)
485 {
486 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
487 struct device *dev = realdev;
488 int interrupts;
489
490
491
492
493
494
495
496
497 if (dev == NULL) {
498 printk ("d_link_interrupt(): irq %d for unknown device.\n", irq);
499 return;
500 }
501
502 if (dev->start == 0) {
503 return;
504 }
505
506 cli();
507 dev->interrupt = 1;
508 sti();
509
510 localstats = (struct netstats*) dev->priv;
511
512 interrupts = d_link_read_status(dev);
513
514 PRINTK(("d_link_interrupt (%2.2X)\n", interrupts));
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531 if (interrupts & TX_INTR) {
532 d_link_tx_intr(dev);
533 }
534
535 if (interrupts & RX_INTR) {
536 d_link_rx_intr(dev);
537 }
538
539
540 if (d_link_debug && (interrupts & OTHER_INTR)) {
541 printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
542 }
543
544
545 if ( (interrupts != 0x47) &&
546 (interrupts != 0x87) &&
547 (interrupts != 0x4F) &&
548 (interrupts != 0x8F)
549 )
550 printk("Strange d_link_interrupt: <%2.2X>\n", interrupts);
551
552 cli();
553 dev->interrupt = 0;
554
555
556 select_prn();
557 return;
558 }
559
560
561
562
563
564 static void
565 d_link_tx_intr(struct device *dev)
566 {
567 localstats->tx_packets++;
568
569 cli();
570 dev->tbusy = 0;
571
572 #ifdef D_LINK_FIFO
573 free_tx_page |= AT_FIFO_OUTPUT;
574 PULL_FROM_FIFO;
575
576 if (AT_FIFO_OUTPUT != 0) {
577 d_link_setup_address(transmit_next_from, TX_ADDR);
578 d_link_put_command(TX_ENABLE);
579 dev->trans_start = jiffies;
580 }
581 #endif
582
583 mark_bh(INET_BH);
584 sti();
585 }
586
587
588
589
590 static void
591 d_link_rx_intr(struct device *dev)
592 {
593 struct sk_buff *skb;
594 int i;
595 int size;
596 int sksize;
597 unsigned char *buffer;
598
599
600
601 size = d_link_read_byte(RX_LEN, dev);
602 size = size + (d_link_read_byte(RX_LEN, dev) << 8) - 4;
603
604
605 rx_page ^= RX_PAGE2_SELECT;
606 d_link_put_command(RX_ENABLE);
607
608 if (size == 0)
609 return;
610
611 if ((size < 32 || size > 1535) && d_link_debug)
612 printk("%s: Bogus packet size %d.\n", dev->name, size);
613
614 sksize = sizeof(struct sk_buff) + size;
615 if ((skb = (struct sk_buff *) kmalloc(sksize, GFP_ATOMIC)) == NULL) {
616 if (d_link_debug) {
617 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
618 dev->name, sksize);
619 }
620 return;
621 }
622
623
624 skb->lock = 0;
625 skb->mem_len = sksize;
626 skb->mem_addr = skb;
627
628 buffer = (unsigned char *)(skb + 1);
629
630
631
632
633 if (rx_page & RX_PAGE2_SELECT) {
634 d_link_setup_address(MEM_4K, RW_ADDR);
635 } else {
636 d_link_setup_address(MEM_4K + MEM_2K, RW_ADDR);
637 }
638
639
640 for (i = size; i > 0; --i) {
641 *buffer++ = d_link_read_byte(READ_DATA, dev);
642 }
643
644 localstats->rx_packets++;
645
646 if(dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev)) {
647 printk("%s: receive buffers full.\n", dev->name);
648 return;
649 }
650
651
652
653
654
655
656 return;
657 }
658
659 int
660 d_link_init(struct device *dev)
661 {
662 int i;
663
664 printk("%s: D-Link pocket adapter", dev->name);
665
666 if (d_link_debug > 1)
667 printk(version);
668
669
670 rx_page = 0;
671 (void)d_link_read_status(dev);
672 d_link_put_command(RESET);
673 d_link_put_command(STOP_RESET);
674 if (d_link_read_status(dev) & 0xf0) {
675 printk(": probe failed at %#3x.\n", dev->base_addr);
676 return ENODEV;
677 }
678
679
680
681
682
683
684
685 d_link_setup_address(NODE_ADDRESS, RW_ADDR);
686 for (i = 0; i < ETH_ALEN; i++) {
687 dev->dev_addr[i] = d_link_read_byte(READ_DATA, dev);
688 dev->broadcast[i] = 0xff;
689 }
690
691
692 if ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) {
693
694 dev->dev_addr[0] = 0x00;
695 dev->dev_addr[1] = 0x80;
696 dev->dev_addr[2] = 0xc8;
697 dev->dev_addr[3] &= 0x0f;
698 dev->dev_addr[3] |= 0x70;
699 } else {
700 printk(", not found in printer port!\n");
701 return ENODEV;
702 }
703
704
705 dev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL);
706 memset(dev->priv, 0, sizeof(struct netstats));
707
708 for (i = 0; i < DEV_NUMBUFFS; i++)
709 dev->buffs[i] = NULL;
710
711 dev->hard_header = eth_header;
712 dev->add_arp = eth_add_arp;
713 dev->queue_xmit = dev_queue_xmit;
714 dev->rebuild_header = eth_rebuild_header;
715 dev->type_trans = eth_type_trans;
716
717 dev->open = &d_link_open;
718 dev->stop = &d_link_close;
719 dev->hard_start_xmit = &d_link_start_xmit;
720
721
722 dev->type = ARPHRD_ETHER;
723 dev->hard_header_len = ETH_HLEN;
724 dev->mtu = 1500;
725 dev->addr_len = ETH_ALEN;
726
727
728 dev->flags = IFF_BROADCAST;
729 dev->family = AF_INET;
730 dev->pa_addr = 0;
731 dev->pa_brdaddr = 0;
732 dev->pa_mask = 0;
733 dev->pa_alen = sizeof(unsigned long);
734
735 if (irqaction (dev->irq, &d_link_sigaction)) {
736 printk (": unable to get IRQ %d\n", dev->irq);
737 return 0;
738 }
739
740 printk(", Ethernet Address: %2.2X", dev->dev_addr[0]);
741 for (i = 1; i < ETH_ALEN; i++)
742 printk(":%2.2X",dev->dev_addr[i]);
743 printk("\n");
744
745 return 0;
746 }
747
748 static void
749 adapter_init(struct device *dev, int startp)
750 {
751 int i;
752
753 cli();
754
755 select_nic();
756 rx_page = 0;
757 d_link_put_command(RESET);
758 d_link_put_command(STOP_RESET);
759
760 if (startp) {
761 irqaction (dev->irq, &d_link_sigaction);
762 realdev = dev;
763 #ifdef D_LINK_FIFO
764 free_tx_page = 0x03;
765 busy_tx_page = 0x00;
766 #endif
767
768 d_link_setup_address(NODE_ADDRESS, RW_ADDR);
769 for (i = 0; i < ETH_ALEN; i++) {
770 d_link_put_byte(dev->dev_addr[i]);
771 }
772
773
774 rx_page = 0 | RX_BP | RX_BASE_PAGE;
775 d_link_setup_address(MEM_4K, RW_ADDR);
776
777 d_link_put_command(RX_ENABLE);
778 }
779 else
780 d_link_put_command(0);
781
782 select_prn();
783
784 sti();
785 }