2 * de620.c $Revision: 1.40 $ BETA
5 * Linux driver for the D-Link DE-620 Ethernet pocket adapter.
7 * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall <bj0rn@blox.se>
9 * Based on adapter information gathered from DOS packetdriver
10 * sources from D-Link Inc: (Special thanks to Henry Ngai of D-Link.)
11 * Portions (C) Copyright D-Link SYSTEM Inc. 1991, 1992
12 * Copyright, 1988, Russell Nelson, Crynwr Software
14 * Adapted to the sample network driver core for linux,
15 * written by: Donald Becker <becker@super.org>
16 * (Now at <becker@scyld.com>)
18 * Valuable assistance from:
19 * J. Joshua Kopper <kopper@rtsg.mot.com>
20 * Olav Kvittem <Olav.Kvittem@uninett.no>
21 * Germano Caronni <caronni@nessie.cs.id.ethz.ch>
22 * Jeremy Fitzhardinge <jeremy@suite.sw.oz.au>
24 *****************************************************************************/
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2, or (at your option)
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
36 * You should have received a copy of the GNU General Public License
37 * along with this program; if not, write to the Free Software
38 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
40 *****************************************************************************/
41 static const char version
[] =
42 "de620.c: $Revision: 1.40 $, Bjorn Ekwall <bj0rn@blox.se>\n";
44 /***********************************************************************
48 * Compile-time options: (see below for descriptions)
49 * -DDE620_IO=0x378 (lpt1)
50 * -DDE620_IRQ=7 (lpt1)
52 * -DSHUTDOWN_WHEN_LOST
60 * This driver assumes that the printer port is a "normal",
61 * dumb, uni-directional port!
62 * If your port is "fancy" in any way, please try to set it to "normal"
63 * with your BIOS setup. I have no access to machines with bi-directional
64 * ports, so I can't test such a driver :-(
65 * (Yes, I _know_ it is possible to use DE620 with bidirectional ports...)
67 * There are some clones of DE620 out there, with different names.
68 * If the current driver does not recognize a clone, try to change
69 * the following #define to:
71 * #define DE620_CLONE 1
76 * If the adapter has problems with high speeds, enable this #define
77 * otherwise full printerport speed will be attempted.
79 * You can tune the READ_DELAY/WRITE_DELAY below if you enable LOWSPEED
85 #define READ_DELAY 100 /* adapter internal read delay in 100ns units */
89 #define WRITE_DELAY 100 /* adapter internal write delay in 100ns units */
93 * Enable this #define if you want the adapter to do a "ifconfig down" on
94 * itself when we have detected that something is possibly wrong with it.
95 * The default behaviour is to retry with "adapter_init()" until success.
96 * This should be used for debugging purposes only.
98 #define SHUTDOWN_WHEN_LOST
102 * Enable debugging by "-DDE620_DEBUG=3" when compiling,
103 * OR by enabling the following #define
105 * use 0 for production, 1 for verification, >2 for debug
107 #define DE620_DEBUG 3
112 * Enable this #define if you want to see debugging output that show how long
113 * we have to wait before the DE-620 is ready for the next read/write/command.
119 #include <linux/module.h>
120 #include <linux/kernel.h>
121 #include <linux/types.h>
122 #include <linux/fcntl.h>
123 #include <linux/string.h>
124 #include <linux/interrupt.h>
125 #include <linux/ioport.h>
126 #include <linux/in.h>
127 #include <linux/errno.h>
128 #include <linux/init.h>
129 #include <linux/inet.h>
130 #include <linux/netdevice.h>
131 #include <linux/etherdevice.h>
132 #include <linux/skbuff.h>
135 #include <asm/system.h>
137 /* Constant definitions for the DE-620 registers, commands and bits */
140 typedef unsigned char byte
;
142 /*******************************************************
144 * Definition of D-Link DE-620 Ethernet Pocket adapter *
145 * See also "de620.h" *
147 *******************************************************/
148 #ifndef DE620_IO /* Compile-time configurable */
149 #define DE620_IO 0x378
152 #ifndef DE620_IRQ /* Compile-time configurable */
156 #define DATA_PORT (dev->base_addr)
157 #define STATUS_PORT (dev->base_addr + 1)
158 #define COMMAND_PORT (dev->base_addr + 2)
160 #define RUNT 60 /* Too small Ethernet packet */
161 #define GIANT 1514 /* largest legal size packet, no fcs */
163 #ifdef DE620_DEBUG /* Compile-time configurable */
164 #define PRINTK(x) if (de620_debug >= 2) printk x
166 #define DE620_DEBUG 0
167 #define PRINTK(x) /**/
172 * Force media with insmod:
173 * insmod de620.o bnc=1
175 * insmod de620.o utp=1
177 * Force io and/or irq with insmod:
178 * insmod de620.o io=0x378 irq=7
180 * Make a clone skip the Ethernet-address range check:
181 * insmod de620.o clone=1
185 static int io
= DE620_IO
;
186 static int irq
= DE620_IRQ
;
187 static int clone
= DE620_CLONE
;
189 static unsigned int de620_debug
= DE620_DEBUG
;
191 static spinlock_t de620_lock
;
193 module_param(bnc
, int, 0);
194 module_param(utp
, int, 0);
195 module_param(io
, int, 0);
196 module_param(irq
, int, 0);
197 module_param(clone
, int, 0);
198 module_param(de620_debug
, int, 0);
199 MODULE_PARM_DESC(bnc
, "DE-620 set BNC medium (0-1)");
200 MODULE_PARM_DESC(utp
, "DE-620 set UTP medium (0-1)");
201 MODULE_PARM_DESC(io
, "DE-620 I/O base address,required");
202 MODULE_PARM_DESC(irq
, "DE-620 IRQ number,required");
203 MODULE_PARM_DESC(clone
, "Check also for non-D-Link DE-620 clones (0-1)");
204 MODULE_PARM_DESC(de620_debug
, "DE-620 debug level (0-2)");
206 /***********************************************
208 * Index to functions, as function prototypes. *
210 ***********************************************/
213 * Routines used internally. (See also "convenience macros.. below")
216 /* Put in the device structure. */
217 static int de620_open(struct net_device
*);
218 static int de620_close(struct net_device
*);
219 static void de620_set_multicast_list(struct net_device
*);
220 static int de620_start_xmit(struct sk_buff
*, struct net_device
*);
222 /* Dispatch from interrupts. */
223 static irqreturn_t
de620_interrupt(int, void *);
224 static int de620_rx_intr(struct net_device
*);
227 static int adapter_init(struct net_device
*);
228 static int read_eeprom(struct net_device
*);
232 * D-Link driver variables:
234 #define SCR_DEF NIBBLEMODE |INTON | SLEEP | AUTOTX
235 #define TCR_DEF RXPB /* not used: | TXSUCINT | T16INT */
236 #define DE620_RX_START_PAGE 12 /* 12 pages (=3k) reserved for tx */
237 #define DEF_NIC_CMD IRQEN | ICEN | DS1
239 static volatile byte NIC_Cmd
;
240 static volatile byte next_rx_page
;
241 static byte first_rx_page
;
242 static byte last_rx_page
;
243 static byte EIPRegister
;
253 /**********************************************************
255 * Convenience macros/functions for D-Link DE-620 adapter *
257 **********************************************************/
258 #define de620_tx_buffs(dd) (inb(STATUS_PORT) & (TXBF0 | TXBF1))
259 #define de620_flip_ds(dd) NIC_Cmd ^= DS0 | DS1; outb(NIC_Cmd, COMMAND_PORT);
261 /* Check for ready-status, and return a nibble (high 4 bits) for data input */
266 de620_ready(struct net_device
*dev
)
269 register short int cnt
= 0;
271 while ((((value
= inb(STATUS_PORT
)) & READY
) == 0) && (cnt
<= 1000))
277 return value
& 0xf0; /* nibble */
281 de620_send_command(struct net_device
*dev
, byte cmd
)
285 outb(NIC_Cmd
, COMMAND_PORT
);
287 outb(cmd
, DATA_PORT
);
289 outb(NIC_Cmd
^ CS0
, COMMAND_PORT
);
291 outb(NIC_Cmd
, COMMAND_PORT
);
295 de620_put_byte(struct net_device
*dev
, byte value
)
297 /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
299 outb(value
, DATA_PORT
);
304 de620_read_byte(struct net_device
*dev
)
308 /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
309 value
= de620_ready(dev
); /* High nibble */
311 value
|= de620_ready(dev
) >> 4; /* Low nibble */
316 de620_write_block(struct net_device
*dev
, byte
*buffer
, int count
, int pad
)
319 byte uflip
= NIC_Cmd
^ (DS0
| DS1
);
320 byte dflip
= NIC_Cmd
;
324 #endif /* COUNT_LOOPS */
325 #endif /* LOWSPEED */
330 #endif /* COUNT_LOOPS */
331 /* No further optimization useful, the limit is in the adapter. */
332 for ( ; count
> 0; --count
, ++buffer
) {
333 de620_put_byte(dev
,*buffer
);
335 for ( count
= pad
; count
> 0; --count
, ++buffer
) {
336 de620_put_byte(dev
, 0);
338 de620_send_command(dev
,W_DUMMY
);
340 /* trial debug output: loops per byte in de620_ready() */
341 printk("WRITE(%d)\n", tot_cnt
/((bytes
?bytes
:1)));
342 #endif /* COUNT_LOOPS */
343 #else /* not LOWSPEED */
344 for ( ; count
> 0; count
-=2) {
345 outb(*buffer
++, DATA_PORT
);
346 outb(uflip
, COMMAND_PORT
);
347 outb(*buffer
++, DATA_PORT
);
348 outb(dflip
, COMMAND_PORT
);
350 de620_send_command(dev
,W_DUMMY
);
351 #endif /* LOWSPEED */
355 de620_read_block(struct net_device
*dev
, byte
*data
, int count
)
359 byte uflip
= NIC_Cmd
^ (DS0
| DS1
);
360 byte dflip
= NIC_Cmd
;
366 #endif /* COUNT_LOOPS */
367 #endif /* LOWSPEED */
370 /* No further optimization useful, the limit is in the adapter. */
371 while (count
-- > 0) {
372 *data
++ = de620_read_byte(dev
);
376 /* trial debug output: loops per byte in de620_ready() */
377 printk("READ(%d)\n", tot_cnt
/(2*(bytes
?bytes
:1)));
378 #endif /* COUNT_LOOPS */
379 #else /* not LOWSPEED */
380 while (count
-- > 0) {
381 value
= inb(STATUS_PORT
) & 0xf0; /* High nibble */
382 outb(uflip
, COMMAND_PORT
);
383 *data
++ = value
| inb(STATUS_PORT
) >> 4; /* Low nibble */
384 outb(dflip
, COMMAND_PORT
);
386 #endif /* LOWSPEED */
390 de620_set_delay(struct net_device
*dev
)
393 outb(W_DFR
, DATA_PORT
);
394 outb(NIC_Cmd
^ CS0
, COMMAND_PORT
);
398 outb(WRITE_DELAY
, DATA_PORT
);
406 outb(READ_DELAY
, DATA_PORT
);
414 de620_set_register(struct net_device
*dev
, byte reg
, byte value
)
417 outb(reg
, DATA_PORT
);
418 outb(NIC_Cmd
^ CS0
, COMMAND_PORT
);
420 de620_put_byte(dev
, value
);
424 de620_get_register(struct net_device
*dev
, byte reg
)
428 de620_send_command(dev
,reg
);
429 value
= de620_read_byte(dev
);
430 de620_send_command(dev
,W_DUMMY
);
435 /*********************************************************************
437 * Open/initialize the board.
439 * This routine should set everything up anew at each open, even
440 * registers that "should" only need to be set once at boot, so that
441 * there is a non-reboot way to recover if something goes wrong.
444 static int de620_open(struct net_device
*dev
)
446 int ret
= request_irq(dev
->irq
, de620_interrupt
, 0, dev
->name
, dev
);
448 printk (KERN_ERR
"%s: unable to get IRQ %d\n", dev
->name
, dev
->irq
);
452 if (adapter_init(dev
)) {
457 netif_start_queue(dev
);
461 free_irq(dev
->irq
, dev
);
465 /************************************************
467 * The inverse routine to de620_open().
471 static int de620_close(struct net_device
*dev
)
473 netif_stop_queue(dev
);
475 de620_set_register(dev
, W_TCR
, RXOFF
);
476 free_irq(dev
->irq
, dev
);
480 /*********************************************
482 * Set or clear the multicast filter for this adaptor.
483 * (no real multicast implemented for the DE-620, but she can be promiscuous...)
487 static void de620_set_multicast_list(struct net_device
*dev
)
489 if (dev
->mc_count
|| dev
->flags
&(IFF_ALLMULTI
|IFF_PROMISC
))
490 { /* Enable promiscuous mode */
491 de620_set_register(dev
, W_TCR
, (TCR_DEF
& ~RXPBM
) | RXALL
);
494 { /* Disable promiscuous mode, use normal mode */
495 de620_set_register(dev
, W_TCR
, TCR_DEF
);
499 /*******************************************************
501 * Handle timeouts on transmit
504 static void de620_timeout(struct net_device
*dev
)
506 printk(KERN_WARNING
"%s: transmit timed out, %s?\n", dev
->name
, "network cable problem");
507 /* Restart the adapter. */
508 if (!adapter_init(dev
)) /* maybe close it */
509 netif_wake_queue(dev
);
512 /*******************************************************
514 * Copy a buffer to the adapter transmit page memory.
517 static int de620_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
521 byte
*buffer
= skb
->data
;
524 using_txbuf
= de620_tx_buffs(dev
); /* Peek at the adapter */
526 netif_stop_queue(dev
);
529 if ((len
= skb
->len
) < RUNT
)
531 if (len
& 1) /* send an even number of bytes */
534 /* Start real output */
536 spin_lock_irqsave(&de620_lock
, flags
)
537 PRINTK(("de620_start_xmit: len=%d, bufs 0x%02x\n",
538 (int)skb
->len
, using_txbuf
));
540 /* select a free tx buffer. if there is one... */
541 switch (using_txbuf
) {
542 default: /* both are free: use TXBF0 */
543 case TXBF1
: /* use TXBF0 */
544 de620_send_command(dev
,W_CR
| RW0
);
545 using_txbuf
|= TXBF0
;
548 case TXBF0
: /* use TXBF1 */
549 de620_send_command(dev
,W_CR
| RW1
);
550 using_txbuf
|= TXBF1
;
553 case (TXBF0
| TXBF1
): /* NONE!!! */
554 printk(KERN_WARNING
"%s: No tx-buffer available!\n", dev
->name
);
555 spin_unlock_irqrestore(&de620_lock
, flags
);
558 de620_write_block(dev
, buffer
, skb
->len
, len
-skb
->len
);
560 dev
->trans_start
= jiffies
;
561 if(!(using_txbuf
== (TXBF0
| TXBF1
)))
562 netif_wake_queue(dev
);
564 dev
->stats
.tx_packets
++;
565 spin_unlock_irqrestore(&de620_lock
, flags
);
570 /*****************************************************
572 * Handle the network interface interrupts.
576 de620_interrupt(int irq_in
, void *dev_id
)
578 struct net_device
*dev
= dev_id
;
583 spin_lock(&de620_lock
);
585 /* Read the status register (_not_ the status port) */
586 irq_status
= de620_get_register(dev
, R_STS
);
588 PRINTK(("de620_interrupt (%2.2X)\n", irq_status
));
590 if (irq_status
& RXGOOD
) {
592 again
= de620_rx_intr(dev
);
593 PRINTK(("again=%d\n", again
));
595 while (again
&& (++bogus_count
< 100));
598 if(de620_tx_buffs(dev
) != (TXBF0
| TXBF1
))
599 netif_wake_queue(dev
);
601 spin_unlock(&de620_lock
);
605 /**************************************
607 * Get a packet from the adapter
612 static int de620_rx_intr(struct net_device
*dev
)
617 unsigned short Rx_ByteCount
;
625 PRINTK(("de620_rx_intr: next_rx_page = %d\n", next_rx_page
));
627 /* Tell the adapter that we are going to read data, and from where */
628 de620_send_command(dev
, W_CR
| RRN
);
629 de620_set_register(dev
, W_RSA1
, next_rx_page
);
630 de620_set_register(dev
, W_RSA0
, 0);
632 /* Deep breath, and away we goooooo */
633 de620_read_block(dev
, (byte
*)&header_buf
, sizeof(struct header_buf
));
634 PRINTK(("page status=0x%02x, nextpage=%d, packetsize=%d\n",
635 header_buf
.status
, header_buf
.Rx_NextPage
, header_buf
.Rx_ByteCount
));
637 /* Plausible page header? */
638 pagelink
= header_buf
.Rx_NextPage
;
639 if ((pagelink
< first_rx_page
) || (last_rx_page
< pagelink
)) {
640 /* Ouch... Forget it! Skip all and start afresh... */
641 printk(KERN_WARNING
"%s: Ring overrun? Restoring...\n", dev
->name
);
642 /* You win some, you lose some. And sometimes plenty... */
644 netif_wake_queue(dev
);
645 dev
->stats
.rx_over_errors
++;
649 /* OK, this look good, so far. Let's see if it's consistent... */
650 /* Let's compute the start of the next packet, based on where we are */
651 pagelink
= next_rx_page
+
652 ((header_buf
.Rx_ByteCount
+ (4 - 1 + 0x100)) >> 8);
654 /* Are we going to wrap around the page counter? */
655 if (pagelink
> last_rx_page
)
656 pagelink
-= (last_rx_page
- first_rx_page
+ 1);
658 /* Is the _computed_ next page number equal to what the adapter says? */
659 if (pagelink
!= header_buf
.Rx_NextPage
) {
660 /* Naah, we'll skip this packet. Probably bogus data as well */
661 printk(KERN_WARNING
"%s: Page link out of sync! Restoring...\n", dev
->name
);
662 next_rx_page
= header_buf
.Rx_NextPage
; /* at least a try... */
663 de620_send_command(dev
, W_DUMMY
);
664 de620_set_register(dev
, W_NPRF
, next_rx_page
);
665 dev
->stats
.rx_over_errors
++;
668 next_rx_page
= pagelink
;
670 size
= header_buf
.Rx_ByteCount
- 4;
671 if ((size
< RUNT
) || (GIANT
< size
)) {
672 printk(KERN_WARNING
"%s: Illegal packet size: %d!\n", dev
->name
, size
);
674 else { /* Good packet? */
675 skb
= dev_alloc_skb(size
+2);
676 if (skb
== NULL
) { /* Yeah, but no place to put it... */
677 printk(KERN_WARNING
"%s: Couldn't allocate a sk_buff of size %d.\n", dev
->name
, size
);
678 dev
->stats
.rx_dropped
++;
680 else { /* Yep! Go get it! */
681 skb_reserve(skb
,2); /* Align */
682 /* skb->data points to the start of sk_buff data area */
683 buffer
= skb_put(skb
,size
);
684 /* copy the packet into the buffer */
685 de620_read_block(dev
, buffer
, size
);
686 PRINTK(("Read %d bytes\n", size
));
687 skb
->protocol
=eth_type_trans(skb
,dev
);
688 netif_rx(skb
); /* deliver it "upstairs" */
689 dev
->last_rx
= jiffies
;
690 /* count all receives */
691 dev
->stats
.rx_packets
++;
692 dev
->stats
.rx_bytes
+= size
;
696 /* Let's peek ahead to see if we have read the last current packet */
697 /* NOTE! We're _not_ checking the 'EMPTY'-flag! This seems better... */
698 curr_page
= de620_get_register(dev
, R_CPR
);
699 de620_set_register(dev
, W_NPRF
, next_rx_page
);
700 PRINTK(("next_rx_page=%d CPR=%d\n", next_rx_page
, curr_page
));
702 return (next_rx_page
!= curr_page
); /* That was slightly tricky... */
705 /*********************************************
707 * Reset the adapter to a known state
710 static int adapter_init(struct net_device
*dev
)
715 if ((nic_data
.Model
== 3) || (nic_data
.Model
== 0)) { /* CT */
717 if (nic_data
.Media
!= 1)
718 EIPRegister
|= NIS0
; /* not BNC */
720 else if (nic_data
.Model
== 2) { /* UTP */
721 EIPRegister
= NCTL0
| NIS0
;
725 EIPRegister
= NCTL0
| NIS0
;
729 de620_send_command(dev
, W_CR
| RNOP
| CLEAR
);
730 de620_send_command(dev
, W_CR
| RNOP
);
732 de620_set_register(dev
, W_SCR
, SCR_DEF
);
733 /* disable recv to wait init */
734 de620_set_register(dev
, W_TCR
, RXOFF
);
736 /* Set the node ID in the adapter */
737 for (i
= 0; i
< 6; ++i
) { /* W_PARn = 0xaa + n */
738 de620_set_register(dev
, W_PAR0
+ i
, dev
->dev_addr
[i
]);
741 de620_set_register(dev
, W_EIP
, EIPRegister
);
743 next_rx_page
= first_rx_page
= DE620_RX_START_PAGE
;
744 if (nic_data
.RAM_Size
)
745 last_rx_page
= nic_data
.RAM_Size
- 1;
749 de620_set_register(dev
, W_SPR
, first_rx_page
); /* Start Page Register*/
750 de620_set_register(dev
, W_EPR
, last_rx_page
); /* End Page Register */
751 de620_set_register(dev
, W_CPR
, first_rx_page
);/*Current Page Register*/
752 de620_send_command(dev
, W_NPR
| first_rx_page
); /* Next Page Register*/
753 de620_send_command(dev
, W_DUMMY
);
754 de620_set_delay(dev
);
756 /* Final sanity check: Anybody out there? */
757 /* Let's hope some bits from the statusregister make a good check */
758 #define CHECK_MASK ( 0 | TXSUC | T16 | 0 | RXCRC | RXSHORT | 0 | 0 )
759 #define CHECK_OK ( 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 )
760 /* success: X 0 0 X 0 0 X X */
761 /* ignore: EEDI RXGOOD COLS LNKS*/
763 if (((i
= de620_get_register(dev
, R_STS
)) & CHECK_MASK
) != CHECK_OK
) {
764 printk(KERN_ERR
"%s: Something has happened to the DE-620! Please check it"
765 #ifdef SHUTDOWN_WHEN_LOST
766 " and do a new ifconfig"
768 "! (%02x)\n", dev
->name
, i
);
769 #ifdef SHUTDOWN_WHEN_LOST
770 /* Goodbye, cruel world... */
771 dev
->flags
&= ~IFF_UP
;
775 return 1; /* failed */
778 printk(KERN_WARNING
"%s: Thanks, I feel much better now!\n", dev
->name
);
782 /* All OK, go ahead... */
783 de620_set_register(dev
, W_TCR
, TCR_DEF
);
785 return 0; /* all ok */
788 /******************************************************************************
790 * Only start-up code below
793 /****************************************
795 * Check if there is a DE-620 connected
797 struct net_device
* __init
de620_probe(int unit
)
799 byte checkbyte
= 0xa5;
800 struct net_device
*dev
;
803 DECLARE_MAC_BUF(mac
);
805 dev
= alloc_etherdev(0);
809 spin_lock_init(&de620_lock
);
812 * This is where the base_addr and irq gets set.
813 * Tunable at compile-time and insmod-time
818 /* allow overriding parameters on command line */
820 sprintf(dev
->name
, "eth%d", unit
);
821 netdev_boot_setup_check(dev
);
827 printk(KERN_INFO
"D-Link DE-620 pocket adapter");
829 if (!request_region(dev
->base_addr
, 3, "de620")) {
830 printk(" io 0x%3lX, which is busy.\n", dev
->base_addr
);
835 /* Initially, configure basic nibble mode, so we can read the EEPROM */
836 NIC_Cmd
= DEF_NIC_CMD
;
837 de620_set_register(dev
, W_EIP
, EIPRegister
);
839 /* Anybody out there? */
840 de620_set_register(dev
, W_CPR
, checkbyte
);
841 checkbyte
= de620_get_register(dev
, R_CPR
);
843 if ((checkbyte
!= 0xa5) || (read_eeprom(dev
) != 0)) {
844 printk(" not identified in the printer port\n");
850 dev
->dev_addr
[0] = nic_data
.NodeID
[0];
851 for (i
= 1; i
< ETH_ALEN
; i
++) {
852 dev
->dev_addr
[i
] = nic_data
.NodeID
[i
];
853 dev
->broadcast
[i
] = 0xff;
856 printk(", Ethernet Address: %s", print_mac(mac
, dev
->dev_addr
));
859 (nic_data
.RAM_Size
) ? (nic_data
.RAM_Size
>> 2) : 64);
861 if (nic_data
.Media
== 1)
866 dev
->open
= de620_open
;
867 dev
->stop
= de620_close
;
868 dev
->hard_start_xmit
= de620_start_xmit
;
869 dev
->tx_timeout
= de620_timeout
;
870 dev
->watchdog_timeo
= HZ
*2;
871 dev
->set_multicast_list
= de620_set_multicast_list
;
873 /* base_addr and irq are already set, see above! */
877 printk("\nEEPROM contents:\n");
878 printk("RAM_Size = 0x%02X\n", nic_data
.RAM_Size
);
879 printk("NodeID = %02X:%02X:%02X:%02X:%02X:%02X\n",
880 nic_data
.NodeID
[0], nic_data
.NodeID
[1],
881 nic_data
.NodeID
[2], nic_data
.NodeID
[3],
882 nic_data
.NodeID
[4], nic_data
.NodeID
[5]);
883 printk("Model = %d\n", nic_data
.Model
);
884 printk("Media = %d\n", nic_data
.Media
);
885 printk("SCR = 0x%02x\n", nic_data
.SCR
);
888 err
= register_netdev(dev
);
894 release_region(dev
->base_addr
, 3);
901 /**********************************
903 * Read info from on-board EEPROM
905 * Note: Bitwise serial I/O to/from the EEPROM vi the status _register_!
907 #define sendit(dev,data) de620_set_register(dev, W_EIP, data | EIPRegister);
909 static unsigned short __init
ReadAWord(struct net_device
*dev
, int from
)
914 /* cs [__~~] SET SEND STATE */
917 sendit(dev
, 0); sendit(dev
, 1); sendit(dev
, 5); sendit(dev
, 4);
919 /* Send the 9-bit address from where we want to read the 16-bit word */
920 for (nbits
= 9; nbits
> 0; --nbits
, from
<<= 1) {
921 if (from
& 0x0100) { /* bit set? */
922 /* cs [~~~~] SEND 1 */
925 sendit(dev
, 6); sendit(dev
, 7); sendit(dev
, 7); sendit(dev
, 6);
928 /* cs [~~~~] SEND 0 */
931 sendit(dev
, 4); sendit(dev
, 5); sendit(dev
, 5); sendit(dev
, 4);
935 /* Shift in the 16-bit word. The bits appear serially in EEDI (=0x80) */
936 for (data
= 0, nbits
= 16; nbits
> 0; --nbits
) {
937 /* cs [~~~~] SEND 0 */
940 sendit(dev
, 4); sendit(dev
, 5); sendit(dev
, 5); sendit(dev
, 4);
941 data
= (data
<< 1) | ((de620_get_register(dev
, R_STS
) & EEDI
) >> 7);
943 /* cs [____] RESET SEND STATE */
946 sendit(dev
, 0); sendit(dev
, 1); sendit(dev
, 1); sendit(dev
, 0);
951 static int __init
read_eeprom(struct net_device
*dev
)
955 /* D-Link Ethernet addresses are in the series 00:80:c8:7X:XX:XX:XX */
956 wrd
= ReadAWord(dev
, 0x1aa); /* bytes 0 + 1 of NodeID */
957 if (!clone
&& (wrd
!= htons(0x0080))) /* Valid D-Link ether sequence? */
958 return -1; /* Nope, not a DE-620 */
959 nic_data
.NodeID
[0] = wrd
& 0xff;
960 nic_data
.NodeID
[1] = wrd
>> 8;
962 wrd
= ReadAWord(dev
, 0x1ab); /* bytes 2 + 3 of NodeID */
963 if (!clone
&& ((wrd
& 0xff) != 0xc8)) /* Valid D-Link ether sequence? */
964 return -1; /* Nope, not a DE-620 */
965 nic_data
.NodeID
[2] = wrd
& 0xff;
966 nic_data
.NodeID
[3] = wrd
>> 8;
968 wrd
= ReadAWord(dev
, 0x1ac); /* bytes 4 + 5 of NodeID */
969 nic_data
.NodeID
[4] = wrd
& 0xff;
970 nic_data
.NodeID
[5] = wrd
>> 8;
972 wrd
= ReadAWord(dev
, 0x1ad); /* RAM size in pages (256 bytes). 0 = 64k */
973 nic_data
.RAM_Size
= (wrd
>> 8);
975 wrd
= ReadAWord(dev
, 0x1ae); /* hardware model (CT = 3) */
976 nic_data
.Model
= (wrd
& 0xff);
978 wrd
= ReadAWord(dev
, 0x1af); /* media (indicates BNC/UTP) */
979 nic_data
.Media
= (wrd
& 0xff);
981 wrd
= ReadAWord(dev
, 0x1a8); /* System Configuration Register */
982 nic_data
.SCR
= (wrd
>> 8);
984 return 0; /* no errors */
987 /******************************************************************************
989 * Loadable module skeleton
993 static struct net_device
*de620_dev
;
995 int __init
init_module(void)
997 de620_dev
= de620_probe(-1);
998 if (IS_ERR(de620_dev
))
999 return PTR_ERR(de620_dev
);
1003 void cleanup_module(void)
1005 unregister_netdev(de620_dev
);
1006 release_region(de620_dev
->base_addr
, 3);
1007 free_netdev(de620_dev
);
1010 MODULE_LICENSE("GPL");
1014 * (add '-DMODULE' when compiling as loadable module)
1017 * gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
1018 * -fomit-frame-pointer -m486 \
1019 * -I/usr/src/linux/include -I../../net/inet -c de620.c
1023 * kernel-compile-command: "gcc -D__KERNEL__ -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
1024 * module-compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
1025 * compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
This page took 0.05778 seconds and 6 git commands to generate.