1 /* mac8390.c: New driver for 8390-based Nubus (or Nubus-alike)
2 Ethernet cards on Linux */
3 /* Based on the former daynaport.c driver, by Alan Cox. Some code
4 taken from or inspired by skeleton.c by Donald Becker, acenic.c by
5 Jes Sorensen, and ne2k-pci.c by Donald Becker and Paul Gortmaker.
7 This software may be used and distributed according to the terms of
8 the GNU Public License, incorporated herein by reference. */
10 /* 2000-02-28: support added for Dayna and Kinetics cards by
11 A.G.deWijn@phys.uu.nl */
12 /* 2000-04-04: support added for Dayna2 by bart@etpmod.phys.tue.nl */
13 /* 2001-04-18: support for DaynaPort E/LC-M by rayk@knightsmanor.org */
14 /* 2001-05-15: support for Cabletron ported from old daynaport driver
15 * and fixed access to Sonic Sys card which masquerades as a Farallon
16 * by rayk@knightsmanor.org */
17 /* 2002-12-30: Try to support more cards, some clues from NetBSD driver */
18 /* 2003-12-26: Make sure Asante cards always work. */
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/types.h>
25 #include <linux/fcntl.h>
26 #include <linux/interrupt.h>
27 #include <linux/ptrace.h>
28 #include <linux/ioport.h>
29 #include <linux/nubus.h>
31 #include <linux/string.h>
32 #include <linux/errno.h>
33 #include <linux/init.h>
34 #include <linux/netdevice.h>
35 #include <linux/etherdevice.h>
36 #include <linux/skbuff.h>
37 #include <linux/bitops.h>
41 #include <asm/hwtest.h>
42 #include <asm/macints.h>
44 static char version
[] =
45 "v0.4 2001-05-15 David Huggins-Daines <dhd@debian.org> and others\n";
47 #define EI_SHIFT(x) (ei_local->reg_offset[x])
48 #define ei_inb(port) in_8(port)
49 #define ei_outb(val, port) out_8(port, val)
50 #define ei_inb_p(port) in_8(port)
51 #define ei_outb_p(val, port) out_8(port, val)
55 #define WD_START_PG 0x00 /* First page of TX buffer */
56 #define CABLETRON_RX_START_PG 0x00 /* First page of RX buffer */
57 #define CABLETRON_RX_STOP_PG 0x30 /* Last page +1 of RX ring */
58 #define CABLETRON_TX_START_PG CABLETRON_RX_STOP_PG
59 /* First page of TX buffer */
62 * Unfortunately it seems we have to hardcode these for the moment
63 * Shouldn't the card know about this?
64 * Does anyone know where to read it off the card?
65 * Do we trust the data provided by the card?
68 #define DAYNA_8390_BASE 0x80000
69 #define DAYNA_8390_MEM 0x00000
71 #define CABLETRON_8390_BASE 0x90000
72 #define CABLETRON_8390_MEM 0x00000
74 #define INTERLAN_8390_BASE 0xE0000
75 #define INTERLAN_8390_MEM 0xD0000
88 static const char *cardname
[] = {
98 static const int word16
[] = {
108 /* on which cards do we use NuBus resources? */
109 static const int useresources
[] = {
119 enum mac8390_access
{
125 extern int mac8390_memtest(struct net_device
*dev
);
126 static int mac8390_initdev(struct net_device
*dev
, struct nubus_dev
*ndev
,
127 enum mac8390_type type
);
129 static int mac8390_open(struct net_device
*dev
);
130 static int mac8390_close(struct net_device
*dev
);
131 static void mac8390_no_reset(struct net_device
*dev
);
132 static void interlan_reset(struct net_device
*dev
);
134 /* Sane (32-bit chunk memory read/write) - Some Farallon and Apple do this*/
135 static void sane_get_8390_hdr(struct net_device
*dev
,
136 struct e8390_pkt_hdr
*hdr
, int ring_page
);
137 static void sane_block_input(struct net_device
*dev
, int count
,
138 struct sk_buff
*skb
, int ring_offset
);
139 static void sane_block_output(struct net_device
*dev
, int count
,
140 const unsigned char *buf
, const int start_page
);
142 /* dayna_memcpy to and from card */
143 static void dayna_memcpy_fromcard(struct net_device
*dev
, void *to
,
144 int from
, int count
);
145 static void dayna_memcpy_tocard(struct net_device
*dev
, int to
,
146 const void *from
, int count
);
148 /* Dayna - Dayna/Kinetics use this */
149 static void dayna_get_8390_hdr(struct net_device
*dev
,
150 struct e8390_pkt_hdr
*hdr
, int ring_page
);
151 static void dayna_block_input(struct net_device
*dev
, int count
,
152 struct sk_buff
*skb
, int ring_offset
);
153 static void dayna_block_output(struct net_device
*dev
, int count
,
154 const unsigned char *buf
, int start_page
);
156 #define memcpy_fromio(a, b, c) memcpy((a), (void *)(b), (c))
157 #define memcpy_toio(a, b, c) memcpy((void *)(a), (b), (c))
159 #define memcmp_withio(a, b, c) memcmp((a), (void *)(b), (c))
161 /* Slow Sane (16-bit chunk memory read/write) Cabletron uses this */
162 static void slow_sane_get_8390_hdr(struct net_device
*dev
,
163 struct e8390_pkt_hdr
*hdr
, int ring_page
);
164 static void slow_sane_block_input(struct net_device
*dev
, int count
,
165 struct sk_buff
*skb
, int ring_offset
);
166 static void slow_sane_block_output(struct net_device
*dev
, int count
,
167 const unsigned char *buf
, int start_page
);
168 static void word_memcpy_tocard(unsigned long tp
, const void *fp
, int count
);
169 static void word_memcpy_fromcard(void *tp
, unsigned long fp
, int count
);
170 static u32 mac8390_msg_enable
;
172 static enum mac8390_type __init
mac8390_ident(struct nubus_dev
*dev
)
174 switch (dev
->dr_sw
) {
175 case NUBUS_DRSW_3COM
:
176 switch (dev
->dr_hw
) {
177 case NUBUS_DRHW_APPLE_SONIC_NB
:
178 case NUBUS_DRHW_APPLE_SONIC_LC
:
179 case NUBUS_DRHW_SONNET
:
182 return MAC8390_APPLE
;
186 case NUBUS_DRSW_APPLE
:
187 switch (dev
->dr_hw
) {
188 case NUBUS_DRHW_ASANTE_LC
:
190 case NUBUS_DRHW_CABLETRON
:
191 return MAC8390_CABLETRON
;
193 return MAC8390_APPLE
;
197 case NUBUS_DRSW_ASANTE
:
198 return MAC8390_ASANTE
;
201 case NUBUS_DRSW_TECHWORKS
:
202 case NUBUS_DRSW_DAYNA2
:
203 case NUBUS_DRSW_DAYNA_LC
:
204 if (dev
->dr_hw
== NUBUS_DRHW_CABLETRON
)
205 return MAC8390_CABLETRON
;
207 return MAC8390_APPLE
;
210 case NUBUS_DRSW_FARALLON
:
211 return MAC8390_FARALLON
;
214 case NUBUS_DRSW_KINETICS
:
215 switch (dev
->dr_hw
) {
216 case NUBUS_DRHW_INTERLAN
:
217 return MAC8390_INTERLAN
;
219 return MAC8390_KINETICS
;
223 case NUBUS_DRSW_DAYNA
:
225 * These correspond to Dayna Sonic cards
226 * which use the macsonic driver
228 if (dev
->dr_hw
== NUBUS_DRHW_SMC9194
||
229 dev
->dr_hw
== NUBUS_DRHW_INTERLAN
)
232 return MAC8390_DAYNA
;
238 static enum mac8390_access __init
mac8390_testio(volatile unsigned long membase
)
240 unsigned long outdata
= 0xA5A0B5B0;
241 unsigned long indata
= 0x00000000;
242 /* Try writing 32 bits */
243 memcpy_toio(membase
, &outdata
, 4);
244 /* Now compare them */
245 if (memcmp_withio(&outdata
, membase
, 4) == 0)
247 /* Write 16 bit output */
248 word_memcpy_tocard(membase
, &outdata
, 4);
249 /* Now read it back */
250 word_memcpy_fromcard(&indata
, membase
, 4);
251 if (outdata
== indata
)
253 return ACCESS_UNKNOWN
;
256 static int __init
mac8390_memsize(unsigned long membase
)
261 local_irq_save(flags
);
262 /* Check up to 32K in 4K increments */
263 for (i
= 0; i
< 8; i
++) {
264 volatile unsigned short *m
= (unsigned short *)(membase
+ (i
* 0x1000));
266 /* Unwriteable - we have a fully decoded card and the
268 if (hwreg_present(m
) == 0)
271 /* write a distinctive byte */
273 /* check that we read back what we wrote */
274 if (*m
!= (0xA5A0 | i
))
277 /* check for partial decode and wrap */
278 for (j
= 0; j
< i
; j
++) {
279 volatile unsigned short *p
= (unsigned short *)(membase
+ (j
* 0x1000));
280 if (*p
!= (0xA5A0 | j
))
284 local_irq_restore(flags
);
286 * in any case, we stopped once we tried one block too many,
287 * or once we reached 32K
292 static bool __init
mac8390_init(struct net_device
*dev
, struct nubus_dev
*ndev
,
293 enum mac8390_type cardtype
)
295 struct nubus_dir dir
;
296 struct nubus_dirent ent
;
298 volatile unsigned short *i
;
300 printk_once(KERN_INFO
pr_fmt("%s"), version
);
302 dev
->irq
= SLOT2IRQ(ndev
->board
->slot
);
303 /* This is getting to be a habit */
304 dev
->base_addr
= (ndev
->board
->slot_addr
|
305 ((ndev
->board
->slot
& 0xf) << 20));
308 * Get some Nubus info - we will trust the card's idea
309 * of where its memory and registers are.
312 if (nubus_get_func_dir(ndev
, &dir
) == -1) {
313 pr_err("%s: Unable to get Nubus functional directory for slot %X!\n",
314 dev
->name
, ndev
->board
->slot
);
318 /* Get the MAC address */
319 if (nubus_find_rsrc(&dir
, NUBUS_RESID_MAC_ADDRESS
, &ent
) == -1) {
320 pr_info("%s: Couldn't get MAC address!\n", dev
->name
);
324 nubus_get_rsrc_mem(dev
->dev_addr
, &ent
, 6);
326 if (useresources
[cardtype
] == 1) {
327 nubus_rewinddir(&dir
);
328 if (nubus_find_rsrc(&dir
, NUBUS_RESID_MINOR_BASEOS
,
330 pr_err("%s: Memory offset resource for slot %X not found!\n",
331 dev
->name
, ndev
->board
->slot
);
334 nubus_get_rsrc_mem(&offset
, &ent
, 4);
335 dev
->mem_start
= dev
->base_addr
+ offset
;
336 /* yes, this is how the Apple driver does it */
337 dev
->base_addr
= dev
->mem_start
+ 0x10000;
338 nubus_rewinddir(&dir
);
339 if (nubus_find_rsrc(&dir
, NUBUS_RESID_MINOR_LENGTH
,
341 pr_info("%s: Memory length resource for slot %X not found, probing\n",
342 dev
->name
, ndev
->board
->slot
);
343 offset
= mac8390_memsize(dev
->mem_start
);
345 nubus_get_rsrc_mem(&offset
, &ent
, 4);
347 dev
->mem_end
= dev
->mem_start
+ offset
;
350 case MAC8390_KINETICS
:
351 case MAC8390_DAYNA
: /* it's the same */
352 dev
->base_addr
= (int)(ndev
->board
->slot_addr
+
354 dev
->mem_start
= (int)(ndev
->board
->slot_addr
+
356 dev
->mem_end
= dev
->mem_start
+
357 mac8390_memsize(dev
->mem_start
);
359 case MAC8390_INTERLAN
:
360 dev
->base_addr
= (int)(ndev
->board
->slot_addr
+
362 dev
->mem_start
= (int)(ndev
->board
->slot_addr
+
364 dev
->mem_end
= dev
->mem_start
+
365 mac8390_memsize(dev
->mem_start
);
367 case MAC8390_CABLETRON
:
368 dev
->base_addr
= (int)(ndev
->board
->slot_addr
+
369 CABLETRON_8390_BASE
);
370 dev
->mem_start
= (int)(ndev
->board
->slot_addr
+
372 /* The base address is unreadable if 0x00
373 * has been written to the command register
374 * Reset the chip by writing E8390_NODMA +
375 * E8390_PAGE0 + E8390_STOP just to be
378 i
= (void *)dev
->base_addr
;
380 dev
->mem_end
= dev
->mem_start
+
381 mac8390_memsize(dev
->mem_start
);
385 pr_err("Card type %s is unsupported, sorry\n",
394 struct net_device
* __init
mac8390_probe(int unit
)
396 struct net_device
*dev
;
397 struct nubus_dev
*ndev
= NULL
;
399 struct ei_device
*ei_local
;
401 static unsigned int slots
;
403 enum mac8390_type cardtype
;
405 /* probably should check for Nubus instead */
408 return ERR_PTR(-ENODEV
);
410 dev
= ____alloc_ei_netdev(0);
412 return ERR_PTR(-ENOMEM
);
415 sprintf(dev
->name
, "eth%d", unit
);
417 while ((ndev
= nubus_find_type(NUBUS_CAT_NETWORK
, NUBUS_TYPE_ETHERNET
,
419 /* Have we seen it already? */
420 if (slots
& (1 << ndev
->board
->slot
))
422 slots
|= 1 << ndev
->board
->slot
;
424 cardtype
= mac8390_ident(ndev
);
425 if (cardtype
== MAC8390_NONE
)
428 if (!mac8390_init(dev
, ndev
, cardtype
))
431 /* Do the nasty 8390 stuff */
432 if (!mac8390_initdev(dev
, ndev
, cardtype
))
439 ei_local
= netdev_priv(dev
);
440 ei_local
->msg_enable
= mac8390_msg_enable
;
442 err
= register_netdev(dev
);
453 MODULE_AUTHOR("David Huggins-Daines <dhd@debian.org> and others");
454 MODULE_DESCRIPTION("Macintosh NS8390-based Nubus Ethernet driver");
455 MODULE_LICENSE("GPL");
457 /* overkill, of course */
458 static struct net_device
*dev_mac8390
[15];
459 int init_module(void)
462 for (i
= 0; i
< 15; i
++) {
463 struct net_device
*dev
= mac8390_probe(-1);
469 pr_notice("No useable cards found, driver NOT installed.\n");
475 void cleanup_module(void)
478 for (i
= 0; i
< 15; i
++) {
479 struct net_device
*dev
= dev_mac890
[i
];
481 unregister_netdev(dev
);
489 static const struct net_device_ops mac8390_netdev_ops
= {
490 .ndo_open
= mac8390_open
,
491 .ndo_stop
= mac8390_close
,
492 .ndo_start_xmit
= __ei_start_xmit
,
493 .ndo_tx_timeout
= __ei_tx_timeout
,
494 .ndo_get_stats
= __ei_get_stats
,
495 .ndo_set_rx_mode
= __ei_set_multicast_list
,
496 .ndo_validate_addr
= eth_validate_addr
,
497 .ndo_set_mac_address
= eth_mac_addr
,
498 .ndo_change_mtu
= eth_change_mtu
,
499 #ifdef CONFIG_NET_POLL_CONTROLLER
500 .ndo_poll_controller
= __ei_poll
,
504 static int __init
mac8390_initdev(struct net_device
*dev
,
505 struct nubus_dev
*ndev
,
506 enum mac8390_type type
)
508 static u32 fwrd4_offsets
[16] = {
514 static u32 back4_offsets
[16] = {
520 static u32 fwrd2_offsets
[16] = {
527 int access_bitmode
= 0;
529 /* Now fill in our stuff */
530 dev
->netdev_ops
= &mac8390_netdev_ops
;
532 /* GAR, ei_status is actually a macro even though it looks global */
533 ei_status
.name
= cardname
[type
];
534 ei_status
.word16
= word16
[type
];
536 /* Cabletron's TX/RX buffers are backwards */
537 if (type
== MAC8390_CABLETRON
) {
538 ei_status
.tx_start_page
= CABLETRON_TX_START_PG
;
539 ei_status
.rx_start_page
= CABLETRON_RX_START_PG
;
540 ei_status
.stop_page
= CABLETRON_RX_STOP_PG
;
541 ei_status
.rmem_start
= dev
->mem_start
;
542 ei_status
.rmem_end
= dev
->mem_start
+ CABLETRON_RX_STOP_PG
*256;
544 ei_status
.tx_start_page
= WD_START_PG
;
545 ei_status
.rx_start_page
= WD_START_PG
+ TX_PAGES
;
546 ei_status
.stop_page
= (dev
->mem_end
- dev
->mem_start
)/256;
547 ei_status
.rmem_start
= dev
->mem_start
+ TX_PAGES
*256;
548 ei_status
.rmem_end
= dev
->mem_end
;
551 /* Fill in model-specific information and functions */
553 case MAC8390_FARALLON
:
555 switch (mac8390_testio(dev
->mem_start
)) {
557 pr_err("Don't know how to access card memory!\n");
561 /* 16 bit card, register map is reversed */
562 ei_status
.reset_8390
= mac8390_no_reset
;
563 ei_status
.block_input
= slow_sane_block_input
;
564 ei_status
.block_output
= slow_sane_block_output
;
565 ei_status
.get_8390_hdr
= slow_sane_get_8390_hdr
;
566 ei_status
.reg_offset
= back4_offsets
;
570 /* 32 bit card, register map is reversed */
571 ei_status
.reset_8390
= mac8390_no_reset
;
572 ei_status
.block_input
= sane_block_input
;
573 ei_status
.block_output
= sane_block_output
;
574 ei_status
.get_8390_hdr
= sane_get_8390_hdr
;
575 ei_status
.reg_offset
= back4_offsets
;
582 /* Some Asante cards pass the 32 bit test
583 * but overwrite system memory when run at 32 bit.
584 * so we run them all at 16 bit.
586 ei_status
.reset_8390
= mac8390_no_reset
;
587 ei_status
.block_input
= slow_sane_block_input
;
588 ei_status
.block_output
= slow_sane_block_output
;
589 ei_status
.get_8390_hdr
= slow_sane_get_8390_hdr
;
590 ei_status
.reg_offset
= back4_offsets
;
593 case MAC8390_CABLETRON
:
594 /* 16 bit card, register map is short forward */
595 ei_status
.reset_8390
= mac8390_no_reset
;
596 ei_status
.block_input
= slow_sane_block_input
;
597 ei_status
.block_output
= slow_sane_block_output
;
598 ei_status
.get_8390_hdr
= slow_sane_get_8390_hdr
;
599 ei_status
.reg_offset
= fwrd2_offsets
;
603 case MAC8390_KINETICS
:
604 /* 16 bit memory, register map is forward */
605 /* dayna and similar */
606 ei_status
.reset_8390
= mac8390_no_reset
;
607 ei_status
.block_input
= dayna_block_input
;
608 ei_status
.block_output
= dayna_block_output
;
609 ei_status
.get_8390_hdr
= dayna_get_8390_hdr
;
610 ei_status
.reg_offset
= fwrd4_offsets
;
613 case MAC8390_INTERLAN
:
614 /* 16 bit memory, register map is forward */
615 ei_status
.reset_8390
= interlan_reset
;
616 ei_status
.block_input
= slow_sane_block_input
;
617 ei_status
.block_output
= slow_sane_block_output
;
618 ei_status
.get_8390_hdr
= slow_sane_get_8390_hdr
;
619 ei_status
.reg_offset
= fwrd4_offsets
;
623 pr_err("Card type %s is unsupported, sorry\n",
628 __NS8390_init(dev
, 0);
630 /* Good, done, now spit out some messages */
631 pr_info("%s: %s in slot %X (type %s)\n",
632 dev
->name
, ndev
->board
->name
, ndev
->board
->slot
,
634 pr_info("MAC %pM IRQ %d, %d KB shared memory at %#lx, %d-bit access.\n",
635 dev
->dev_addr
, dev
->irq
,
636 (unsigned int)(dev
->mem_end
- dev
->mem_start
) >> 10,
637 dev
->mem_start
, access_bitmode
? 32 : 16);
641 static int mac8390_open(struct net_device
*dev
)
646 err
= request_irq(dev
->irq
, __ei_interrupt
, 0, "8390 Ethernet", dev
);
648 pr_err("%s: unable to get IRQ %d\n", dev
->name
, dev
->irq
);
652 static int mac8390_close(struct net_device
*dev
)
654 free_irq(dev
->irq
, dev
);
659 static void mac8390_no_reset(struct net_device
*dev
)
661 struct ei_device
*ei_local
= netdev_priv(dev
);
664 netif_info(ei_local
, hw
, dev
, "reset not supported\n");
667 static void interlan_reset(struct net_device
*dev
)
669 unsigned char *target
= nubus_slot_addr(IRQ2SLOT(dev
->irq
));
670 struct ei_device
*ei_local
= netdev_priv(dev
);
672 netif_info(ei_local
, hw
, dev
, "Need to reset the NS8390 t=%lu...",
676 if (netif_msg_hw(ei_local
))
677 pr_cont("reset complete\n");
680 /* dayna_memcpy_fromio/dayna_memcpy_toio */
681 /* directly from daynaport.c by Alan Cox */
682 static void dayna_memcpy_fromcard(struct net_device
*dev
, void *to
, int from
,
685 volatile unsigned char *ptr
;
686 unsigned char *target
= to
;
687 from
<<= 1; /* word, skip overhead */
688 ptr
= (unsigned char *)(dev
->mem_start
+from
);
696 *(unsigned short *)target
= *(unsigned short volatile *)ptr
;
697 ptr
+= 4; /* skip cruft */
706 static void dayna_memcpy_tocard(struct net_device
*dev
, int to
,
707 const void *from
, int count
)
709 volatile unsigned short *ptr
;
710 const unsigned char *src
= from
;
711 to
<<= 1; /* word, skip overhead */
712 ptr
= (unsigned short *)(dev
->mem_start
+to
);
714 if (to
& 2) { /* avoid a byte write (stomps on other data) */
715 ptr
[-1] = (ptr
[-1]&0xFF00)|*src
++;
720 *ptr
++ = *(unsigned short *)src
; /* Copy and */
721 ptr
++; /* skip cruft */
727 /* card doesn't like byte writes */
728 *ptr
= (*ptr
& 0x00FF) | (*src
<< 8);
732 /* sane block input/output */
733 static void sane_get_8390_hdr(struct net_device
*dev
,
734 struct e8390_pkt_hdr
*hdr
, int ring_page
)
736 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
737 memcpy_fromio(hdr
, dev
->mem_start
+ hdr_start
, 4);
739 hdr
->count
= swab16(hdr
->count
);
742 static void sane_block_input(struct net_device
*dev
, int count
,
743 struct sk_buff
*skb
, int ring_offset
)
745 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
746 unsigned long xfer_start
= xfer_base
+ dev
->mem_start
;
748 if (xfer_start
+ count
> ei_status
.rmem_end
) {
749 /* We must wrap the input move. */
750 int semi_count
= ei_status
.rmem_end
- xfer_start
;
751 memcpy_fromio(skb
->data
, dev
->mem_start
+ xfer_base
,
754 memcpy_fromio(skb
->data
+ semi_count
, ei_status
.rmem_start
,
757 memcpy_fromio(skb
->data
, dev
->mem_start
+ xfer_base
, count
);
761 static void sane_block_output(struct net_device
*dev
, int count
,
762 const unsigned char *buf
, int start_page
)
764 long shmem
= (start_page
- WD_START_PG
)<<8;
766 memcpy_toio(dev
->mem_start
+ shmem
, buf
, count
);
769 /* dayna block input/output */
770 static void dayna_get_8390_hdr(struct net_device
*dev
,
771 struct e8390_pkt_hdr
*hdr
, int ring_page
)
773 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
775 dayna_memcpy_fromcard(dev
, hdr
, hdr_start
, 4);
777 hdr
->count
= (hdr
->count
& 0xFF) << 8 | (hdr
->count
>> 8);
780 static void dayna_block_input(struct net_device
*dev
, int count
,
781 struct sk_buff
*skb
, int ring_offset
)
783 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
784 unsigned long xfer_start
= xfer_base
+dev
->mem_start
;
786 /* Note the offset math is done in card memory space which is word
787 per long onto our space. */
789 if (xfer_start
+ count
> ei_status
.rmem_end
) {
790 /* We must wrap the input move. */
791 int semi_count
= ei_status
.rmem_end
- xfer_start
;
792 dayna_memcpy_fromcard(dev
, skb
->data
, xfer_base
, semi_count
);
794 dayna_memcpy_fromcard(dev
, skb
->data
+ semi_count
,
795 ei_status
.rmem_start
- dev
->mem_start
,
798 dayna_memcpy_fromcard(dev
, skb
->data
, xfer_base
, count
);
802 static void dayna_block_output(struct net_device
*dev
, int count
,
803 const unsigned char *buf
,
806 long shmem
= (start_page
- WD_START_PG
)<<8;
808 dayna_memcpy_tocard(dev
, shmem
, buf
, count
);
811 /* Cabletron block I/O */
812 static void slow_sane_get_8390_hdr(struct net_device
*dev
,
813 struct e8390_pkt_hdr
*hdr
,
816 unsigned long hdr_start
= (ring_page
- WD_START_PG
)<<8;
817 word_memcpy_fromcard(hdr
, dev
->mem_start
+ hdr_start
, 4);
818 /* Register endianism - fix here rather than 8390.c */
819 hdr
->count
= (hdr
->count
&0xFF)<<8|(hdr
->count
>>8);
822 static void slow_sane_block_input(struct net_device
*dev
, int count
,
823 struct sk_buff
*skb
, int ring_offset
)
825 unsigned long xfer_base
= ring_offset
- (WD_START_PG
<<8);
826 unsigned long xfer_start
= xfer_base
+dev
->mem_start
;
828 if (xfer_start
+ count
> ei_status
.rmem_end
) {
829 /* We must wrap the input move. */
830 int semi_count
= ei_status
.rmem_end
- xfer_start
;
831 word_memcpy_fromcard(skb
->data
, dev
->mem_start
+ xfer_base
,
834 word_memcpy_fromcard(skb
->data
+ semi_count
,
835 ei_status
.rmem_start
, count
);
837 word_memcpy_fromcard(skb
->data
, dev
->mem_start
+ xfer_base
,
842 static void slow_sane_block_output(struct net_device
*dev
, int count
,
843 const unsigned char *buf
, int start_page
)
845 long shmem
= (start_page
- WD_START_PG
)<<8;
847 word_memcpy_tocard(dev
->mem_start
+ shmem
, buf
, count
);
850 static void word_memcpy_tocard(unsigned long tp
, const void *fp
, int count
)
852 volatile unsigned short *to
= (void *)tp
;
853 const unsigned short *from
= fp
;
862 static void word_memcpy_fromcard(void *tp
, unsigned long fp
, int count
)
864 unsigned short *to
= tp
;
865 const volatile unsigned short *from
= (const void *)fp
;