![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to de600.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to de600.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: static const char *version =
2: "de600.c: $Revision: 1.1 $, Bjorn Ekwall ([email protected])\n";
3: /*
4: * de600.c
5: *
6: * Linux driver for the D-Link DE-600 Ethernet pocket adapter.
7: *
8: * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall
9: * The Author may be reached as [email protected]
10: *
11: * Based on adapter information gathered from DE600.ASM by D-Link Inc.,
12: * as included on disk C in the v.2.11 of PC/TCP from FTP Software.
13: * For DE600.asm:
14: * Portions (C) Copyright 1990 D-Link, Inc.
15: * Copyright, 1988-1992, Russell Nelson, Crynwr Software
16: *
17: * Adapted to the sample network driver core for linux,
18: * written by: Donald Becker <[email protected]>
19: * C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
20: *
21: * compile-command:
22: * "gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer \
23: * -m486 -c de600.c
24: *
25: **************************************************************/
26: /*
27: * This program is free software; you can redistribute it and/or modify
28: * it under the terms of the GNU General Public License as published by
29: * the Free Software Foundation; either version 2, or (at your option)
30: * any later version.
31: *
32: * This program is distributed in the hope that it will be useful,
33: * but WITHOUT ANY WARRANTY; without even the implied warranty of
34: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
35: * GNU General Public License for more details.
36: *
37: * You should have received a copy of the GNU General Public License
38: * along with this program; if not, write to the Free Software
39: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
40: *
41: **************************************************************/
42: /* Add another "; SLOW_DOWN_IO" here if your adapter won't work OK: */
43: #define DE600_SLOW_DOWN SLOW_DOWN_IO; SLOW_DOWN_IO; SLOW_DOWN_IO
44:
45: /*
46: * If you still have trouble reading/writing to the adapter,
47: * modify the following "#define": (see <asm/io.h> for more info)
48: #define REALLY_SLOW_IO
49: */
50: #define SLOW_IO_BY_JUMPING /* Looks "better" than dummy write to port 0x80 :-) */
51:
52: /*
53: * If you want to enable automatic continuous checking for the DE600,
54: * keep this #define enabled.
55: * It doesn't cost much per packet, so I think it is worth it!
56: * If you disagree, comment away the #define, and live with it...
57: *
58: */
59: #define CHECK_LOST_DE600
60:
61: /*
62: * Enable this #define if you want the adapter to do a "ifconfig down" on
63: * itself when we have detected that something is possibly wrong with it.
64: * The default behaviour is to retry with "adapter_init()" until success.
65: * This should be used for debugging purposes only.
66: * (Depends on the CHECK_LOST_DE600 above)
67: *
68: */
69: #define SHUTDOWN_WHEN_LOST
70:
71: /*
72: * See comment at "de600_rspace()"!
73: * This is an *ugly* hack, but for now it achieves its goal of
74: * faking a TCP flow-control that will not flood the poor DE600.
75: *
76: * Tricks TCP to announce a small max window (max 2 fast packets please :-)
77: *
78: * Comment away at your own risk!
79: *
80: * Update: Use the more general per-device maxwindow parameter instead.
81: */
82: #undef FAKE_SMALL_MAX
83:
84: /* use 0 for production, 1 for verification, >2 for debug */
85: #ifdef DE600_DEBUG
86: #define PRINTK(x) if (de600_debug >= 2) printk x
87: #else
88: #define DE600_DEBUG 0
89: #define PRINTK(x) /**/
90: #endif
91: unsigned int de600_debug = DE600_DEBUG;
92:
93: #include <linux/module.h>
94:
95: #include <linux/kernel.h>
96: #include <linux/sched.h>
97: #include <linux/types.h>
98: #include <linux/fcntl.h>
99: #include <linux/string.h>
100: #include <linux/interrupt.h>
101: #include <linux/ioport.h>
102: #include <asm/io.h>
103: #include <linux/in.h>
104: #include <linux/ptrace.h>
105: #include <asm/system.h>
106: #include <linux/errno.h>
107:
108: #include <linux/inet.h>
109: #include <linux/netdevice.h>
110: #include <linux/etherdevice.h>
111: #include <linux/skbuff.h>
112:
113: #ifdef FAKE_SMALL_MAX
114: static unsigned long de600_rspace(struct sock *sk);
115: #include <net/sock.h>
116: #endif
117:
118: #define netstats enet_statistics
119: typedef unsigned char byte;
120:
121: /**************************************************
122: * *
123: * Definition of D-Link Ethernet Pocket adapter *
124: * *
125: **************************************************/
126: /*
127: * D-Link Ethernet pocket adapter ports
128: */
129: /*
130: * OK, so I'm cheating, but there are an awful lot of
131: * reads and writes in order to get anything in and out
132: * of the DE-600 with 4 bits at a time in the parallel port,
133: * so every saved instruction really helps :-)
134: *
135: * That is, I don't care what the device struct says
136: * but hope that Space.c will keep the rest of the drivers happy.
137: */
138: #ifndef DE600_IO
139: #define DE600_IO 0x378
140: #endif
141:
142: #define DATA_PORT (DE600_IO)
143: #define STATUS_PORT (DE600_IO + 1)
144: #define COMMAND_PORT (DE600_IO + 2)
145:
146: #ifndef DE600_IRQ
147: #define DE600_IRQ 7
148: #endif
149: /*
150: * It really should look like this, and autoprobing as well...
151: *
152: #define DATA_PORT (dev->base_addr + 0)
153: #define STATUS_PORT (dev->base_addr + 1)
154: #define COMMAND_PORT (dev->base_addr + 2)
155: #define DE600_IRQ dev->irq
156: */
157:
158: /*
159: * D-Link COMMAND_PORT commands
160: */
161: #define SELECT_NIC 0x04 /* select Network Interface Card */
162: #define SELECT_PRN 0x1c /* select Printer */
163: #define NML_PRN 0xec /* normal Printer situation */
164: #define IRQEN 0x10 /* enable IRQ line */
165:
166: /*
167: * D-Link STATUS_PORT
168: */
169: #define RX_BUSY 0x80
170: #define RX_GOOD 0x40
171: #define TX_FAILED16 0x10
172: #define TX_BUSY 0x08
173:
174: /*
175: * D-Link DATA_PORT commands
176: * command in low 4 bits
177: * data in high 4 bits
178: * select current data nibble with HI_NIBBLE bit
179: */
180: #define WRITE_DATA 0x00 /* write memory */
181: #define READ_DATA 0x01 /* read memory */
182: #define STATUS 0x02 /* read status register */
183: #define COMMAND 0x03 /* write command register (see COMMAND below) */
184: #define NULL_COMMAND 0x04 /* null command */
185: #define RX_LEN 0x05 /* read received packet length */
186: #define TX_ADDR 0x06 /* set adapter transmit memory address */
187: #define RW_ADDR 0x07 /* set adapter read/write memory address */
188: #define HI_NIBBLE 0x08 /* read/write the high nibble of data,
189: or-ed with rest of command */
190:
191: /*
192: * command register, accessed through DATA_PORT with low bits = COMMAND
193: */
194: #define RX_ALL 0x01 /* PROMISCUOUS */
195: #define RX_BP 0x02 /* default: BROADCAST & PHYSICAL ADDRESS */
196: #define RX_MBP 0x03 /* MULTICAST, BROADCAST & PHYSICAL ADDRESS */
197:
198: #define TX_ENABLE 0x04 /* bit 2 */
199: #define RX_ENABLE 0x08 /* bit 3 */
200:
201: #define RESET 0x80 /* set bit 7 high */
202: #define STOP_RESET 0x00 /* set bit 7 low */
203:
204: /*
205: * data to command register
206: * (high 4 bits in write to DATA_PORT)
207: */
208: #define RX_PAGE2_SELECT 0x10 /* bit 4, only 2 pages to select */
209: #define RX_BASE_PAGE 0x20 /* bit 5, always set when specifying RX_ADDR */
210: #define FLIP_IRQ 0x40 /* bit 6 */
211:
212: /*
213: * D-Link adapter internal memory:
214: *
215: * 0-2K 1:st transmit page (send from pointer up to 2K)
216: * 2-4K 2:nd transmit page (send from pointer up to 4K)
217: *
218: * 4-6K 1:st receive page (data from 4K upwards)
219: * 6-8K 2:nd receive page (data from 6K upwards)
220: *
221: * 8K+ Adapter ROM (contains magic code and last 3 bytes of Ethernet address)
222: */
223: #define MEM_2K 0x0800 /* 2048 */
224: #define MEM_4K 0x1000 /* 4096 */
225: #define MEM_6K 0x1800 /* 6144 */
226: #define NODE_ADDRESS 0x2000 /* 8192 */
227:
228: #define RUNT 60 /* Too small Ethernet packet */
229:
230: /**************************************************
231: * *
232: * End of definition *
233: * *
234: **************************************************/
235:
236: /*
237: * Index to functions, as function prototypes.
238: */
239: /* Routines used internally. (See "convenience macros") */
240: static byte de600_read_status(struct device *dev);
241: static byte de600_read_byte(unsigned char type, struct device *dev);
242:
243: /* Put in the device structure. */
244: static int de600_open(struct device *dev);
245: static int de600_close(struct device *dev);
246: static struct netstats *get_stats(struct device *dev);
247: static int de600_start_xmit(struct sk_buff *skb, struct device *dev);
248:
249: /* Dispatch from interrupts. */
250: static void de600_interrupt(int irq, void *dev_id, struct pt_regs *regs);
251: static int de600_tx_intr(struct device *dev, int irq_status);
252: static void de600_rx_intr(struct device *dev);
253:
254: /* Initialization */
255: static void trigger_interrupt(struct device *dev);
256: int de600_probe(struct device *dev);
257: static int adapter_init(struct device *dev);
258:
259: /*
260: * D-Link driver variables:
261: */
262: static volatile int rx_page = 0;
263:
264: #define TX_PAGES 2
265: static volatile int tx_fifo[TX_PAGES];
266: static volatile int tx_fifo_in = 0;
267: static volatile int tx_fifo_out = 0;
268: static volatile int free_tx_pages = TX_PAGES;
269: static int was_down = 0;
270:
271: /*
272: * Convenience macros/functions for D-Link adapter
273: */
274:
275: #define select_prn() outb_p(SELECT_PRN, COMMAND_PORT); DE600_SLOW_DOWN
276: #define select_nic() outb_p(SELECT_NIC, COMMAND_PORT); DE600_SLOW_DOWN
277:
278: /* Thanks for hints from Mark Burton <[email protected]> */
279: #define de600_put_byte(data) ( \
280: outb_p(((data) << 4) | WRITE_DATA , DATA_PORT), \
281: outb_p(((data) & 0xf0) | WRITE_DATA | HI_NIBBLE, DATA_PORT))
282:
283: /*
284: * The first two outb_p()'s below could perhaps be deleted if there
285: * would be more delay in the last two. Not certain about it yet...
286: */
287: #define de600_put_command(cmd) ( \
288: outb_p(( rx_page << 4) | COMMAND , DATA_PORT), \
289: outb_p(( rx_page & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT), \
290: outb_p(((rx_page | cmd) << 4) | COMMAND , DATA_PORT), \
291: outb_p(((rx_page | cmd) & 0xf0) | COMMAND | HI_NIBBLE, DATA_PORT))
292:
293: #define de600_setup_address(addr,type) ( \
294: outb_p((((addr) << 4) & 0xf0) | type , DATA_PORT), \
295: outb_p(( (addr) & 0xf0) | type | HI_NIBBLE, DATA_PORT), \
296: outb_p((((addr) >> 4) & 0xf0) | type , DATA_PORT), \
297: outb_p((((addr) >> 8) & 0xf0) | type | HI_NIBBLE, DATA_PORT))
298:
299: #define rx_page_adr() ((rx_page & RX_PAGE2_SELECT)?(MEM_6K):(MEM_4K))
300:
301: /* Flip bit, only 2 pages */
302: #define next_rx_page() (rx_page ^= RX_PAGE2_SELECT)
303:
304: #define tx_page_adr(a) (((a) + 1) * MEM_2K)
305:
306: static inline byte
307: de600_read_status(struct device *dev)
308: {
309: byte status;
310:
311: outb_p(STATUS, DATA_PORT);
312: status = inb(STATUS_PORT);
313: outb_p(NULL_COMMAND | HI_NIBBLE, DATA_PORT);
314:
315: return status;
316: }
317:
318: static inline byte
319: de600_read_byte(unsigned char type, struct device *dev) { /* dev used by macros */
320: byte lo;
321:
322: (void)outb_p((type), DATA_PORT);
323: lo = ((unsigned char)inb(STATUS_PORT)) >> 4;
324: (void)outb_p((type) | HI_NIBBLE, DATA_PORT);
325: return ((unsigned char)inb(STATUS_PORT) & (unsigned char)0xf0) | lo;
326: }
327:
328: /*
329: * Open/initialize the board. This is called (in the current kernel)
330: * after booting when 'ifconfig <dev->name> $IP_ADDR' is run (in rc.inet1).
331: *
332: * This routine should set everything up anew at each open, even
333: * registers that "should" only need to be set once at boot, so that
334: * there is a non-reboot way to recover if something goes wrong.
335: */
336: static int
337: de600_open(struct device *dev)
338: {
339: if (request_irq(DE600_IRQ, de600_interrupt, 0, "de600", NULL)) {
340: printk ("%s: unable to get IRQ %d\n", dev->name, DE600_IRQ);
341: return 1;
342: }
343: irq2dev_map[DE600_IRQ] = dev;
344:
345: MOD_INC_USE_COUNT;
346: dev->start = 1;
347: if (adapter_init(dev)) {
348: return 1;
349: }
350:
351: return 0;
352: }
353:
354: /*
355: * The inverse routine to de600_open().
356: */
357: static int
358: de600_close(struct device *dev)
359: {
360: select_nic();
361: rx_page = 0;
362: de600_put_command(RESET);
363: de600_put_command(STOP_RESET);
364: de600_put_command(0);
365: select_prn();
366:
367: if (dev->start) {
368: free_irq(DE600_IRQ, NULL);
369: irq2dev_map[DE600_IRQ] = NULL;
370: dev->start = 0;
371: MOD_DEC_USE_COUNT;
372: }
373: return 0;
374: }
375:
376: static struct netstats *
377: get_stats(struct device *dev)
378: {
379: return (struct netstats *)(dev->priv);
380: }
381:
382: static inline void
383: trigger_interrupt(struct device *dev)
384: {
385: de600_put_command(FLIP_IRQ);
386: select_prn();
387: DE600_SLOW_DOWN;
388: select_nic();
389: de600_put_command(0);
390: }
391:
392: /*
393: * Copy a buffer to the adapter transmit page memory.
394: * Start sending.
395: */
396: static int
397: de600_start_xmit(struct sk_buff *skb, struct device *dev)
398: {
399: int transmit_from;
400: int len;
401: int tickssofar;
402: byte *buffer = skb->data;
403:
404: /*
405: * If some higher layer thinks we've missed a
406: * tx-done interrupt we are passed NULL.
407: * Caution: dev_tint() handles the cli()/sti() itself.
408: */
409:
410: if (skb == NULL) {
411: dev_tint(dev);
412: return 0;
413: }
414:
415: if (free_tx_pages <= 0) { /* Do timeouts, to avoid hangs. */
416: tickssofar = jiffies - dev->trans_start;
417:
418: if (tickssofar < 5)
419: return 1;
420:
421: /* else */
422: printk("%s: transmit timed out (%d), %s?\n",
423: dev->name,
424: tickssofar,
425: "network cable problem"
426: );
427: /* Restart the adapter. */
428: if (adapter_init(dev)) {
429: return 1;
430: }
431: }
432:
433: /* Start real output */
434: PRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
435:
436: if ((len = skb->len) < RUNT)
437: len = RUNT;
438:
439: cli();
440: select_nic();
441: tx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len;
442: tx_fifo_in = (tx_fifo_in + 1) % TX_PAGES; /* Next free tx page */
443:
444: #ifdef CHECK_LOST_DE600
445: /* This costs about 40 instructions per packet... */
446: de600_setup_address(NODE_ADDRESS, RW_ADDR);
447: de600_read_byte(READ_DATA, dev);
448: if (was_down || (de600_read_byte(READ_DATA, dev) != 0xde)) {
449: if (adapter_init(dev)) {
450: sti();
451: return 1;
452: }
453: }
454: #endif
455:
456: de600_setup_address(transmit_from, RW_ADDR);
457: for ( ; len > 0; --len, ++buffer)
458: de600_put_byte(*buffer);
459:
460: if (free_tx_pages-- == TX_PAGES) { /* No transmission going on */
461: dev->trans_start = jiffies;
462: dev->tbusy = 0; /* allow more packets into adapter */
463: /* Send page and generate a faked interrupt */
464: de600_setup_address(transmit_from, TX_ADDR);
465: de600_put_command(TX_ENABLE);
466: }
467: else {
468: dev->tbusy = !free_tx_pages;
469: select_prn();
470: }
471:
472: sti(); /* interrupts back on */
473:
474: #ifdef FAKE_SMALL_MAX
475: /* This will "patch" the socket TCP proto at an early moment */
476: if (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
477: (skb->sk->prot->rspace != &de600_rspace))
478: skb->sk->prot->rspace = de600_rspace; /* Ugh! */
479: #endif
480:
481: dev_kfree_skb (skb, FREE_WRITE);
482:
483: return 0;
484: }
485:
486: /*
487: * The typical workload of the driver:
488: * Handle the network interface interrupts.
489: */
490: static void
491: de600_interrupt(int irq, void *dev_id, struct pt_regs * regs)
492: {
493: struct device *dev = irq2dev_map[irq];
494: byte irq_status;
495: int retrig = 0;
496: int boguscount = 0;
497:
498: /* This might just as well be deleted now, no crummy drivers present :-) */
499: if ((dev == NULL) || (dev->start == 0) || (DE600_IRQ != irq)) {
500: printk("%s: bogus interrupt %d\n", dev?dev->name:"DE-600", irq);
501: return;
502: }
503:
504: dev->interrupt = 1;
505: select_nic();
506: irq_status = de600_read_status(dev);
507:
508: do {
509: PRINTK(("de600_interrupt (%02X)\n", irq_status));
510:
511: if (irq_status & RX_GOOD)
512: de600_rx_intr(dev);
513: else if (!(irq_status & RX_BUSY))
514: de600_put_command(RX_ENABLE);
515:
516: /* Any transmission in progress? */
517: if (free_tx_pages < TX_PAGES)
518: retrig = de600_tx_intr(dev, irq_status);
519: else
520: retrig = 0;
521:
522: irq_status = de600_read_status(dev);
523: } while ( (irq_status & RX_GOOD) || ((++boguscount < 100) && retrig) );
524: /*
525: * Yeah, it _looks_ like busy waiting, smells like busy waiting
526: * and I know it's not PC, but please, it will only occur once
527: * in a while and then only for a loop or so (< 1ms for sure!)
528: */
529:
530: /* Enable adapter interrupts */
531: dev->interrupt = 0;
532: select_prn();
533:
534: if (retrig)
535: trigger_interrupt(dev);
536:
537: sti();
538: return;
539: }
540:
541: static int
542: de600_tx_intr(struct device *dev, int irq_status)
543: {
544: /*
545: * Returns 1 if tx still not done
546: */
547:
548: mark_bh(NET_BH);
549: /* Check if current transmission is done yet */
550: if (irq_status & TX_BUSY)
551: return 1; /* tx not done, try again */
552:
553: /* else */
554: /* If last transmission OK then bump fifo index */
555: if (!(irq_status & TX_FAILED16)) {
556: tx_fifo_out = (tx_fifo_out + 1) % TX_PAGES;
557: ++free_tx_pages;
558: ((struct netstats *)(dev->priv))->tx_packets++;
559: dev->tbusy = 0;
560: }
561:
562: /* More to send, or resend last packet? */
563: if ((free_tx_pages < TX_PAGES) || (irq_status & TX_FAILED16)) {
564: dev->trans_start = jiffies;
565: de600_setup_address(tx_fifo[tx_fifo_out], TX_ADDR);
566: de600_put_command(TX_ENABLE);
567: return 1;
568: }
569: /* else */
570:
571: return 0;
572: }
573:
574: /*
575: * We have a good packet, get it out of the adapter.
576: */
577: static void
578: de600_rx_intr(struct device *dev)
579: {
580: struct sk_buff *skb;
581: int i;
582: int read_from;
583: int size;
584: register unsigned char *buffer;
585:
586: cli();
587: /* Get size of received packet */
588: size = de600_read_byte(RX_LEN, dev); /* low byte */
589: size += (de600_read_byte(RX_LEN, dev) << 8); /* high byte */
590: size -= 4; /* Ignore trailing 4 CRC-bytes */
591:
592: /* Tell adapter where to store next incoming packet, enable receiver */
593: read_from = rx_page_adr();
594: next_rx_page();
595: de600_put_command(RX_ENABLE);
596: sti();
597:
598: if ((size < 32) || (size > 1535)) {
599: printk("%s: Bogus packet size %d.\n", dev->name, size);
600: if (size > 10000)
601: adapter_init(dev);
602: return;
603: }
604:
605: skb = dev_alloc_skb(size+2);
606: sti();
607: if (skb == NULL) {
608: printk("%s: Couldn't allocate a sk_buff of size %d.\n",
609: dev->name, size);
610: return;
611: }
612: /* else */
613:
614: skb->dev = dev;
615: skb_reserve(skb,2); /* Align */
616:
617: /* 'skb->data' points to the start of sk_buff data area. */
618: buffer = skb_put(skb,size);
619:
620: /* copy the packet into the buffer */
621: de600_setup_address(read_from, RW_ADDR);
622: for (i = size; i > 0; --i, ++buffer)
623: *buffer = de600_read_byte(READ_DATA, dev);
624:
625: ((struct netstats *)(dev->priv))->rx_packets++; /* count all receives */
626:
627: skb->protocol=eth_type_trans(skb,dev);
628:
629: netif_rx(skb);
630: /*
631: * If any worth-while packets have been received, netif_rx()
632: * has done a mark_bh(INET_BH) for us and will work on them
633: * when we get to the bottom-half routine.
634: */
635: }
636:
637: int
638: de600_probe(struct device *dev)
639: {
640: int i;
641: static struct netstats de600_netstats;
642: /*dev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL);*/
643:
644: printk("%s: D-Link DE-600 pocket adapter", dev->name);
645: /* Alpha testers must have the version number to report bugs. */
646: if (de600_debug > 1)
647: printk(version);
648:
649: /* probe for adapter */
650: rx_page = 0;
651: select_nic();
652: (void)de600_read_status(dev);
653: de600_put_command(RESET);
654: de600_put_command(STOP_RESET);
655: if (de600_read_status(dev) & 0xf0) {
656: printk(": not at I/O %#3x.\n", DATA_PORT);
657: return ENODEV;
658: }
659:
660: /*
661: * Maybe we found one,
662: * have to check if it is a D-Link DE-600 adapter...
663: */
664:
665: /* Get the adapter ethernet address from the ROM */
666: de600_setup_address(NODE_ADDRESS, RW_ADDR);
667: for (i = 0; i < ETH_ALEN; i++) {
668: dev->dev_addr[i] = de600_read_byte(READ_DATA, dev);
669: dev->broadcast[i] = 0xff;
670: }
671:
672: /* Check magic code */
673: if ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) {
674: /* OK, install real address */
675: dev->dev_addr[0] = 0x00;
676: dev->dev_addr[1] = 0x80;
677: dev->dev_addr[2] = 0xc8;
678: dev->dev_addr[3] &= 0x0f;
679: dev->dev_addr[3] |= 0x70;
680: } else {
681: printk(" not identified in the printer port\n");
682: return ENODEV;
683: }
684:
685: #if 0 /* Not yet */
686: if (check_region(DE600_IO, 3)) {
687: printk(", port 0x%x busy\n", DE600_IO);
688: return EBUSY;
689: }
690: #endif
691: request_region(DE600_IO, 3, "de600");
692:
693: printk(", Ethernet Address: %02X", dev->dev_addr[0]);
694: for (i = 1; i < ETH_ALEN; i++)
695: printk(":%02X",dev->dev_addr[i]);
696: printk("\n");
697:
698: /* Initialize the device structure. */
699: /*dev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL);*/
700: dev->priv = &de600_netstats;
701:
702: memset(dev->priv, 0, sizeof(struct netstats));
703: dev->get_stats = get_stats;
704:
705: dev->open = de600_open;
706: dev->stop = de600_close;
707: dev->hard_start_xmit = &de600_start_xmit;
708:
709: ether_setup(dev);
710:
711: dev->flags&=~IFF_MULTICAST;
712:
713: select_prn();
714: return 0;
715: }
716:
717: static int
718: adapter_init(struct device *dev)
719: {
720: int i;
721: long flags;
722:
723: save_flags(flags);
724: cli();
725:
726: select_nic();
727: rx_page = 0; /* used by RESET */
728: de600_put_command(RESET);
729: de600_put_command(STOP_RESET);
730: #ifdef CHECK_LOST_DE600
731: /* Check if it is still there... */
732: /* Get the some bytes of the adapter ethernet address from the ROM */
733: de600_setup_address(NODE_ADDRESS, RW_ADDR);
734: de600_read_byte(READ_DATA, dev);
735: if ((de600_read_byte(READ_DATA, dev) != 0xde) ||
736: (de600_read_byte(READ_DATA, dev) != 0x15)) {
737: /* was: if (de600_read_status(dev) & 0xf0) { */
738: printk("Something has happened to the DE-600! Please check it"
739: #ifdef SHUTDOWN_WHEN_LOST
740: " and do a new ifconfig"
741: #endif /* SHUTDOWN_WHEN_LOST */
742: "!\n");
743: #ifdef SHUTDOWN_WHEN_LOST
744: /* Goodbye, cruel world... */
745: dev->flags &= ~IFF_UP;
746: de600_close(dev);
747: #endif /* SHUTDOWN_WHEN_LOST */
748: was_down = 1;
749: dev->tbusy = 1; /* Transmit busy... */
750: restore_flags(flags);
751: return 1; /* failed */
752: }
753: #endif /* CHECK_LOST_DE600 */
754: if (was_down) {
755: printk("Thanks, I feel much better now!\n");
756: was_down = 0;
757: }
758:
759: dev->tbusy = 0; /* Transmit busy... */
760: dev->interrupt = 0;
761: tx_fifo_in = 0;
762: tx_fifo_out = 0;
763: free_tx_pages = TX_PAGES;
764:
765: /* set the ether address. */
766: de600_setup_address(NODE_ADDRESS, RW_ADDR);
767: for (i = 0; i < ETH_ALEN; i++)
768: de600_put_byte(dev->dev_addr[i]);
769:
770: /* where to start saving incoming packets */
771: rx_page = RX_BP | RX_BASE_PAGE;
772: de600_setup_address(MEM_4K, RW_ADDR);
773: /* Enable receiver */
774: de600_put_command(RX_ENABLE);
775: select_prn();
776: restore_flags(flags);
777:
778: return 0; /* OK */
779: }
780:
781: #ifdef FAKE_SMALL_MAX
782: /*
783: * The new router code (coming soon 8-) ) will fix this properly.
784: */
785: #define DE600_MIN_WINDOW 1024
786: #define DE600_MAX_WINDOW 2048
787: #define DE600_TCP_WINDOW_DIFF 1024
788: /*
789: * Copied from "net/inet/sock.c"
790: *
791: * Sets a lower max receive window in order to achieve <= 2
792: * packets arriving at the adapter in fast succession.
793: * (No way that a DE-600 can keep up with a net saturated
794: * with packets homing in on it :-( )
795: *
796: * Since there are only 2 receive buffers in the DE-600
797: * and it takes some time to copy from the adapter,
798: * this is absolutely necessary for any TCP performance whatsoever!
799: *
800: * Note that the returned window info will never be smaller than
801: * DE600_MIN_WINDOW, i.e. 1024
802: * This differs from the standard function, that can return an
803: * arbitrarily small window!
804: */
805: #define min(a,b) ((a)<(b)?(a):(b))
806: static unsigned long
807: de600_rspace(struct sock *sk)
808: {
809: int amt;
810:
811: if (sk != NULL) {
812: /*
813: * Hack! You might want to play with commenting away the following line,
814: * if you know what you do!
815: sk->max_unacked = DE600_MAX_WINDOW - DE600_TCP_WINDOW_DIFF;
816: */
817:
818: if (sk->rmem_alloc >= sk->rcvbuf-2*DE600_MIN_WINDOW) return(0);
819: amt = min((sk->rcvbuf-sk->rmem_alloc)/2/*-DE600_MIN_WINDOW*/, DE600_MAX_WINDOW);
820: if (amt < 0) return(0);
821: return(amt);
822: }
823: return(0);
824: }
825: #endif
826:
827: #ifdef MODULE
828: static char nullname[8];
829: static struct device de600_dev = {
830: nullname, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, de600_probe };
831:
832: int
833: init_module(void)
834: {
835: if (register_netdev(&de600_dev) != 0)
836: return -EIO;
837: return 0;
838: }
839:
840: void
841: cleanup_module(void)
842: {
843: unregister_netdev(&de600_dev);
844: release_region(DE600_IO, 3);
845: }
846: #endif /* MODULE */
847: /*
848: * Local variables:
849: * kernel-compile-command: "gcc -D__KERNEL__ -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c"
850: * module-compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c"
851: * compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de600.c"
852: * End:
853: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.