1405 lines
34 KiB
C
1405 lines
34 KiB
C
/*
|
|
* Copyright 1998, Joerg Wunsch
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice unmodified, this list of conditions, and the following
|
|
* disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
/*
|
|
* Device driver for RealTek RTL 8002 (`REDP') based pocket-ethernet
|
|
* adapters, hooked up to a printer port. `rdp' is a shorthand for
|
|
* REDP since some tools like netstat work best if the interface name
|
|
* has no more than three letters.
|
|
*
|
|
* Driver configuration flags so far:
|
|
* flags 0x1 -- assume 74S288 EEPROM (default 94C46)
|
|
* flags 0x2 -- use `slow' mode (mode 3 of the packet driver, default 0)
|
|
*
|
|
* Maybe this driver will some day also work with the successor, RTL
|
|
* 8012 (`AREDP'), which is unfortunately not fully register-
|
|
* compatible with the 8002. The 8012 offers support for faster
|
|
* transfer modi like bidirectional SPP and EPP, 64 K x 4 buffer
|
|
* memory as opposed to 16 K x 4 for the 8002, a multicast filter, and
|
|
* a builtin multiplexer that allows chaining a printer behind the
|
|
* ethernet adapter.
|
|
*
|
|
* About the only documentation i've been able to find about the RTL
|
|
* 8002 was the packet driver source code at ftp.realtek.com.tw, so
|
|
* this driver is somewhat based on the way the packet driver handles
|
|
* the chip. The exact author of the packet driver is unknown, the
|
|
* only name that i could find in the source was someone called Chiu,
|
|
* supposedly an employee of RealTek. So credits to them for that
|
|
* piece of code which has proven valuable to me.
|
|
*
|
|
* Later on, Leo kuo <leo@realtek.com.tw> has been very helpful to me
|
|
* by sending me a readable (PDF) file documenting the RTL 8012, which
|
|
* helped me to also understand the 8002, as well as by providing me
|
|
* with the source code of the 8012 packet driver that i haven't been
|
|
* able to find on the FTP site. A big Thanks! goes here to RealTek
|
|
* for this kind of service.
|
|
*/
|
|
|
|
#include "rdp.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/sockio.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/bus.h>
|
|
|
|
#include <net/ethernet.h>
|
|
#include <net/if.h>
|
|
#include <net/if_arp.h>
|
|
#include <net/if_dl.h>
|
|
#include <net/if_mib.h>
|
|
|
|
#ifdef INET
|
|
#include <netinet/in.h>
|
|
#include <netinet/if_ether.h>
|
|
#endif
|
|
|
|
#ifdef NS
|
|
#include <netns/ns.h>
|
|
#include <netns/ns_if.h>
|
|
#endif
|
|
|
|
#include <net/bpf.h>
|
|
|
|
#include <machine/md_var.h>
|
|
|
|
#include <i386/isa/isa_device.h>
|
|
#include <i386/isa/icu.h>
|
|
#include <i386/isa/if_rdpreg.h>
|
|
#include <i386/isa/intr_machdep.h>
|
|
|
|
#ifndef COMPAT_OLDISA
|
|
#error "The rdp device requires the old isa compatibility shims"
|
|
#endif
|
|
|
|
#define IOCTL_CMD_T u_long
|
|
|
|
/*
|
|
* Debug levels (ORed together):
|
|
* != 0 - general (bad packets etc.)
|
|
* 2 - debug EEPROM IO
|
|
* 4 - debug interrupt status
|
|
*/
|
|
#undef DEBUG
|
|
#define DEBUG 0
|
|
|
|
/*
|
|
* rdp_softc: per interface info and status
|
|
*/
|
|
struct rdp_softc {
|
|
struct arpcom arpcom; /*
|
|
* Ethernet common, always goes first so
|
|
* a rdp_softc * can be cast into an
|
|
* arpcom * or into an ifnet *.
|
|
*/
|
|
|
|
/*
|
|
* local stuff, somewhat sorted by memory alignment class
|
|
*/
|
|
u_short baseaddr; /* IO port address */
|
|
u_short txsize; /* tx size for next (buffered) packet,
|
|
* there's only one additional packet
|
|
* we can buffer, thus a single variable
|
|
* ought to be enough */
|
|
int txbusy; /* tx is transmitting */
|
|
int txbuffered; /* # of packets in tx buffer */
|
|
int slow; /* use lpt_control to send data */
|
|
u_char irqenbit; /* mirror of current Ctrl_IRQEN */
|
|
/*
|
|
* type of parameter EEPROM; device flags 0x1 selects 74S288
|
|
*/
|
|
enum {
|
|
EEPROM_93C46, EEPROM_74S288 /* or 82S123 */
|
|
} eeprom;
|
|
};
|
|
|
|
static struct rdp_softc rdp_softc[NRDP];
|
|
|
|
/*
|
|
* Since there's no fixed location in the EEPROM about where to find
|
|
* the ethernet hardware address, we drop a table of valid OUIs here,
|
|
* and search through the EEPROM until we find a possible valid
|
|
* Ethernet address. Only the first 16 bits of all possible OUIs are
|
|
* recorded in the table (as obtained from
|
|
* http://standards.ieee.org/regauth/oui/oui.txt).
|
|
*/
|
|
|
|
static u_short allowed_ouis[] = {
|
|
0x0000, 0x0001, 0x0002, 0x0004, 0x0005, 0x0006, 0x0007,
|
|
0x0008, 0x0010, 0x001C, 0x0020, 0x0040, 0x0050, 0x0060,
|
|
0x0070, 0x0080, 0x0090, 0x009D, 0x00A0, 0x00AA, 0x00BB,
|
|
0x00C0, 0x00CF, 0x00DD, 0x00E0, 0x00E6, 0x0207, 0x021C,
|
|
0x0260, 0x0270, 0x029D, 0x02AA, 0x02BB, 0x02C0, 0x02CF,
|
|
0x02E6, 0x040A, 0x04E0, 0x0800, 0x08BB, 0x1000, 0x1100,
|
|
0x8000, 0xAA00
|
|
};
|
|
|
|
/*
|
|
* ISA bus support.
|
|
*/
|
|
static int rdp_probe(struct isa_device *);
|
|
static int rdp_attach(struct isa_device *);
|
|
|
|
/*
|
|
* Required entry points.
|
|
*/
|
|
static void rdp_init(void *);
|
|
static int rdp_ioctl(struct ifnet *, IOCTL_CMD_T, caddr_t);
|
|
static void rdp_start(struct ifnet *);
|
|
static void rdp_reset(struct ifnet *);
|
|
static void rdp_watchdog(struct ifnet *);
|
|
static void rdpintr(int);
|
|
|
|
/*
|
|
* REDP private functions.
|
|
*/
|
|
|
|
static void rdp_stop(struct rdp_softc *);
|
|
static void rdp_rint(struct rdp_softc *);
|
|
static void rdp_get_packet(struct rdp_softc *, unsigned);
|
|
static u_short rdp_write_mbufs(struct rdp_softc *, struct mbuf *);
|
|
static int rdp_gethwaddr_93c46(struct rdp_softc *, u_char *);
|
|
static void rdp_gethwaddr_74s288(struct rdp_softc *, u_char *);
|
|
static void rdp_93c46_cmd(struct rdp_softc *, u_short, unsigned);
|
|
static u_short rdp_93c46_read(struct rdp_softc *);
|
|
|
|
struct isa_driver rdpdriver = {
|
|
INTR_TYPE_NET,
|
|
rdp_probe,
|
|
rdp_attach,
|
|
"rdp",
|
|
1 /* we wanna get a chance before lptN */
|
|
};
|
|
COMPAT_ISA_DRIVER(rdp, rdpdriver);
|
|
|
|
/*
|
|
* REDP-specific functions.
|
|
*
|
|
* They are inlined, thus go first in this file. Together with gcc's
|
|
* usual optimization, these functions probably come close to the
|
|
* packet driver's hand-optimized code. ;-)
|
|
*
|
|
* Comments are partially obtained from the packet driver as well.
|
|
* Some of the function names contain register names which don't make
|
|
* much sense for us, but i've kept them for easier reference in
|
|
* comparision to the packet driver.
|
|
*
|
|
* Some of the functions are currently not used by the driver; it's
|
|
* not quite clear whether we ever need them at all. They are
|
|
* supposedly even slower than what is currently implemented as `slow'
|
|
* mode. Right now, `fast' (default) mode is what the packet driver
|
|
* calls mode 0, slow mode is mode 3 (writing through lpt_control,
|
|
* reading twice).
|
|
*
|
|
* We should autoprobe the modi, as opposed to making them dependent
|
|
* on a kernel configuration flag.
|
|
*/
|
|
|
|
/*
|
|
* read a nibble from rreg; end-of-data cmd is not issued;
|
|
* used for general register read.
|
|
*
|
|
* Unlike the packet driver's version, i'm shifting the result
|
|
* by 3 here (as opposed to within the caller's code) for clarity.
|
|
* -- Joerg
|
|
*/
|
|
static __inline u_char
|
|
RdNib(struct rdp_softc *sc, u_char rreg)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, EOC + rreg);
|
|
outb(sc->baseaddr + lpt_data, RdAddr + rreg); /* write addr */
|
|
(void)inb(sc->baseaddr + lpt_status);
|
|
return (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* read a byte from MAR register through lpt_data; the low nibble is
|
|
* read prior to the high one; end-of-read command is not issued; used
|
|
* for remote DMA in mode 4 + 5
|
|
*/
|
|
static __inline u_char
|
|
RdByte(struct rdp_softc *sc)
|
|
{
|
|
u_char hinib, lonib;
|
|
|
|
outb(sc->baseaddr + lpt_data, RdAddr + MAR); /* cmd for low nibble */
|
|
lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
|
|
outb(sc->baseaddr + lpt_data, RdAddr + MAR + HNib);
|
|
hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
|
|
return hinib + lonib;
|
|
}
|
|
|
|
|
|
/*
|
|
* read a byte from MAR register through lpt_data; the low nibble is
|
|
* read prior to the high one; end-of-read command is not issued; used
|
|
* for remote DMA in mode 6 + 7
|
|
*/
|
|
static __inline u_char
|
|
RdByte1(struct rdp_softc *sc)
|
|
{
|
|
u_char hinib, lonib;
|
|
|
|
outb(sc->baseaddr + lpt_data, RdAddr + MAR); /* cmd for low nibble */
|
|
(void)inb(sc->baseaddr + lpt_status);
|
|
lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
|
|
outb(sc->baseaddr + lpt_data, RdAddr + MAR + HNib);
|
|
(void)inb(sc->baseaddr + lpt_status);
|
|
hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
|
|
return hinib + lonib;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* read a byte from MAR register through lpt_control; the low nibble is
|
|
* read prior to the high one; end-of-read command is not issued; used
|
|
* for remote DMA in mode 0 + 1
|
|
*/
|
|
static __inline u_char
|
|
RdByteA1(struct rdp_softc *sc)
|
|
{
|
|
u_char hinib, lonib;
|
|
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
|
|
lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
|
|
outb(sc->baseaddr + lpt_control, Ctrl_HNibRead);
|
|
hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
|
|
return hinib + lonib;
|
|
}
|
|
|
|
|
|
/*
|
|
* read a byte from MAR register through lpt_control; the low nibble is
|
|
* read prior to the high one; end-of-read command is not issued; used
|
|
* for remote DMA in mode 2 + 3
|
|
*/
|
|
static __inline u_char
|
|
RdByteA2(struct rdp_softc *sc)
|
|
{
|
|
u_char hinib, lonib;
|
|
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
|
|
(void)inb(sc->baseaddr + lpt_status);
|
|
lonib = (inb(sc->baseaddr + lpt_status) >> 3) & 0x0f;
|
|
outb(sc->baseaddr + lpt_control, Ctrl_HNibRead);
|
|
(void)inb(sc->baseaddr + lpt_status);
|
|
hinib = (inb(sc->baseaddr + lpt_status) << 1) & 0xf0;
|
|
return hinib + lonib;
|
|
}
|
|
|
|
/*
|
|
* End-of-read cmd
|
|
*/
|
|
static __inline void
|
|
RdEnd(struct rdp_softc *sc, u_char rreg)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, EOC + rreg);
|
|
}
|
|
|
|
/*
|
|
* Write a nibble to a register; end-of-write is issued.
|
|
* Used for general register write.
|
|
*/
|
|
static __inline void
|
|
WrNib(struct rdp_softc *sc, u_char wreg, u_char wdata)
|
|
{
|
|
|
|
/* prepare and write address */
|
|
outb(sc->baseaddr + lpt_data, EOC + wreg);
|
|
outb(sc->baseaddr + lpt_data, WrAddr + wreg);
|
|
outb(sc->baseaddr + lpt_data, WrAddr + wreg);
|
|
/* prepare and write data */
|
|
outb(sc->baseaddr + lpt_data, WrAddr + wdata);
|
|
outb(sc->baseaddr + lpt_data, wdata);
|
|
outb(sc->baseaddr + lpt_data, wdata);
|
|
/* end-of-write */
|
|
outb(sc->baseaddr + lpt_data, EOC + wdata);
|
|
}
|
|
|
|
/*
|
|
* Write a byte to a register; end-of-write is issued.
|
|
* Used for general register write.
|
|
*/
|
|
static __inline void
|
|
WrByte(struct rdp_softc *sc, u_char wreg, u_char wdata)
|
|
{
|
|
|
|
/* prepare and write address */
|
|
outb(sc->baseaddr + lpt_data, EOC + wreg);
|
|
outb(sc->baseaddr + lpt_data, WrAddr + wreg);
|
|
outb(sc->baseaddr + lpt_data, WrAddr + wreg);
|
|
/* prepare and write low nibble */
|
|
outb(sc->baseaddr + lpt_data, WrAddr + (wdata & 0x0F));
|
|
outb(sc->baseaddr + lpt_data, (wdata & 0x0F));
|
|
outb(sc->baseaddr + lpt_data, (wdata & 0x0F));
|
|
/* prepare and write high nibble */
|
|
wdata >>= 4;
|
|
outb(sc->baseaddr + lpt_data, wdata);
|
|
outb(sc->baseaddr + lpt_data, wdata + HNib);
|
|
outb(sc->baseaddr + lpt_data, wdata + HNib);
|
|
/* end-of-write */
|
|
outb(sc->baseaddr + lpt_data, EOC + wdata + HNib);
|
|
}
|
|
|
|
/*
|
|
* Write the byte to DRAM via lpt_data;
|
|
* used for remote DMA write in mode 0 / 2 / 4
|
|
*/
|
|
static __inline void
|
|
WrByteALToDRAM(struct rdp_softc *sc, u_char val)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
outb(sc->baseaddr + lpt_data, MkHi(val));
|
|
}
|
|
|
|
/*
|
|
* Write the byte to DRAM via lpt_control;
|
|
* used for remote DMA write in mode 1 / 3 / 5
|
|
*/
|
|
static __inline void
|
|
WrByteALToDRAMA(struct rdp_softc *sc, u_char val)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
|
|
outb(sc->baseaddr + lpt_data, val >> 4);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
|
|
}
|
|
|
|
#if 0 /* they could be used for the RAM test */
|
|
/*
|
|
* Write the u_short to DRAM via lpt_data;
|
|
* used for remote DMA write in mode 0 / 2 / 4
|
|
*/
|
|
static __inline void
|
|
WrWordbxToDRAM(struct rdp_softc *sc, u_short val)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, (val & 0x0F) + HNib);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, val + HNib);
|
|
}
|
|
|
|
|
|
/*
|
|
* Write the u_short to DRAM via lpt_control;
|
|
* used for remote DMA write in mode 1 / 3 / 5
|
|
*/
|
|
static __inline void
|
|
WrWordbxToDRAMA(struct rdp_softc *sc, u_short val)
|
|
{
|
|
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, (val & 0x0F) + HNib);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, val & 0x0F);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead | sc->irqenbit);
|
|
val >>= 4;
|
|
outb(sc->baseaddr + lpt_data, val + HNib);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_HNibRead | sc->irqenbit);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Determine if the device is present
|
|
*
|
|
* on entry:
|
|
* a pointer to an isa_device struct
|
|
* on exit:
|
|
* 0 if device not found
|
|
* or # of i/o addresses used (if found)
|
|
*/
|
|
static int
|
|
rdp_probe(struct isa_device *isa_dev)
|
|
{
|
|
int unit = isa_dev->id_unit;
|
|
struct rdp_softc *sc = &rdp_softc[unit];
|
|
u_char b1, b2;
|
|
intrmask_t irqmap[3];
|
|
u_char sval[3];
|
|
|
|
if (unit < 0 || unit >= NRDP)
|
|
return 0;
|
|
|
|
sc->baseaddr = isa_dev->id_iobase;
|
|
if (isa_dev->id_flags & 1)
|
|
sc->eeprom = EEPROM_74S288;
|
|
/* else defaults to 93C46 */
|
|
if (isa_dev->id_flags & 2)
|
|
sc->slow = 1;
|
|
|
|
/* let R/WB = A/DB = CSB = high to be ready for next r/w cycle */
|
|
outb(sc->baseaddr + lpt_data, 0xFF);
|
|
/* DIR = 0 for write mode, IRQEN=0, SLCT=INIT=AUTOFEED=STB=high */
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
/* software reset */
|
|
WrNib(sc, CMR1 + HNib, MkHi(CMR1_RST));
|
|
DELAY(2000);
|
|
/* is EPLC alive? */
|
|
b1 = RdNib(sc, CMR1);
|
|
RdEnd(sc, CMR1);
|
|
b2 = RdNib(sc, CMR2) & 0x0f;
|
|
b2 |= RdNib(sc, CMR2 + HNib) << 4;
|
|
RdEnd(sc, CMR2 + HNib);
|
|
/*
|
|
* After the reset, we expect CMR1 & 7 to be 1 (rx buffer empty),
|
|
* and CMR2 & 0xf7 to be 0x20 (receive mode set to physical and
|
|
* broadcasts).
|
|
*/
|
|
if (bootverbose)
|
|
printf("rdp%d: CMR1 = %#x, CMR2 = %#x\n", unit, b1, b2);
|
|
|
|
if ((b1 & (CMR1_BUFE | CMR1_IRQ | CMR1_TRA)) != CMR1_BUFE
|
|
|| (b2 & ~CMR2_IRQINV) != CMR2_AM_PB)
|
|
return 0;
|
|
|
|
/*
|
|
* We have found something that could be a RTL 80[01]2, now
|
|
* see whether we can generate an interrupt.
|
|
*/
|
|
disable_intr();
|
|
|
|
/*
|
|
* Test whether our configured IRQ is working.
|
|
*
|
|
* Set to no acception mode + IRQout, then enable RxE + TxE,
|
|
* then cause RBER (by advancing the read pointer although
|
|
* the read buffer is empty) to generate an interrupt.
|
|
*/
|
|
WrByte(sc, CMR2, CMR2_IRQOUT);
|
|
WrNib(sc, CMR1 + HNib, MkHi(CMR1_TE | CMR1_RE));
|
|
WrNib(sc, CMR1, CMR1_RDPAC);
|
|
DELAY(1000);
|
|
|
|
irqmap[0] = isa_irq_pending();
|
|
sval[0] = inb(sc->baseaddr + lpt_status);
|
|
|
|
/* allow IRQs to pass the parallel interface */
|
|
outb(sc->baseaddr + lpt_control, Ctrl_IRQEN + Ctrl_SelData);
|
|
DELAY(1000);
|
|
/* generate interrupt */
|
|
WrNib(sc, IMR + HNib, MkHi(ISR_RBER));
|
|
DELAY(1000);
|
|
|
|
irqmap[1] = isa_irq_pending();
|
|
sval[1] = inb(sc->baseaddr + lpt_status);
|
|
|
|
/* de-assert and disable IRQ */
|
|
WrNib(sc, IMR + HNib, MkHi(0));
|
|
(void)inb(sc->baseaddr + lpt_status); /* might be necessary to
|
|
clear IRQ */
|
|
DELAY(1000);
|
|
irqmap[2] = isa_irq_pending();
|
|
sval[2] = inb(sc->baseaddr + lpt_status);
|
|
|
|
WrNib(sc, CMR1 + HNib, MkHi(0));
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
WrNib(sc, CMR2, CMR2_IRQINV);
|
|
|
|
enable_intr();
|
|
|
|
if (bootverbose)
|
|
printf("rdp%d: irq maps / lpt status "
|
|
"%#x/%#x - %#x/%#x - %#x/%#x (id_irq %#x)\n",
|
|
unit, irqmap[0], sval[0], irqmap[1], sval[1],
|
|
irqmap[2], sval[2], isa_dev->id_irq);
|
|
|
|
if ((irqmap[1] & isa_dev->id_irq) == 0) {
|
|
printf("rdp%d: configured IRQ (%d) cannot be asserted "
|
|
"by device",
|
|
unit, ffs(isa_dev->id_irq) - 1);
|
|
if (irqmap[1])
|
|
printf(" (probable IRQ: %d)", ffs(irqmap[1]) - 1);
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* XXX should do RAMtest here
|
|
*/
|
|
|
|
switch (sc->eeprom) {
|
|
case EEPROM_93C46:
|
|
if (rdp_gethwaddr_93c46(sc, sc->arpcom.ac_enaddr) == 0) {
|
|
printf("rdp%d: failed to find a valid hardware "
|
|
"address in EEPROM\n",
|
|
unit);
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case EEPROM_74S288:
|
|
rdp_gethwaddr_74s288(sc, sc->arpcom.ac_enaddr);
|
|
break;
|
|
}
|
|
|
|
return lpt_control + 1;
|
|
}
|
|
|
|
/*
|
|
* Install interface into kernel networking data structures
|
|
*/
|
|
static int
|
|
rdp_attach(struct isa_device *isa_dev)
|
|
{
|
|
int unit = isa_dev->id_unit;
|
|
struct rdp_softc *sc = &rdp_softc[unit];
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
|
|
isa_dev->id_ointr = rdpintr;
|
|
|
|
/*
|
|
* Reset interface
|
|
*/
|
|
rdp_stop(sc);
|
|
|
|
if (!ifp->if_name) {
|
|
/*
|
|
* Initialize ifnet structure
|
|
*/
|
|
ifp->if_softc = sc;
|
|
ifp->if_unit = unit;
|
|
ifp->if_name = "rdp";
|
|
ifp->if_start = rdp_start;
|
|
ifp->if_ioctl = rdp_ioctl;
|
|
ifp->if_watchdog = rdp_watchdog;
|
|
ifp->if_init = rdp_init;
|
|
ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
|
|
|
|
/*
|
|
* Attach the interface
|
|
*/
|
|
ether_ifattach(ifp, sc->arpcom.ac_enaddr);
|
|
}
|
|
|
|
/*
|
|
* Print additional info when attached
|
|
*/
|
|
if_printf(ifp, "RealTek RTL%s pocket ethernet, EEPROM %s, %s mode\n",
|
|
"8002", /* hook for 8012 */
|
|
sc->eeprom == EEPROM_93C46? "93C46": "74S288",
|
|
sc->slow? "slow": "fast");
|
|
if_printf(ifp, "address %6D\n", sc->arpcom.ac_enaddr, ":");
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Reset interface.
|
|
*/
|
|
static void
|
|
rdp_reset(struct ifnet *ifp)
|
|
{
|
|
struct rdp_softc *sc = ifp->if_softc;
|
|
int s;
|
|
|
|
s = splimp();
|
|
|
|
/*
|
|
* Stop interface and re-initialize.
|
|
*/
|
|
rdp_stop(sc);
|
|
rdp_init(sc);
|
|
|
|
(void) splx(s);
|
|
}
|
|
|
|
/*
|
|
* Take interface offline.
|
|
*/
|
|
static void
|
|
rdp_stop(struct rdp_softc *sc)
|
|
{
|
|
|
|
sc->txbusy = sc->txbusy = 0;
|
|
|
|
/* disable printer interface interrupts */
|
|
sc->irqenbit = 0;
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
outb(sc->baseaddr + lpt_data, 0xff);
|
|
|
|
/* reset the RTL 8002 */
|
|
WrNib(sc, CMR1 + HNib, MkHi(CMR1_RST));
|
|
DELAY(100);
|
|
}
|
|
|
|
/*
|
|
* Device timeout/watchdog routine. Entered if the device neglects to
|
|
* generate an interrupt after a transmit has been started on it.
|
|
*/
|
|
static void
|
|
rdp_watchdog(struct ifnet *ifp)
|
|
{
|
|
|
|
log(LOG_ERR, "rdp%d: device timeout\n", ifp->if_unit);
|
|
ifp->if_oerrors++;
|
|
|
|
rdp_reset(ifp);
|
|
}
|
|
|
|
/*
|
|
* Initialize device.
|
|
*/
|
|
static void
|
|
rdp_init(void *xsc)
|
|
{
|
|
struct rdp_softc *sc = xsc;
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
int i, s;
|
|
u_char reg;
|
|
|
|
/* address not known */
|
|
if (TAILQ_EMPTY(&ifp->if_addrhead))
|
|
return;
|
|
|
|
s = splimp();
|
|
|
|
ifp->if_timer = 0;
|
|
|
|
/* program ethernet ID into the chip */
|
|
for (i = 0, reg = IDR0; i < 6; i++, reg++)
|
|
WrByte(sc, reg, sc->arpcom.ac_enaddr[i]);
|
|
|
|
/* set accept mode */
|
|
WrNib(sc, CMR2 + HNib,
|
|
MkHi((ifp->if_flags & IFF_PROMISC)? CMR2_AM_ALL: CMR2_AM_PB));
|
|
|
|
/* enable tx and rx */
|
|
WrNib(sc, CMR1 + HNib, MkHi(CMR1_TE | CMR1_RE));
|
|
|
|
/* allow interrupts to happen */
|
|
WrNib(sc, CMR2, CMR2_IRQOUT | CMR2_IRQINV);
|
|
WrNib(sc, IMR, ISR_TOK | ISR_TER | ISR_ROK | ISR_RER);
|
|
WrNib(sc, IMR + HNib, MkHi(ISR_RBER));
|
|
|
|
/* allow IRQs to pass the parallel interface */
|
|
sc->irqenbit = Ctrl_IRQEN;
|
|
outb(sc->baseaddr + lpt_control, sc->irqenbit + Ctrl_SelData);
|
|
|
|
/* clear all flags */
|
|
sc->txbusy = sc->txbuffered = 0;
|
|
|
|
/*
|
|
* Set 'running' flag, and clear output active flag.
|
|
*/
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
/*
|
|
* ...and attempt to start output
|
|
*/
|
|
rdp_start(ifp);
|
|
|
|
(void) splx(s);
|
|
}
|
|
|
|
/*
|
|
* Start output on interface.
|
|
* We make two assumptions here:
|
|
* 1) that the current priority is set to splimp _before_ this code
|
|
* is called *and* is returned to the appropriate priority after
|
|
* return
|
|
* 2) that the IFF_OACTIVE flag is checked before this code is called
|
|
* (i.e. that the output part of the interface is idle)
|
|
*/
|
|
static void
|
|
rdp_start(struct ifnet *ifp)
|
|
{
|
|
struct rdp_softc *sc = ifp->if_softc;
|
|
struct mbuf *m;
|
|
int len;
|
|
|
|
outloop:
|
|
|
|
/*
|
|
* See if there is room to put another packet in the buffer.
|
|
*/
|
|
if (sc->txbuffered) {
|
|
/*
|
|
* No room. Indicate this to the outside world and exit.
|
|
*/
|
|
ifp->if_flags |= IFF_OACTIVE;
|
|
return;
|
|
}
|
|
IF_DEQUEUE(&ifp->if_snd, m);
|
|
if (m == 0) {
|
|
/*
|
|
* We are using the !OACTIVE flag to indicate to the outside
|
|
* world that we can accept an additional packet rather than
|
|
* that the transmitter is _actually_ active. Indeed, the
|
|
* transmitter may be active, but if we haven't filled all the
|
|
* buffers with data then we still want to accept more.
|
|
*/
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Copy the mbuf chain into the transmit buffer
|
|
*/
|
|
|
|
len = rdp_write_mbufs(sc, m);
|
|
if (len == 0)
|
|
goto outloop;
|
|
|
|
/* ensure minimal valid ethernet length */
|
|
len = max(len, (ETHER_MIN_LEN-ETHER_CRC_LEN));
|
|
|
|
/*
|
|
* Actually start the transceiver. Set a timeout in case the
|
|
* Tx interrupt never arrives.
|
|
*/
|
|
if (!sc->txbusy) {
|
|
WrNib(sc, TBCR1, len >> 8);
|
|
WrByte(sc, TBCR0, len & 0xff);
|
|
WrNib(sc, CMR1, CMR1_TRA);
|
|
sc->txbusy = 1;
|
|
ifp->if_timer = 2;
|
|
} else {
|
|
sc->txbuffered = 1;
|
|
sc->txsize = len;
|
|
}
|
|
|
|
/*
|
|
* Tap off here if there is a bpf listener.
|
|
*/
|
|
BPF_MTAP(ifp, m);
|
|
|
|
m_freem(m);
|
|
|
|
/*
|
|
* Loop back to the top to possibly buffer more packets
|
|
*/
|
|
goto outloop;
|
|
}
|
|
|
|
/*
|
|
* Process an ioctl request.
|
|
*/
|
|
static int
|
|
rdp_ioctl(struct ifnet *ifp, IOCTL_CMD_T command, caddr_t data)
|
|
{
|
|
struct rdp_softc *sc = ifp->if_softc;
|
|
int s, error = 0;
|
|
|
|
s = splimp();
|
|
|
|
switch (command) {
|
|
|
|
case SIOCSIFFLAGS:
|
|
/*
|
|
* If the interface is marked up and stopped, then start it.
|
|
* If it is marked down and running, then stop it.
|
|
*/
|
|
if (ifp->if_flags & IFF_UP) {
|
|
if ((ifp->if_flags & IFF_RUNNING) == 0)
|
|
rdp_init(sc);
|
|
} else {
|
|
if (ifp->if_flags & IFF_RUNNING) {
|
|
rdp_stop(sc);
|
|
ifp->if_flags &= ~IFF_RUNNING;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Promiscuous flag may have changed, propagage this
|
|
* to the NIC.
|
|
*/
|
|
if (ifp->if_flags & IFF_UP)
|
|
WrNib(sc, CMR2 + HNib,
|
|
MkHi((ifp->if_flags & IFF_PROMISC)?
|
|
CMR2_AM_ALL: CMR2_AM_PB));
|
|
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
case SIOCDELMULTI:
|
|
/*
|
|
* Multicast list has changed; we don't support it.
|
|
*/
|
|
error = ENOTTY;
|
|
break;
|
|
|
|
default:
|
|
error = ether_ioctl(ifp, command, data);
|
|
break;
|
|
}
|
|
(void) splx(s);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* External interrupt service routine.
|
|
*/
|
|
static void
|
|
rdpintr(int unit)
|
|
{
|
|
struct rdp_softc *sc = rdp_softc + unit;
|
|
struct ifnet *ifp = (struct ifnet *)sc;
|
|
u_char isr, tsr, rsr, colls;
|
|
|
|
/* disable interrupts, so SD3 can be routed to the pin */
|
|
sc->irqenbit = 0;
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
WrNib(sc, CMR2, CMR2_IRQINV);
|
|
/*
|
|
* loop until there are no more new interrupts
|
|
*/
|
|
for (;;) {
|
|
isr = RdNib(sc, ISR);
|
|
isr |= RdNib(sc, ISR + HNib) << 4;
|
|
RdEnd(sc, ISR + HNib);
|
|
|
|
if (isr == 0)
|
|
break;
|
|
#if DEBUG & 4
|
|
printf("rdp%d: ISR = %#x\n", unit, isr);
|
|
#endif
|
|
|
|
/*
|
|
* Clear the pending interrupt bits.
|
|
*/
|
|
WrNib(sc, ISR, isr & 0x0f);
|
|
if (isr & 0xf0)
|
|
WrNib(sc, ISR + HNib, MkHi(isr));
|
|
|
|
/*
|
|
* Handle transmitter interrupts.
|
|
*/
|
|
if (isr & (ISR_TOK | ISR_TER)) {
|
|
tsr = RdNib(sc, TSR);
|
|
RdEnd(sc, TSR);
|
|
#if DEBUG & 4
|
|
if (isr & ISR_TER)
|
|
printf("rdp%d: tsr %#x\n", unit, tsr);
|
|
#endif
|
|
if (tsr & TSR_TABT)
|
|
ifp->if_oerrors++;
|
|
else
|
|
/*
|
|
* Update total number of successfully
|
|
* transmitted packets.
|
|
*/
|
|
ifp->if_opackets++;
|
|
|
|
if (tsr & TSR_COL) {
|
|
colls = RdNib(sc, COLR);
|
|
RdEnd(sc, COLR);
|
|
ifp->if_collisions += colls;
|
|
}
|
|
|
|
/*
|
|
* reset tx busy and output active flags
|
|
*/
|
|
sc->txbusy = 0;
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
/*
|
|
* If we had already queued up another packet,
|
|
* start sending it now.
|
|
*/
|
|
if (sc->txbuffered) {
|
|
WrNib(sc, TBCR1, sc->txsize >> 8);
|
|
WrByte(sc, TBCR0, sc->txsize & 0xff);
|
|
WrNib(sc, CMR1, CMR1_TRA);
|
|
sc->txbusy = 1;
|
|
sc->txbuffered = 0;
|
|
ifp->if_timer = 2;
|
|
} else {
|
|
/*
|
|
* clear watchdog timer
|
|
*/
|
|
ifp->if_timer = 0;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Handle receiver interrupts
|
|
*/
|
|
if (isr & (ISR_ROK | ISR_RER | ISR_RBER)) {
|
|
rsr = RdNib(sc, RSR);
|
|
rsr |= RdNib(sc, RSR + HNib) << 4;
|
|
RdEnd(sc, RSR + HNib);
|
|
#if DEBUG & 4
|
|
if (isr & (ISR_RER | ISR_RBER))
|
|
printf("rdp%d: rsr %#x\n", unit, rsr);
|
|
#endif
|
|
|
|
if (rsr & (RSR_PUN | RSR_POV)) {
|
|
printf("rdp%d: rsr %#x, resetting\n",
|
|
unit, rsr);
|
|
rdp_reset(ifp);
|
|
break;
|
|
}
|
|
|
|
if (rsr & RSR_BUFO)
|
|
/*
|
|
* CRC and FA errors are recorded in
|
|
* rdp_rint() on a per-packet basis
|
|
*/
|
|
ifp->if_ierrors++;
|
|
if (isr & (ISR_ROK | ISR_RER))
|
|
rdp_rint(sc);
|
|
}
|
|
|
|
/*
|
|
* If it looks like the transmitter can take more data,
|
|
* attempt to start output on the interface. This is done
|
|
* after handling the receiver to give the receiver priority.
|
|
*/
|
|
if ((ifp->if_flags & IFF_OACTIVE) == 0)
|
|
rdp_start(ifp);
|
|
|
|
}
|
|
/* re-enable interrupts */
|
|
WrNib(sc, CMR2, CMR2_IRQOUT | CMR2_IRQINV);
|
|
sc->irqenbit = Ctrl_IRQEN;
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData + sc->irqenbit);
|
|
}
|
|
|
|
/*
|
|
* Ethernet interface receiver interrupt.
|
|
*/
|
|
static void
|
|
rdp_rint(struct rdp_softc *sc)
|
|
{
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
struct rdphdr rh;
|
|
u_short len;
|
|
size_t i;
|
|
u_char *packet_ptr, b, status;
|
|
int excessive_bad_pkts = 0;
|
|
|
|
/*
|
|
* Fetch the packets from the NIC's buffer.
|
|
*/
|
|
for (;;) {
|
|
b = RdNib(sc, CMR1);
|
|
RdEnd(sc, CMR1);
|
|
|
|
if (b & CMR1_BUFE)
|
|
/* no more packets */
|
|
break;
|
|
|
|
/* first, obtain the buffer header */
|
|
|
|
outb(sc->baseaddr + lpt_data, MAR + EOC); /* prepare addr */
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
|
|
outb(sc->baseaddr + lpt_data, MAR + RdAddr + HNib);
|
|
|
|
packet_ptr = (u_char *)&rh;
|
|
if (sc->slow)
|
|
for (i = 0; i < sizeof rh; i++, packet_ptr++)
|
|
*packet_ptr = RdByteA2(sc);
|
|
else
|
|
for (i = 0; i < sizeof rh; i++, packet_ptr++)
|
|
*packet_ptr = RdByteA1(sc);
|
|
|
|
RdEnd(sc, MAR + HNib);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
|
|
len = rh.pktlen - ETHER_CRC_LEN;
|
|
status = rh.status;
|
|
|
|
if ((status & (RSR_ROK | RSR_CRC | RSR_FA)) != RSR_ROK ||
|
|
len > (ETHER_MAX_LEN - ETHER_CRC_LEN) ||
|
|
len < (ETHER_MIN_LEN - ETHER_CRC_LEN) ||
|
|
len > MCLBYTES) {
|
|
#if DEBUG
|
|
if_printf(ifp, "bad packet in buffer, "
|
|
"len %d, status %#x\n",
|
|
(int)len, (int)status);
|
|
#endif
|
|
ifp->if_ierrors++;
|
|
/* rx jump packet */
|
|
WrNib(sc, CMR1, CMR1_RDPAC);
|
|
if (++excessive_bad_pkts > 5) {
|
|
/*
|
|
* the chip seems to be stuck, we are
|
|
* probably seeing the same bad packet
|
|
* over and over again
|
|
*/
|
|
#if DEBUG
|
|
if_printf(ifp, "resetting due to an "
|
|
"excessive number of bad packets\n");
|
|
#endif
|
|
rdp_reset(ifp);
|
|
return;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Go get packet.
|
|
*/
|
|
excessive_bad_pkts = 0;
|
|
rdp_get_packet(sc, len);
|
|
ifp->if_ipackets++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Retreive packet from NIC memory and send to the next level up via
|
|
* ether_input().
|
|
*/
|
|
static void
|
|
rdp_get_packet(struct rdp_softc *sc, unsigned len)
|
|
{
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
struct mbuf *m;
|
|
u_char *packet_ptr;
|
|
size_t s;
|
|
|
|
/* Allocate a header mbuf */
|
|
MGETHDR(m, M_NOWAIT, MT_DATA);
|
|
if (m == NULL)
|
|
return;
|
|
m->m_pkthdr.rcvif = ifp;
|
|
m->m_pkthdr.len = m->m_len = len;
|
|
|
|
/*
|
|
* We always put the received packet in a single buffer -
|
|
* either with just an mbuf header or in a cluster attached
|
|
* to the header. The +2 is to compensate for the alignment
|
|
* fixup below.
|
|
*/
|
|
if ((len + ETHER_ALIGN) > MHLEN) {
|
|
/* Attach an mbuf cluster */
|
|
MCLGET(m, M_NOWAIT);
|
|
|
|
/* Insist on getting a cluster */
|
|
if ((m->m_flags & M_EXT) == 0) {
|
|
m_freem(m);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The +2 is to longword align the start of the real packet.
|
|
* This is important for NFS.
|
|
*/
|
|
m->m_data += ETHER_ALIGN;
|
|
|
|
/*
|
|
* Get packet, including link layer address, from interface.
|
|
*/
|
|
outb(sc->baseaddr + lpt_control, Ctrl_LNibRead);
|
|
outb(sc->baseaddr + lpt_data, RdAddr + MAR);
|
|
|
|
packet_ptr = mtod(m, u_char *);
|
|
if (sc->slow)
|
|
for (s = 0; s < len; s++, packet_ptr++)
|
|
*packet_ptr = RdByteA2(sc);
|
|
else
|
|
for (s = 0; s < len; s++, packet_ptr++)
|
|
*packet_ptr = RdByteA1(sc);
|
|
|
|
RdEnd(sc, MAR + HNib);
|
|
outb(sc->baseaddr + lpt_control, Ctrl_SelData);
|
|
WrNib(sc, CMR1, CMR1_RDPAC);
|
|
|
|
(*ifp->if_input)(ifp, m);
|
|
}
|
|
|
|
/*
|
|
* Write an mbuf chain to the NIC's tx buffer.
|
|
*/
|
|
static u_short
|
|
rdp_write_mbufs(struct rdp_softc *sc, struct mbuf *m)
|
|
{
|
|
u_short total_len;
|
|
struct mbuf *mp;
|
|
u_char *dp, b;
|
|
int i;
|
|
|
|
/* First, count up the total number of bytes to copy */
|
|
for (total_len = 0, mp = m; mp; mp = mp->m_next)
|
|
total_len += mp->m_len;
|
|
|
|
if (total_len == 0)
|
|
return 0;
|
|
|
|
outb(sc->baseaddr + lpt_data, MAR | EOC);
|
|
|
|
/*
|
|
* Transfer the mbuf chain to the NIC memory.
|
|
*/
|
|
if (sc->slow) {
|
|
/* writing the first byte is complicated */
|
|
outb(sc->baseaddr + lpt_control,
|
|
Ctrl_LNibRead | sc->irqenbit);
|
|
outb(sc->baseaddr + lpt_data, MAR | WrAddr);
|
|
b = *(u_char *)m->m_data;
|
|
outb(sc->baseaddr + lpt_data, (b & 0x0f) | 0x40);
|
|
outb(sc->baseaddr + lpt_data, b & 0x0f);
|
|
outb(sc->baseaddr + lpt_data, b >> 4);
|
|
outb(sc->baseaddr + lpt_control,
|
|
Ctrl_HNibRead | sc->irqenbit);
|
|
/* advance the mbuf pointer */
|
|
mp = m;
|
|
m->m_len--;
|
|
m->m_data++;
|
|
/* write the remaining bytes */
|
|
while (m) {
|
|
for (i = 0, dp = (u_char *)m->m_data;
|
|
i < m->m_len;
|
|
i++, dp++)
|
|
WrByteALToDRAMA(sc, *dp);
|
|
m = m->m_next;
|
|
}
|
|
/*
|
|
* restore old mbuf in case we have to hand it off to
|
|
* BPF again
|
|
*/
|
|
m = mp;
|
|
m->m_len++;
|
|
m->m_data--;
|
|
|
|
/* the RTL 8002 requires an even byte-count remote DMA */
|
|
if (total_len & 1)
|
|
WrByteALToDRAMA(sc, 0);
|
|
} else {
|
|
outb(sc->baseaddr + lpt_data, MAR | WrAddr);
|
|
while (m) {
|
|
for (i = 0, dp = (u_char *)m->m_data;
|
|
i < m->m_len;
|
|
i++, dp++)
|
|
WrByteALToDRAM(sc, *dp);
|
|
m = m->m_next;
|
|
}
|
|
|
|
/* the RTL 8002 requires an even byte-count remote DMA */
|
|
if (total_len & 1)
|
|
WrByteALToDRAM(sc, 0);
|
|
}
|
|
|
|
outb(sc->baseaddr + lpt_data, 0xff);
|
|
outb(sc->baseaddr + lpt_control,
|
|
Ctrl_HNibRead | Ctrl_SelData | sc->irqenbit);
|
|
|
|
return total_len;
|
|
}
|
|
|
|
/*
|
|
* Read the designated ethernet hardware address out of a 93C46
|
|
* (serial) EEPROM.
|
|
* Note that the 93C46 uses 16-bit words in big-endian notation.
|
|
*/
|
|
static int
|
|
rdp_gethwaddr_93c46(struct rdp_softc *sc, u_char *etheraddr)
|
|
{
|
|
int i, magic;
|
|
size_t j = 0;
|
|
u_short w;
|
|
|
|
WrNib(sc, CMR2, CMR2_PAGE | CMR2_IRQINV); /* select page 1 */
|
|
|
|
/*
|
|
* The original RealTek packet driver had the ethernet address
|
|
* starting at EEPROM address 0. Other vendors seem to have
|
|
* gone `creative' here -- while they didn't do anything else
|
|
* than changing a few strings in the entire driver, compared
|
|
* to the RealTek version, they also moved out the ethernet
|
|
* address to a different location in the EEPROM, so the
|
|
* original RealTek driver won't work correctly with them, and
|
|
* vice versa. Sounds pretty cool, eh? $@%&!
|
|
*
|
|
* Anyway, we walk through the EEPROM, until we find some
|
|
* allowable value based upon our table of IEEE OUI assignments.
|
|
*/
|
|
for (i = magic = 0; magic < 3 && i < 32; i++) {
|
|
/* read cmd (+ 6 bit address) */
|
|
rdp_93c46_cmd(sc, 0x180 + i, 10);
|
|
w = rdp_93c46_read(sc);
|
|
switch (magic) {
|
|
case 0:
|
|
for (j = 0;
|
|
j < sizeof allowed_ouis / sizeof(u_short);
|
|
j++)
|
|
if (w == allowed_ouis[j]) {
|
|
etheraddr[0] = (w >> 8) & 0xff;
|
|
etheraddr[1] = w & 0xff;
|
|
magic++;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
/*
|
|
* If the first two bytes have been 00:00, we
|
|
* discard the match iff the next two bytes
|
|
* are also 00:00, so we won't get fooled by
|
|
* an EEPROM that has been filled with zeros.
|
|
* This in theory would disallow 64 K of legal
|
|
* addresses assigned to Xerox, but it's
|
|
* almost certain that those addresses haven't
|
|
* been used for RTL80[01]2 chips anyway.
|
|
*/
|
|
if ((etheraddr[0] | etheraddr[1]) == 0 && w == 0) {
|
|
magic--;
|
|
break;
|
|
}
|
|
|
|
etheraddr[2] = (w >> 8) & 0xff;
|
|
etheraddr[3] = w & 0xff;
|
|
magic++;
|
|
break;
|
|
|
|
case 2:
|
|
etheraddr[4] = (w >> 8) & 0xff;
|
|
etheraddr[5] = w & 0xff;
|
|
magic++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
WrNib(sc, CMR2, CMR2_IRQINV); /* back to page 0 */
|
|
|
|
return magic == 3;
|
|
}
|
|
|
|
/*
|
|
* Read the designated ethernet hardware address out of a 74S288
|
|
* EEPROM.
|
|
*
|
|
* This is untested, since i haven't seen any adapter actually using
|
|
* a 74S288. In the RTL 8012, only the serial EEPROM (94C46) is
|
|
* supported anymore.
|
|
*/
|
|
static void
|
|
rdp_gethwaddr_74s288(struct rdp_softc *sc, u_char *etheraddr)
|
|
{
|
|
int i;
|
|
u_char b;
|
|
|
|
WrNib(sc, CMR2, CMR2_PAGE | CMR2_IRQINV); /* select page 1 */
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
WrNib(sc, PCMR, i & 0x0f); /* lower 4 bit of addr */
|
|
WrNib(sc, PCMR + HNib, HNib + 4); /* upper 2 bit addr + /CS */
|
|
WrNib(sc, PCMR + HNib, HNib); /* latch data now */
|
|
b = RdNib(sc, PDR) & 0x0f;
|
|
b |= (RdNib(sc, PDR + HNib) & 0x0f) << 4;
|
|
etheraddr[i] = b;
|
|
}
|
|
|
|
RdEnd(sc, PDR + HNib);
|
|
WrNib(sc, CMR2, CMR2_IRQINV); /* reselect page 0 */
|
|
}
|
|
|
|
/*
|
|
* Send nbits of data (starting with MSB) out to the 93c46 as a
|
|
* command. Assumes register page 1 has already been selected.
|
|
*/
|
|
static void
|
|
rdp_93c46_cmd(struct rdp_softc *sc, u_short data, unsigned nbits)
|
|
{
|
|
u_short mask = 1 << (nbits - 1);
|
|
unsigned i;
|
|
u_char b;
|
|
|
|
#if DEBUG & 2
|
|
printf("rdp_93c46_cmd(): ");
|
|
#endif
|
|
for (i = 0; i < nbits; i++, mask >>= 1) {
|
|
b = HNib + PCMR_SK + PCMR_CS;
|
|
if (data & mask)
|
|
b += PCMR_DO;
|
|
#if DEBUG & 2
|
|
printf("%d", b & 1);
|
|
#endif
|
|
WrNib(sc, PCMR + HNib, b);
|
|
DELAY(1);
|
|
WrNib(sc, PCMR + HNib, b & ~PCMR_SK);
|
|
DELAY(1);
|
|
}
|
|
#if DEBUG & 2
|
|
printf("\n");
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Read one word of data from the 93c46. Actually, we have to read
|
|
* 17 bits, and discard the very first bit. Assumes register page 1
|
|
* to be selected as well.
|
|
*/
|
|
static u_short
|
|
rdp_93c46_read(struct rdp_softc *sc)
|
|
{
|
|
u_short data = 0;
|
|
u_char b;
|
|
int i;
|
|
|
|
#if DEBUG & 2
|
|
printf("rdp_93c46_read(): ");
|
|
#endif
|
|
for (i = 0; i < 17; i++) {
|
|
WrNib(sc, PCMR + HNib, PCMR_SK + PCMR_CS + HNib);
|
|
DELAY(1);
|
|
WrNib(sc, PCMR + HNib, PCMR_CS + HNib);
|
|
DELAY(1);
|
|
b = RdNib(sc, PDR);
|
|
data <<= 1;
|
|
if (b & 1)
|
|
data |= 1;
|
|
#if DEBUG & 2
|
|
printf("%d", b & 1);
|
|
#endif
|
|
RdEnd(sc, PDR);
|
|
DELAY(1);
|
|
}
|
|
|
|
#if DEBUG & 2
|
|
printf("\n");
|
|
#endif
|
|
/* end of cycle */
|
|
WrNib(sc, PCMR + HNib, PCMR_SK + HNib);
|
|
DELAY(1);
|
|
|
|
return data;
|
|
}
|