1 static const char version
[] = "de600.c: $Revision: 1.41-2.5 $, Bjorn Ekwall (bj0rn@blox.se)\n";
5 * Linux driver for the D-Link DE-600 Ethernet pocket adapter.
7 * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall
8 * The Author may be reached as bj0rn@blox.se
10 * Based on adapter information gathered from DE600.ASM by D-Link Inc.,
11 * as included on disk C in the v.2.11 of PC/TCP from FTP Software.
13 * Portions (C) Copyright 1990 D-Link, Inc.
14 * Copyright, 1988-1992, Russell Nelson, Crynwr Software
16 * Adapted to the sample network driver core for linux,
17 * written by: Donald Becker <becker@super.org>
18 * (Now at <becker@scyld.com>)
20 **************************************************************/
22 * This program is free software; you can redistribute it and/or modify
23 * it under the terms of the GNU General Public License as published by
24 * the Free Software Foundation; either version 2, or (at your option)
27 * This program is distributed in the hope that it will be useful,
28 * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 * GNU General Public License for more details.
32 * You should have received a copy of the GNU General Public License
33 * along with this program; if not, write to the Free Software
34 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36 **************************************************************/
38 /* Add more time here if your adapter won't work OK: */
39 #define DE600_SLOW_DOWN udelay(delay_time)
42 * If you still have trouble reading/writing to the adapter,
43 * modify the following "#define": (see <asm/io.h> for more info)
44 #define REALLY_SLOW_IO
46 #define SLOW_IO_BY_JUMPING /* Looks "better" than dummy write to port 0x80 :-) */
48 /* use 0 for production, 1 for verification, >2 for debug */
50 #define PRINTK(x) if (de600_debug >= 2) printk x
53 #define PRINTK(x) /**/
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/types.h>
59 #include <linux/fcntl.h>
60 #include <linux/string.h>
61 #include <linux/interrupt.h>
62 #include <linux/ioport.h>
64 #include <asm/system.h>
65 #include <linux/errno.h>
66 #include <linux/init.h>
67 #include <linux/delay.h>
68 #include <linux/inet.h>
69 #include <linux/netdevice.h>
70 #include <linux/etherdevice.h>
71 #include <linux/skbuff.h>
77 static unsigned int de600_debug
= DE600_DEBUG
;
78 module_param(de600_debug
, int, 0);
79 MODULE_PARM_DESC(de600_debug
, "DE-600 debug level (0-2)");
81 static unsigned int check_lost
= 1;
82 module_param(check_lost
, bool, 0);
83 MODULE_PARM_DESC(check_lost
, "If set then check for unplugged de600");
85 static unsigned int delay_time
= 10;
86 module_param(delay_time
, int, 0);
87 MODULE_PARM_DESC(delay_time
, "DE-600 deley on I/O in microseconds");
91 * D-Link driver variables:
94 static volatile int rx_page
;
97 static volatile int tx_fifo
[TX_PAGES
];
98 static volatile int tx_fifo_in
;
99 static volatile int tx_fifo_out
;
100 static volatile int free_tx_pages
= TX_PAGES
;
102 static DEFINE_SPINLOCK(de600_lock
);
104 static inline u8
de600_read_status(struct net_device
*dev
)
108 outb_p(STATUS
, DATA_PORT
);
109 status
= inb(STATUS_PORT
);
110 outb_p(NULL_COMMAND
| HI_NIBBLE
, DATA_PORT
);
115 static inline u8
de600_read_byte(unsigned char type
, struct net_device
*dev
)
117 /* dev used by macros */
119 outb_p((type
), DATA_PORT
);
120 lo
= ((unsigned char)inb(STATUS_PORT
)) >> 4;
121 outb_p((type
) | HI_NIBBLE
, DATA_PORT
);
122 return ((unsigned char)inb(STATUS_PORT
) & (unsigned char)0xf0) | lo
;
126 * Open/initialize the board. This is called (in the current kernel)
127 * after booting when 'ifconfig <dev->name> $IP_ADDR' is run (in rc.inet1).
129 * This routine should set everything up anew at each open, even
130 * registers that "should" only need to be set once at boot, so that
131 * there is a non-reboot way to recover if something goes wrong.
134 static int de600_open(struct net_device
*dev
)
137 int ret
= request_irq(DE600_IRQ
, de600_interrupt
, 0, dev
->name
, dev
);
139 printk(KERN_ERR
"%s: unable to get IRQ %d\n", dev
->name
, DE600_IRQ
);
142 spin_lock_irqsave(&de600_lock
, flags
);
143 ret
= adapter_init(dev
);
144 spin_unlock_irqrestore(&de600_lock
, flags
);
149 * The inverse routine to de600_open().
152 static int de600_close(struct net_device
*dev
)
156 de600_put_command(RESET
);
157 de600_put_command(STOP_RESET
);
158 de600_put_command(0);
160 free_irq(DE600_IRQ
, dev
);
164 static struct net_device_stats
*get_stats(struct net_device
*dev
)
166 return (struct net_device_stats
*)(dev
->priv
);
169 static inline void trigger_interrupt(struct net_device
*dev
)
171 de600_put_command(FLIP_IRQ
);
175 de600_put_command(0);
179 * Copy a buffer to the adapter transmit page memory.
183 static int de600_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
189 u8
*buffer
= skb
->data
;
192 if (free_tx_pages
<= 0) { /* Do timeouts, to avoid hangs. */
193 tickssofar
= jiffies
- dev
->trans_start
;
197 printk(KERN_WARNING
"%s: transmit timed out (%d), %s?\n", dev
->name
, tickssofar
, "network cable problem");
198 /* Restart the adapter. */
199 spin_lock_irqsave(&de600_lock
, flags
);
200 if (adapter_init(dev
)) {
201 spin_unlock_irqrestore(&de600_lock
, flags
);
204 spin_unlock_irqrestore(&de600_lock
, flags
);
207 /* Start real output */
208 PRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb
->len
, tx_fifo_in
, free_tx_pages
));
210 if ((len
= skb
->len
) < RUNT
)
213 spin_lock_irqsave(&de600_lock
, flags
);
215 tx_fifo
[tx_fifo_in
] = transmit_from
= tx_page_adr(tx_fifo_in
) - len
;
216 tx_fifo_in
= (tx_fifo_in
+ 1) % TX_PAGES
; /* Next free tx page */
220 /* This costs about 40 instructions per packet... */
221 de600_setup_address(NODE_ADDRESS
, RW_ADDR
);
222 de600_read_byte(READ_DATA
, dev
);
223 if (was_down
|| (de600_read_byte(READ_DATA
, dev
) != 0xde)) {
224 if (adapter_init(dev
)) {
225 spin_unlock_irqrestore(&de600_lock
, flags
);
231 de600_setup_address(transmit_from
, RW_ADDR
);
232 for (i
= 0; i
< skb
->len
; ++i
, ++buffer
)
233 de600_put_byte(*buffer
);
237 if (free_tx_pages
-- == TX_PAGES
) { /* No transmission going on */
238 dev
->trans_start
= jiffies
;
239 netif_start_queue(dev
); /* allow more packets into adapter */
240 /* Send page and generate a faked interrupt */
241 de600_setup_address(transmit_from
, TX_ADDR
);
242 de600_put_command(TX_ENABLE
);
246 netif_start_queue(dev
);
248 netif_stop_queue(dev
);
251 spin_unlock_irqrestore(&de600_lock
, flags
);
257 * The typical workload of the driver:
258 * Handle the network interface interrupts.
261 static irqreturn_t
de600_interrupt(int irq
, void *dev_id
)
263 struct net_device
*dev
= dev_id
;
268 spin_lock(&de600_lock
);
271 irq_status
= de600_read_status(dev
);
274 PRINTK(("de600_interrupt (%02X)\n", irq_status
));
276 if (irq_status
& RX_GOOD
)
278 else if (!(irq_status
& RX_BUSY
))
279 de600_put_command(RX_ENABLE
);
281 /* Any transmission in progress? */
282 if (free_tx_pages
< TX_PAGES
)
283 retrig
= de600_tx_intr(dev
, irq_status
);
287 irq_status
= de600_read_status(dev
);
288 } while ( (irq_status
& RX_GOOD
) || ((++boguscount
< 100) && retrig
) );
290 * Yeah, it _looks_ like busy waiting, smells like busy waiting
291 * and I know it's not PC, but please, it will only occur once
292 * in a while and then only for a loop or so (< 1ms for sure!)
295 /* Enable adapter interrupts */
298 trigger_interrupt(dev
);
299 spin_unlock(&de600_lock
);
303 static int de600_tx_intr(struct net_device
*dev
, int irq_status
)
306 * Returns 1 if tx still not done
309 /* Check if current transmission is done yet */
310 if (irq_status
& TX_BUSY
)
311 return 1; /* tx not done, try again */
314 /* If last transmission OK then bump fifo index */
315 if (!(irq_status
& TX_FAILED16
)) {
316 tx_fifo_out
= (tx_fifo_out
+ 1) % TX_PAGES
;
318 ((struct net_device_stats
*)(dev
->priv
))->tx_packets
++;
319 netif_wake_queue(dev
);
322 /* More to send, or resend last packet? */
323 if ((free_tx_pages
< TX_PAGES
) || (irq_status
& TX_FAILED16
)) {
324 dev
->trans_start
= jiffies
;
325 de600_setup_address(tx_fifo
[tx_fifo_out
], TX_ADDR
);
326 de600_put_command(TX_ENABLE
);
335 * We have a good packet, get it out of the adapter.
337 static void de600_rx_intr(struct net_device
*dev
)
343 unsigned char *buffer
;
345 /* Get size of received packet */
346 size
= de600_read_byte(RX_LEN
, dev
); /* low byte */
347 size
+= (de600_read_byte(RX_LEN
, dev
) << 8); /* high byte */
348 size
-= 4; /* Ignore trailing 4 CRC-bytes */
350 /* Tell adapter where to store next incoming packet, enable receiver */
351 read_from
= rx_page_adr();
353 de600_put_command(RX_ENABLE
);
355 if ((size
< 32) || (size
> 1535)) {
356 printk(KERN_WARNING
"%s: Bogus packet size %d.\n", dev
->name
, size
);
362 skb
= dev_alloc_skb(size
+2);
364 printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev
->name
, size
);
370 skb_reserve(skb
,2); /* Align */
372 /* 'skb->data' points to the start of sk_buff data area. */
373 buffer
= skb_put(skb
,size
);
375 /* copy the packet into the buffer */
376 de600_setup_address(read_from
, RW_ADDR
);
377 for (i
= size
; i
> 0; --i
, ++buffer
)
378 *buffer
= de600_read_byte(READ_DATA
, dev
);
380 skb
->protocol
=eth_type_trans(skb
,dev
);
385 dev
->last_rx
= jiffies
;
386 ((struct net_device_stats
*)(dev
->priv
))->rx_packets
++; /* count all receives */
387 ((struct net_device_stats
*)(dev
->priv
))->rx_bytes
+= size
; /* count all received bytes */
390 * If any worth-while packets have been received, netif_rx()
391 * will work on them when we get to the tasklets.
395 static struct net_device
* __init
de600_probe(void)
398 struct net_device
*dev
;
401 dev
= alloc_etherdev(sizeof(struct net_device_stats
));
403 return ERR_PTR(-ENOMEM
);
405 SET_MODULE_OWNER(dev
);
407 if (!request_region(DE600_IO
, 3, "de600")) {
408 printk(KERN_WARNING
"DE600: port 0x%x busy\n", DE600_IO
);
413 printk(KERN_INFO
"%s: D-Link DE-600 pocket adapter", dev
->name
);
414 /* Alpha testers must have the version number to report bugs. */
418 /* probe for adapter */
422 (void)de600_read_status(dev
);
423 de600_put_command(RESET
);
424 de600_put_command(STOP_RESET
);
425 if (de600_read_status(dev
) & 0xf0) {
426 printk(": not at I/O %#3x.\n", DATA_PORT
);
431 * Maybe we found one,
432 * have to check if it is a D-Link DE-600 adapter...
435 /* Get the adapter ethernet address from the ROM */
436 de600_setup_address(NODE_ADDRESS
, RW_ADDR
);
437 for (i
= 0; i
< ETH_ALEN
; i
++) {
438 dev
->dev_addr
[i
] = de600_read_byte(READ_DATA
, dev
);
439 dev
->broadcast
[i
] = 0xff;
442 /* Check magic code */
443 if ((dev
->dev_addr
[1] == 0xde) && (dev
->dev_addr
[2] == 0x15)) {
444 /* OK, install real address */
445 dev
->dev_addr
[0] = 0x00;
446 dev
->dev_addr
[1] = 0x80;
447 dev
->dev_addr
[2] = 0xc8;
448 dev
->dev_addr
[3] &= 0x0f;
449 dev
->dev_addr
[3] |= 0x70;
451 printk(" not identified in the printer port\n");
455 printk(", Ethernet Address: %02X", dev
->dev_addr
[0]);
456 for (i
= 1; i
< ETH_ALEN
; i
++)
457 printk(":%02X",dev
->dev_addr
[i
]);
460 dev
->get_stats
= get_stats
;
462 dev
->open
= de600_open
;
463 dev
->stop
= de600_close
;
464 dev
->hard_start_xmit
= &de600_start_xmit
;
466 dev
->flags
&=~IFF_MULTICAST
;
470 err
= register_netdev(dev
);
477 release_region(DE600_IO
, 3);
483 static int adapter_init(struct net_device
*dev
)
488 rx_page
= 0; /* used by RESET */
489 de600_put_command(RESET
);
490 de600_put_command(STOP_RESET
);
492 /* Check if it is still there... */
493 /* Get the some bytes of the adapter ethernet address from the ROM */
494 de600_setup_address(NODE_ADDRESS
, RW_ADDR
);
495 de600_read_byte(READ_DATA
, dev
);
496 if ((de600_read_byte(READ_DATA
, dev
) != 0xde) ||
497 (de600_read_byte(READ_DATA
, dev
) != 0x15)) {
498 /* was: if (de600_read_status(dev) & 0xf0) { */
499 printk("Something has happened to the DE-600! Please check it and do a new ifconfig!\n");
500 /* Goodbye, cruel world... */
501 dev
->flags
&= ~IFF_UP
;
504 netif_stop_queue(dev
); /* Transmit busy... */
505 return 1; /* failed */
509 printk(KERN_INFO
"%s: Thanks, I feel much better now!\n", dev
->name
);
515 free_tx_pages
= TX_PAGES
;
518 /* set the ether address. */
519 de600_setup_address(NODE_ADDRESS
, RW_ADDR
);
520 for (i
= 0; i
< ETH_ALEN
; i
++)
521 de600_put_byte(dev
->dev_addr
[i
]);
523 /* where to start saving incoming packets */
524 rx_page
= RX_BP
| RX_BASE_PAGE
;
525 de600_setup_address(MEM_4K
, RW_ADDR
);
526 /* Enable receiver */
527 de600_put_command(RX_ENABLE
);
530 netif_start_queue(dev
);
535 static struct net_device
*de600_dev
;
537 static int __init
de600_init(void)
539 de600_dev
= de600_probe();
540 if (IS_ERR(de600_dev
))
541 return PTR_ERR(de600_dev
);
545 static void __exit
de600_exit(void)
547 unregister_netdev(de600_dev
);
548 release_region(DE600_IO
, 3);
549 free_netdev(de600_dev
);
552 module_init(de600_init
);
553 module_exit(de600_exit
);
555 MODULE_LICENSE("GPL");