1278 lines
30 KiB
C
1278 lines
30 KiB
C
/*-
|
|
* Copyright (c) 1997-2001 Granch, Ltd. All rights reserved.
|
|
* Author: Denis I.Timofeev <timofeev@granch.ru>
|
|
*
|
|
* Redistributon 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 NEIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* Device driver for Granch SBNI12 leased line adapters
|
|
*
|
|
* Revision 2.0.0 1997/08/06
|
|
* Initial revision by Alexey Zverev
|
|
*
|
|
* Revision 2.0.1 1997/08/11
|
|
* Additional internal statistics support (tx statistics)
|
|
*
|
|
* Revision 2.0.2 1997/11/05
|
|
* if_bpf bug has been fixed
|
|
*
|
|
* Revision 2.0.3 1998/12/20
|
|
* Memory leakage has been eliminated in
|
|
* the sbni_st and sbni_timeout routines.
|
|
*
|
|
* Revision 3.0 2000/08/10 by Yaroslav Polyakov
|
|
* Support for PCI cards. 4.1 modification.
|
|
*
|
|
* Revision 3.1 2000/09/12
|
|
* Removed extra #defines around bpf functions
|
|
*
|
|
* Revision 4.0 2000/11/23 by Denis Timofeev
|
|
* Completely redesigned the buffer management
|
|
*
|
|
* Revision 4.1 2001/01/21
|
|
* Support for PCI Dual cards and new SBNI12D-10, -11 Dual/ISA cards
|
|
*
|
|
* Written with reference to NE2000 driver developed by David Greenman.
|
|
*/
|
|
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/sockio.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/priv.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/callout.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/random.h>
|
|
|
|
#include <machine/bus.h>
|
|
#include <sys/rman.h>
|
|
#include <machine/resource.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_var.h>
|
|
#include <net/if_dl.h>
|
|
#include <net/ethernet.h>
|
|
#include <net/bpf.h>
|
|
#include <net/if_types.h>
|
|
|
|
#include <dev/sbni/if_sbnireg.h>
|
|
#include <dev/sbni/if_sbnivar.h>
|
|
|
|
static void sbni_init(void *);
|
|
static void sbni_init_locked(struct sbni_softc *);
|
|
static void sbni_start(struct ifnet *);
|
|
static void sbni_start_locked(struct ifnet *);
|
|
static int sbni_ioctl(struct ifnet *, u_long, caddr_t);
|
|
static void sbni_stop(struct sbni_softc *);
|
|
static void handle_channel(struct sbni_softc *);
|
|
|
|
static void card_start(struct sbni_softc *);
|
|
static int recv_frame(struct sbni_softc *);
|
|
static void send_frame(struct sbni_softc *);
|
|
static int upload_data(struct sbni_softc *, u_int, u_int, u_int, u_int32_t);
|
|
static int skip_tail(struct sbni_softc *, u_int, u_int32_t);
|
|
static void interpret_ack(struct sbni_softc *, u_int);
|
|
static void download_data(struct sbni_softc *, u_int32_t *);
|
|
static void prepare_to_send(struct sbni_softc *);
|
|
static void drop_xmit_queue(struct sbni_softc *);
|
|
static int get_rx_buf(struct sbni_softc *);
|
|
static void indicate_pkt(struct sbni_softc *);
|
|
static void change_level(struct sbni_softc *);
|
|
static int check_fhdr(struct sbni_softc *, u_int *, u_int *,
|
|
u_int *, u_int *, u_int32_t *);
|
|
static int append_frame_to_pkt(struct sbni_softc *, u_int, u_int32_t);
|
|
static void timeout_change_level(struct sbni_softc *);
|
|
static void send_frame_header(struct sbni_softc *, u_int32_t *);
|
|
static void set_initial_values(struct sbni_softc *, struct sbni_flags);
|
|
|
|
static u_int32_t calc_crc32(u_int32_t, caddr_t, u_int);
|
|
static timeout_t sbni_timeout;
|
|
|
|
static __inline u_char sbni_inb(struct sbni_softc *, enum sbni_reg);
|
|
static __inline void sbni_outb(struct sbni_softc *, enum sbni_reg, u_char);
|
|
static __inline void sbni_insb(struct sbni_softc *, u_char *, u_int);
|
|
static __inline void sbni_outsb(struct sbni_softc *, u_char *, u_int);
|
|
|
|
static u_int32_t crc32tab[];
|
|
|
|
#ifdef SBNI_DUAL_COMPOUND
|
|
static struct mtx headlist_lock;
|
|
MTX_SYSINIT(headlist_lock, &headlist_lock, "sbni headlist", MTX_DEF);
|
|
static struct sbni_softc *sbni_headlist;
|
|
#endif
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static __inline u_char
|
|
sbni_inb(struct sbni_softc *sc, enum sbni_reg reg)
|
|
{
|
|
return bus_space_read_1(
|
|
rman_get_bustag(sc->io_res),
|
|
rman_get_bushandle(sc->io_res),
|
|
sc->io_off + reg);
|
|
}
|
|
|
|
static __inline void
|
|
sbni_outb(struct sbni_softc *sc, enum sbni_reg reg, u_char value)
|
|
{
|
|
bus_space_write_1(
|
|
rman_get_bustag(sc->io_res),
|
|
rman_get_bushandle(sc->io_res),
|
|
sc->io_off + reg, value);
|
|
}
|
|
|
|
static __inline void
|
|
sbni_insb(struct sbni_softc *sc, u_char *to, u_int len)
|
|
{
|
|
bus_space_read_multi_1(
|
|
rman_get_bustag(sc->io_res),
|
|
rman_get_bushandle(sc->io_res),
|
|
sc->io_off + DAT, to, len);
|
|
}
|
|
|
|
static __inline void
|
|
sbni_outsb(struct sbni_softc *sc, u_char *from, u_int len)
|
|
{
|
|
bus_space_write_multi_1(
|
|
rman_get_bustag(sc->io_res),
|
|
rman_get_bushandle(sc->io_res),
|
|
sc->io_off + DAT, from, len);
|
|
}
|
|
|
|
|
|
/*
|
|
Valid combinations in CSR0 (for probing):
|
|
|
|
VALID_DECODER 0000,0011,1011,1010
|
|
|
|
; 0 ; -
|
|
TR_REQ ; 1 ; +
|
|
TR_RDY ; 2 ; -
|
|
TR_RDY TR_REQ ; 3 ; +
|
|
BU_EMP ; 4 ; +
|
|
BU_EMP TR_REQ ; 5 ; +
|
|
BU_EMP TR_RDY ; 6 ; -
|
|
BU_EMP TR_RDY TR_REQ ; 7 ; +
|
|
RC_RDY ; 8 ; +
|
|
RC_RDY TR_REQ ; 9 ; +
|
|
RC_RDY TR_RDY ; 10 ; -
|
|
RC_RDY TR_RDY TR_REQ ; 11 ; -
|
|
RC_RDY BU_EMP ; 12 ; -
|
|
RC_RDY BU_EMP TR_REQ ; 13 ; -
|
|
RC_RDY BU_EMP TR_RDY ; 14 ; -
|
|
RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
|
|
*/
|
|
|
|
#define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
|
|
|
|
|
|
int
|
|
sbni_probe(struct sbni_softc *sc)
|
|
{
|
|
u_char csr0;
|
|
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
if (csr0 != 0xff && csr0 != 0x00) {
|
|
csr0 &= ~EN_INT;
|
|
if (csr0 & BU_EMP)
|
|
csr0 |= EN_INT;
|
|
|
|
if (VALID_DECODER & (1 << (csr0 >> 4)))
|
|
return (0);
|
|
}
|
|
|
|
return (ENXIO);
|
|
}
|
|
|
|
|
|
/*
|
|
* Install interface into kernel networking data structures
|
|
*/
|
|
int
|
|
sbni_attach(struct sbni_softc *sc, int unit, struct sbni_flags flags)
|
|
{
|
|
struct ifnet *ifp;
|
|
u_char csr0;
|
|
|
|
ifp = sc->ifp = if_alloc(IFT_ETHER);
|
|
if (ifp == NULL)
|
|
return (ENOMEM);
|
|
sbni_outb(sc, CSR0, 0);
|
|
set_initial_values(sc, flags);
|
|
|
|
/* Initialize ifnet structure */
|
|
ifp->if_softc = sc;
|
|
if_initname(ifp, "sbni", unit);
|
|
ifp->if_init = sbni_init;
|
|
ifp->if_start = sbni_start;
|
|
ifp->if_ioctl = sbni_ioctl;
|
|
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
|
|
|
|
/* report real baud rate */
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
ifp->if_baudrate =
|
|
(csr0 & 0x01 ? 500000 : 2000000) / (1 << flags.rate);
|
|
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
|
|
|
|
mtx_init(&sc->lock, ifp->if_xname, MTX_NETWORK_LOCK, MTX_DEF);
|
|
callout_init_mtx(&sc->wch, &sc->lock, 0);
|
|
ether_ifattach(ifp, sc->enaddr);
|
|
/* device attach does transition from UNCONFIGURED to IDLE state */
|
|
|
|
if_printf(ifp, "speed %ju, rxl ", (uintmax_t)ifp->if_baudrate);
|
|
if (sc->delta_rxl)
|
|
printf("auto\n");
|
|
else
|
|
printf("%d (fixed)\n", sc->cur_rxl_index);
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
sbni_detach(struct sbni_softc *sc)
|
|
{
|
|
|
|
SBNI_LOCK(sc);
|
|
sbni_stop(sc);
|
|
SBNI_UNLOCK(sc);
|
|
callout_drain(&sc->wch);
|
|
ether_ifdetach(sc->ifp);
|
|
if (sc->irq_handle)
|
|
bus_teardown_intr(sc->dev, sc->irq_res, sc->irq_handle);
|
|
mtx_destroy(&sc->lock);
|
|
if_free(sc->ifp);
|
|
}
|
|
|
|
void
|
|
sbni_release_resources(struct sbni_softc *sc)
|
|
{
|
|
|
|
if (sc->irq_res)
|
|
bus_release_resource(sc->dev, SYS_RES_IRQ, sc->irq_rid,
|
|
sc->irq_res);
|
|
if (sc->io_res && sc->io_off == 0)
|
|
bus_release_resource(sc->dev, SYS_RES_IOPORT, sc->io_rid,
|
|
sc->io_res);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static void
|
|
sbni_init(void *xsc)
|
|
{
|
|
struct sbni_softc *sc;
|
|
|
|
sc = (struct sbni_softc *)xsc;
|
|
SBNI_LOCK(sc);
|
|
sbni_init_locked(sc);
|
|
SBNI_UNLOCK(sc);
|
|
}
|
|
|
|
static void
|
|
sbni_init_locked(struct sbni_softc *sc)
|
|
{
|
|
struct ifnet *ifp;
|
|
|
|
ifp = sc->ifp;
|
|
|
|
/*
|
|
* kludge to avoid multiple initialization when more than once
|
|
* protocols configured
|
|
*/
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING)
|
|
return;
|
|
|
|
card_start(sc);
|
|
callout_reset(&sc->wch, hz/SBNI_HZ, sbni_timeout, sc);
|
|
|
|
ifp->if_drv_flags |= IFF_DRV_RUNNING;
|
|
ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
|
|
|
|
/* attempt to start output */
|
|
sbni_start_locked(ifp);
|
|
}
|
|
|
|
static void
|
|
sbni_start(struct ifnet *ifp)
|
|
{
|
|
struct sbni_softc *sc = ifp->if_softc;
|
|
|
|
SBNI_LOCK(sc);
|
|
sbni_start_locked(ifp);
|
|
SBNI_UNLOCK(sc);
|
|
}
|
|
|
|
static void
|
|
sbni_start_locked(struct ifnet *ifp)
|
|
{
|
|
struct sbni_softc *sc = ifp->if_softc;
|
|
|
|
if (sc->tx_frameno == 0)
|
|
prepare_to_send(sc);
|
|
}
|
|
|
|
|
|
static void
|
|
sbni_stop(struct sbni_softc *sc)
|
|
{
|
|
sbni_outb(sc, CSR0, 0);
|
|
drop_xmit_queue(sc);
|
|
|
|
if (sc->rx_buf_p) {
|
|
m_freem(sc->rx_buf_p);
|
|
sc->rx_buf_p = NULL;
|
|
}
|
|
|
|
callout_stop(&sc->wch);
|
|
sc->ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/* interrupt handler */
|
|
|
|
/*
|
|
* SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
|
|
* be looked as two independent single-channel devices. Every channel seems
|
|
* as Ethernet interface but interrupt handler must be common. Really, first
|
|
* channel ("master") driver only registers the handler. In it's struct softc
|
|
* it has got pointer to "slave" channel's struct softc and handles that's
|
|
* interrupts too.
|
|
* softc of successfully attached ISA SBNI boards is linked to list.
|
|
* While next board driver is initialized, it scans this list. If one
|
|
* has found softc with same irq and ioaddr different by 4 then it assumes
|
|
* this board to be "master".
|
|
*/
|
|
|
|
void
|
|
sbni_intr(void *arg)
|
|
{
|
|
struct sbni_softc *sc;
|
|
int repeat;
|
|
|
|
sc = (struct sbni_softc *)arg;
|
|
|
|
do {
|
|
repeat = 0;
|
|
SBNI_LOCK(sc);
|
|
if (sbni_inb(sc, CSR0) & (RC_RDY | TR_RDY)) {
|
|
handle_channel(sc);
|
|
repeat = 1;
|
|
}
|
|
SBNI_UNLOCK(sc);
|
|
if (sc->slave_sc) {
|
|
/* second channel present */
|
|
SBNI_LOCK(sc->slave_sc);
|
|
if (sbni_inb(sc->slave_sc, CSR0) & (RC_RDY | TR_RDY)) {
|
|
handle_channel(sc->slave_sc);
|
|
repeat = 1;
|
|
}
|
|
SBNI_UNLOCK(sc->slave_sc);
|
|
}
|
|
} while (repeat);
|
|
}
|
|
|
|
|
|
static void
|
|
handle_channel(struct sbni_softc *sc)
|
|
{
|
|
int req_ans;
|
|
u_char csr0;
|
|
|
|
sbni_outb(sc, CSR0, (sbni_inb(sc, CSR0) & ~EN_INT) | TR_REQ);
|
|
|
|
sc->timer_ticks = CHANGE_LEVEL_START_TICKS;
|
|
for (;;) {
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
if ((csr0 & (RC_RDY | TR_RDY)) == 0)
|
|
break;
|
|
|
|
req_ans = !(sc->state & FL_PREV_OK);
|
|
|
|
if (csr0 & RC_RDY)
|
|
req_ans = recv_frame(sc);
|
|
|
|
/*
|
|
* TR_RDY always equals 1 here because we have owned the marker,
|
|
* and we set TR_REQ when disabled interrupts
|
|
*/
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
if ((csr0 & TR_RDY) == 0 || (csr0 & RC_RDY) != 0)
|
|
if_printf(sc->ifp, "internal error!\n");
|
|
|
|
/* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
|
|
if (req_ans || sc->tx_frameno != 0)
|
|
send_frame(sc);
|
|
else {
|
|
/* send the marker without any data */
|
|
sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) & ~TR_REQ);
|
|
}
|
|
}
|
|
|
|
sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) | EN_INT);
|
|
}
|
|
|
|
|
|
/*
|
|
* Routine returns 1 if it need to acknoweledge received frame.
|
|
* Empty frame received without errors won't be acknoweledged.
|
|
*/
|
|
|
|
static int
|
|
recv_frame(struct sbni_softc *sc)
|
|
{
|
|
u_int32_t crc;
|
|
u_int framelen, frameno, ack;
|
|
u_int is_first, frame_ok;
|
|
|
|
crc = CRC32_INITIAL;
|
|
if (check_fhdr(sc, &framelen, &frameno, &ack, &is_first, &crc)) {
|
|
frame_ok = framelen > 4 ?
|
|
upload_data(sc, framelen, frameno, is_first, crc) :
|
|
skip_tail(sc, framelen, crc);
|
|
if (frame_ok)
|
|
interpret_ack(sc, ack);
|
|
} else {
|
|
framelen = 0;
|
|
frame_ok = 0;
|
|
}
|
|
|
|
sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) ^ CT_ZER);
|
|
if (frame_ok) {
|
|
sc->state |= FL_PREV_OK;
|
|
if (framelen > 4)
|
|
sc->in_stats.all_rx_number++;
|
|
} else {
|
|
sc->state &= ~FL_PREV_OK;
|
|
change_level(sc);
|
|
sc->in_stats.all_rx_number++;
|
|
sc->in_stats.bad_rx_number++;
|
|
}
|
|
|
|
return (!frame_ok || framelen > 4);
|
|
}
|
|
|
|
|
|
static void
|
|
send_frame(struct sbni_softc *sc)
|
|
{
|
|
u_int32_t crc;
|
|
u_char csr0;
|
|
|
|
crc = CRC32_INITIAL;
|
|
if (sc->state & FL_NEED_RESEND) {
|
|
|
|
/* if frame was sended but not ACK'ed - resend it */
|
|
if (sc->trans_errors) {
|
|
sc->trans_errors--;
|
|
if (sc->framelen != 0)
|
|
sc->in_stats.resend_tx_number++;
|
|
} else {
|
|
/* cannot xmit with many attempts */
|
|
drop_xmit_queue(sc);
|
|
goto do_send;
|
|
}
|
|
} else
|
|
sc->trans_errors = TR_ERROR_COUNT;
|
|
|
|
send_frame_header(sc, &crc);
|
|
sc->state |= FL_NEED_RESEND;
|
|
/*
|
|
* FL_NEED_RESEND will be cleared after ACK, but if empty
|
|
* frame sended then in prepare_to_send next frame
|
|
*/
|
|
|
|
|
|
if (sc->framelen) {
|
|
download_data(sc, &crc);
|
|
sc->in_stats.all_tx_number++;
|
|
sc->state |= FL_WAIT_ACK;
|
|
}
|
|
|
|
sbni_outsb(sc, (u_char *)&crc, sizeof crc);
|
|
|
|
do_send:
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
sbni_outb(sc, CSR0, csr0 & ~TR_REQ);
|
|
|
|
if (sc->tx_frameno) {
|
|
/* next frame exists - request to send */
|
|
sbni_outb(sc, CSR0, csr0 | TR_REQ);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
download_data(struct sbni_softc *sc, u_int32_t *crc_p)
|
|
{
|
|
struct mbuf *m;
|
|
caddr_t data_p;
|
|
u_int data_len, pos, slice;
|
|
|
|
data_p = NULL; /* initialized to avoid warn */
|
|
pos = 0;
|
|
|
|
for (m = sc->tx_buf_p; m != NULL && pos < sc->pktlen; m = m->m_next) {
|
|
if (pos + m->m_len > sc->outpos) {
|
|
data_len = m->m_len - (sc->outpos - pos);
|
|
data_p = mtod(m, caddr_t) + (sc->outpos - pos);
|
|
|
|
goto do_copy;
|
|
} else
|
|
pos += m->m_len;
|
|
}
|
|
|
|
data_len = 0;
|
|
|
|
do_copy:
|
|
pos = 0;
|
|
do {
|
|
if (data_len) {
|
|
slice = min(data_len, sc->framelen - pos);
|
|
sbni_outsb(sc, data_p, slice);
|
|
*crc_p = calc_crc32(*crc_p, data_p, slice);
|
|
|
|
pos += slice;
|
|
if (data_len -= slice)
|
|
data_p += slice;
|
|
else {
|
|
do {
|
|
m = m->m_next;
|
|
} while (m != NULL && m->m_len == 0);
|
|
|
|
if (m) {
|
|
data_len = m->m_len;
|
|
data_p = mtod(m, caddr_t);
|
|
}
|
|
}
|
|
} else {
|
|
/* frame too short - zero padding */
|
|
|
|
pos = sc->framelen - pos;
|
|
while (pos--) {
|
|
sbni_outb(sc, DAT, 0);
|
|
*crc_p = CRC32(0, *crc_p);
|
|
}
|
|
return;
|
|
}
|
|
} while (pos < sc->framelen);
|
|
}
|
|
|
|
|
|
static int
|
|
upload_data(struct sbni_softc *sc, u_int framelen, u_int frameno,
|
|
u_int is_first, u_int32_t crc)
|
|
{
|
|
int frame_ok;
|
|
|
|
if (is_first) {
|
|
sc->wait_frameno = frameno;
|
|
sc->inppos = 0;
|
|
}
|
|
|
|
if (sc->wait_frameno == frameno) {
|
|
|
|
if (sc->inppos + framelen <= ETHER_MAX_LEN) {
|
|
frame_ok = append_frame_to_pkt(sc, framelen, crc);
|
|
|
|
/*
|
|
* if CRC is right but framelen incorrect then transmitter
|
|
* error was occurred... drop entire packet
|
|
*/
|
|
} else if ((frame_ok = skip_tail(sc, framelen, crc)) != 0) {
|
|
sc->wait_frameno = 0;
|
|
sc->inppos = 0;
|
|
if_inc_counter(sc->ifp, IFCOUNTER_IERRORS, 1);
|
|
/* now skip all frames until is_first != 0 */
|
|
}
|
|
} else
|
|
frame_ok = skip_tail(sc, framelen, crc);
|
|
|
|
if (is_first && !frame_ok) {
|
|
/*
|
|
* Frame has been violated, but we have stored
|
|
* is_first already... Drop entire packet.
|
|
*/
|
|
sc->wait_frameno = 0;
|
|
if_inc_counter(sc->ifp, IFCOUNTER_IERRORS, 1);
|
|
}
|
|
|
|
return (frame_ok);
|
|
}
|
|
|
|
|
|
static __inline void send_complete(struct sbni_softc *);
|
|
|
|
static __inline void
|
|
send_complete(struct sbni_softc *sc)
|
|
{
|
|
m_freem(sc->tx_buf_p);
|
|
sc->tx_buf_p = NULL;
|
|
if_inc_counter(sc->ifp, IFCOUNTER_OPACKETS, 1);
|
|
}
|
|
|
|
|
|
static void
|
|
interpret_ack(struct sbni_softc *sc, u_int ack)
|
|
{
|
|
if (ack == FRAME_SENT_OK) {
|
|
sc->state &= ~FL_NEED_RESEND;
|
|
|
|
if (sc->state & FL_WAIT_ACK) {
|
|
sc->outpos += sc->framelen;
|
|
|
|
if (--sc->tx_frameno) {
|
|
sc->framelen = min(
|
|
sc->maxframe, sc->pktlen - sc->outpos);
|
|
} else {
|
|
send_complete(sc);
|
|
prepare_to_send(sc);
|
|
}
|
|
}
|
|
}
|
|
|
|
sc->state &= ~FL_WAIT_ACK;
|
|
}
|
|
|
|
|
|
/*
|
|
* Glue received frame with previous fragments of packet.
|
|
* Indicate packet when last frame would be accepted.
|
|
*/
|
|
|
|
static int
|
|
append_frame_to_pkt(struct sbni_softc *sc, u_int framelen, u_int32_t crc)
|
|
{
|
|
caddr_t p;
|
|
|
|
if (sc->inppos + framelen > ETHER_MAX_LEN)
|
|
return (0);
|
|
|
|
if (!sc->rx_buf_p && !get_rx_buf(sc))
|
|
return (0);
|
|
|
|
p = sc->rx_buf_p->m_data + sc->inppos;
|
|
sbni_insb(sc, p, framelen);
|
|
if (calc_crc32(crc, p, framelen) != CRC32_REMAINDER)
|
|
return (0);
|
|
|
|
sc->inppos += framelen - 4;
|
|
if (--sc->wait_frameno == 0) { /* last frame received */
|
|
indicate_pkt(sc);
|
|
if_inc_counter(sc->ifp, IFCOUNTER_IPACKETS, 1);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*
|
|
* Prepare to start output on adapter. Current priority must be set to splimp
|
|
* before this routine is called.
|
|
* Transmitter will be actually activated when marker has been accepted.
|
|
*/
|
|
|
|
static void
|
|
prepare_to_send(struct sbni_softc *sc)
|
|
{
|
|
struct mbuf *m;
|
|
u_int len;
|
|
|
|
/* sc->tx_buf_p == NULL here! */
|
|
if (sc->tx_buf_p)
|
|
printf("sbni: memory leak!\n");
|
|
|
|
sc->outpos = 0;
|
|
sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
|
|
|
|
for (;;) {
|
|
IF_DEQUEUE(&sc->ifp->if_snd, sc->tx_buf_p);
|
|
if (!sc->tx_buf_p) {
|
|
/* nothing to transmit... */
|
|
sc->pktlen = 0;
|
|
sc->tx_frameno = 0;
|
|
sc->framelen = 0;
|
|
sc->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
|
|
return;
|
|
}
|
|
|
|
for (len = 0, m = sc->tx_buf_p; m; m = m->m_next)
|
|
len += m->m_len;
|
|
|
|
if (len != 0)
|
|
break;
|
|
m_freem(sc->tx_buf_p);
|
|
}
|
|
|
|
if (len < SBNI_MIN_LEN)
|
|
len = SBNI_MIN_LEN;
|
|
|
|
sc->pktlen = len;
|
|
sc->tx_frameno = howmany(len, sc->maxframe);
|
|
sc->framelen = min(len, sc->maxframe);
|
|
|
|
sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) | TR_REQ);
|
|
sc->ifp->if_drv_flags |= IFF_DRV_OACTIVE;
|
|
BPF_MTAP(sc->ifp, sc->tx_buf_p);
|
|
}
|
|
|
|
|
|
static void
|
|
drop_xmit_queue(struct sbni_softc *sc)
|
|
{
|
|
struct mbuf *m;
|
|
|
|
if (sc->tx_buf_p) {
|
|
m_freem(sc->tx_buf_p);
|
|
sc->tx_buf_p = NULL;
|
|
if_inc_counter(sc->ifp, IFCOUNTER_OERRORS, 1);
|
|
}
|
|
|
|
for (;;) {
|
|
IF_DEQUEUE(&sc->ifp->if_snd, m);
|
|
if (m == NULL)
|
|
break;
|
|
m_freem(m);
|
|
if_inc_counter(sc->ifp, IFCOUNTER_OERRORS, 1);
|
|
}
|
|
|
|
sc->tx_frameno = 0;
|
|
sc->framelen = 0;
|
|
sc->outpos = 0;
|
|
sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
|
|
sc->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
|
|
}
|
|
|
|
|
|
static void
|
|
send_frame_header(struct sbni_softc *sc, u_int32_t *crc_p)
|
|
{
|
|
u_int32_t crc;
|
|
u_int len_field;
|
|
u_char value;
|
|
|
|
crc = *crc_p;
|
|
len_field = sc->framelen + 6; /* CRC + frameno + reserved */
|
|
|
|
if (sc->state & FL_NEED_RESEND)
|
|
len_field |= FRAME_RETRY; /* non-first attempt... */
|
|
|
|
if (sc->outpos == 0)
|
|
len_field |= FRAME_FIRST;
|
|
|
|
len_field |= (sc->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
|
|
sbni_outb(sc, DAT, SBNI_SIG);
|
|
|
|
value = (u_char)len_field;
|
|
sbni_outb(sc, DAT, value);
|
|
crc = CRC32(value, crc);
|
|
value = (u_char)(len_field >> 8);
|
|
sbni_outb(sc, DAT, value);
|
|
crc = CRC32(value, crc);
|
|
|
|
sbni_outb(sc, DAT, sc->tx_frameno);
|
|
crc = CRC32(sc->tx_frameno, crc);
|
|
sbni_outb(sc, DAT, 0);
|
|
crc = CRC32(0, crc);
|
|
*crc_p = crc;
|
|
}
|
|
|
|
|
|
/*
|
|
* if frame tail not needed (incorrect number or received twice),
|
|
* it won't store, but CRC will be calculated
|
|
*/
|
|
|
|
static int
|
|
skip_tail(struct sbni_softc *sc, u_int tail_len, u_int32_t crc)
|
|
{
|
|
while (tail_len--)
|
|
crc = CRC32(sbni_inb(sc, DAT), crc);
|
|
|
|
return (crc == CRC32_REMAINDER);
|
|
}
|
|
|
|
|
|
static int
|
|
check_fhdr(struct sbni_softc *sc, u_int *framelen, u_int *frameno,
|
|
u_int *ack, u_int *is_first, u_int32_t *crc_p)
|
|
{
|
|
u_int32_t crc;
|
|
u_char value;
|
|
|
|
crc = *crc_p;
|
|
if (sbni_inb(sc, DAT) != SBNI_SIG)
|
|
return (0);
|
|
|
|
value = sbni_inb(sc, DAT);
|
|
*framelen = (u_int)value;
|
|
crc = CRC32(value, crc);
|
|
value = sbni_inb(sc, DAT);
|
|
*framelen |= ((u_int)value) << 8;
|
|
crc = CRC32(value, crc);
|
|
|
|
*ack = *framelen & FRAME_ACK_MASK;
|
|
*is_first = (*framelen & FRAME_FIRST) != 0;
|
|
|
|
if ((*framelen &= FRAME_LEN_MASK) < 6 || *framelen > SBNI_MAX_FRAME - 3)
|
|
return (0);
|
|
|
|
value = sbni_inb(sc, DAT);
|
|
*frameno = (u_int)value;
|
|
crc = CRC32(value, crc);
|
|
|
|
crc = CRC32(sbni_inb(sc, DAT), crc); /* reserved byte */
|
|
*framelen -= 2;
|
|
|
|
*crc_p = crc;
|
|
return (1);
|
|
}
|
|
|
|
|
|
static int
|
|
get_rx_buf(struct sbni_softc *sc)
|
|
{
|
|
struct mbuf *m;
|
|
|
|
MGETHDR(m, M_NOWAIT, MT_DATA);
|
|
if (m == NULL) {
|
|
if_printf(sc->ifp, "cannot allocate header mbuf\n");
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* 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 (ETHER_MAX_LEN + 2 > MHLEN) {
|
|
/* Attach an mbuf cluster */
|
|
if (!(MCLGET(m, M_NOWAIT))) {
|
|
m_freem(m);
|
|
return (0);
|
|
}
|
|
}
|
|
m->m_pkthdr.len = m->m_len = ETHER_MAX_LEN + 2;
|
|
|
|
/*
|
|
* The +2 is to longword align the start of the real packet.
|
|
* (sizeof ether_header == 14)
|
|
* This is important for NFS.
|
|
*/
|
|
m_adj(m, 2);
|
|
sc->rx_buf_p = m;
|
|
return (1);
|
|
}
|
|
|
|
|
|
static void
|
|
indicate_pkt(struct sbni_softc *sc)
|
|
{
|
|
struct ifnet *ifp = sc->ifp;
|
|
struct mbuf *m;
|
|
|
|
m = sc->rx_buf_p;
|
|
m->m_pkthdr.rcvif = ifp;
|
|
m->m_pkthdr.len = m->m_len = sc->inppos;
|
|
sc->rx_buf_p = NULL;
|
|
|
|
SBNI_UNLOCK(sc);
|
|
(*ifp->if_input)(ifp, m);
|
|
SBNI_LOCK(sc);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Routine checks periodically wire activity and regenerates marker if
|
|
* connect was inactive for a long time.
|
|
*/
|
|
|
|
static void
|
|
sbni_timeout(void *xsc)
|
|
{
|
|
struct sbni_softc *sc;
|
|
u_char csr0;
|
|
|
|
sc = (struct sbni_softc *)xsc;
|
|
SBNI_ASSERT_LOCKED(sc);
|
|
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
if (csr0 & RC_CHK) {
|
|
|
|
if (sc->timer_ticks) {
|
|
if (csr0 & (RC_RDY | BU_EMP))
|
|
/* receiving not active */
|
|
sc->timer_ticks--;
|
|
} else {
|
|
sc->in_stats.timeout_number++;
|
|
if (sc->delta_rxl)
|
|
timeout_change_level(sc);
|
|
|
|
sbni_outb(sc, CSR1, *(u_char *)&sc->csr1 | PR_RES);
|
|
csr0 = sbni_inb(sc, CSR0);
|
|
}
|
|
}
|
|
|
|
sbni_outb(sc, CSR0, csr0 | RC_CHK);
|
|
callout_reset(&sc->wch, hz/SBNI_HZ, sbni_timeout, sc);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static void
|
|
card_start(struct sbni_softc *sc)
|
|
{
|
|
sc->timer_ticks = CHANGE_LEVEL_START_TICKS;
|
|
sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
|
|
sc->state |= FL_PREV_OK;
|
|
|
|
sc->inppos = 0;
|
|
sc->wait_frameno = 0;
|
|
|
|
sbni_outb(sc, CSR1, *(u_char *)&sc->csr1 | PR_RES);
|
|
sbni_outb(sc, CSR0, EN_INT);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static u_char rxl_tab[] = {
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
|
|
0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
|
|
};
|
|
|
|
#define SIZE_OF_TIMEOUT_RXL_TAB 4
|
|
static u_char timeout_rxl_tab[] = {
|
|
0x03, 0x05, 0x08, 0x0b
|
|
};
|
|
|
|
static void
|
|
set_initial_values(struct sbni_softc *sc, struct sbni_flags flags)
|
|
{
|
|
if (flags.fixed_rxl) {
|
|
sc->delta_rxl = 0; /* disable receive level autodetection */
|
|
sc->cur_rxl_index = flags.rxl;
|
|
} else {
|
|
sc->delta_rxl = DEF_RXL_DELTA;
|
|
sc->cur_rxl_index = DEF_RXL;
|
|
}
|
|
|
|
sc->csr1.rate = flags.fixed_rate ? flags.rate : DEFAULT_RATE;
|
|
sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
|
|
sc->maxframe = DEFAULT_FRAME_LEN;
|
|
|
|
/*
|
|
* generate Ethernet address (0x00ff01xxxxxx)
|
|
*/
|
|
*(u_int16_t *) sc->enaddr = htons(0x00ff);
|
|
if (flags.mac_addr) {
|
|
*(u_int32_t *) (sc->enaddr + 2) =
|
|
htonl(flags.mac_addr | 0x01000000);
|
|
} else {
|
|
*(u_char *) (sc->enaddr + 2) = 0x01;
|
|
read_random(sc->enaddr + 3, 3);
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef SBNI_DUAL_COMPOUND
|
|
void
|
|
sbni_add(struct sbni_softc *sc)
|
|
{
|
|
|
|
mtx_lock(&headlist_lock);
|
|
sc->link = sbni_headlist;
|
|
sbni_headlist = sc;
|
|
mtx_unlock(&headlist_lock);
|
|
}
|
|
|
|
struct sbni_softc *
|
|
connect_to_master(struct sbni_softc *sc)
|
|
{
|
|
struct sbni_softc *p, *p_prev;
|
|
|
|
mtx_lock(&headlist_lock);
|
|
for (p = sbni_headlist, p_prev = NULL; p; p_prev = p, p = p->link) {
|
|
if (rman_get_start(p->io_res) == rman_get_start(sc->io_res) + 4 ||
|
|
rman_get_start(p->io_res) == rman_get_start(sc->io_res) - 4) {
|
|
p->slave_sc = sc;
|
|
if (p_prev)
|
|
p_prev->link = p->link;
|
|
else
|
|
sbni_headlist = p->link;
|
|
mtx_unlock(&headlist_lock);
|
|
return p;
|
|
}
|
|
}
|
|
mtx_unlock(&headlist_lock);
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
#endif /* SBNI_DUAL_COMPOUND */
|
|
|
|
|
|
/* Receive level auto-selection */
|
|
|
|
static void
|
|
change_level(struct sbni_softc *sc)
|
|
{
|
|
if (sc->delta_rxl == 0) /* do not auto-negotiate RxL */
|
|
return;
|
|
|
|
if (sc->cur_rxl_index == 0)
|
|
sc->delta_rxl = 1;
|
|
else if (sc->cur_rxl_index == 15)
|
|
sc->delta_rxl = -1;
|
|
else if (sc->cur_rxl_rcvd < sc->prev_rxl_rcvd)
|
|
sc->delta_rxl = -sc->delta_rxl;
|
|
|
|
sc->csr1.rxl = rxl_tab[sc->cur_rxl_index += sc->delta_rxl];
|
|
sbni_inb(sc, CSR0); /* it needed for PCI cards */
|
|
sbni_outb(sc, CSR1, *(u_char *)&sc->csr1);
|
|
|
|
sc->prev_rxl_rcvd = sc->cur_rxl_rcvd;
|
|
sc->cur_rxl_rcvd = 0;
|
|
}
|
|
|
|
|
|
static void
|
|
timeout_change_level(struct sbni_softc *sc)
|
|
{
|
|
sc->cur_rxl_index = timeout_rxl_tab[sc->timeout_rxl];
|
|
if (++sc->timeout_rxl >= 4)
|
|
sc->timeout_rxl = 0;
|
|
|
|
sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
|
|
sbni_inb(sc, CSR0);
|
|
sbni_outb(sc, CSR1, *(u_char *)&sc->csr1);
|
|
|
|
sc->prev_rxl_rcvd = sc->cur_rxl_rcvd;
|
|
sc->cur_rxl_rcvd = 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* Process an ioctl request. This code needs some work - it looks
|
|
* pretty ugly.
|
|
*/
|
|
|
|
static int
|
|
sbni_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
|
|
{
|
|
struct sbni_softc *sc;
|
|
struct ifreq *ifr;
|
|
struct thread *td;
|
|
struct sbni_in_stats *in_stats;
|
|
struct sbni_flags flags;
|
|
int error;
|
|
|
|
sc = ifp->if_softc;
|
|
ifr = (struct ifreq *)data;
|
|
td = curthread;
|
|
error = 0;
|
|
|
|
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.
|
|
*/
|
|
SBNI_LOCK(sc);
|
|
if (ifp->if_flags & IFF_UP) {
|
|
if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
|
|
sbni_init_locked(sc);
|
|
} else {
|
|
if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
|
|
sbni_stop(sc);
|
|
}
|
|
}
|
|
SBNI_UNLOCK(sc);
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
case SIOCDELMULTI:
|
|
/*
|
|
* Multicast list has changed; set the hardware filter
|
|
* accordingly.
|
|
*/
|
|
error = 0;
|
|
/* if (ifr == NULL)
|
|
error = EAFNOSUPPORT; */
|
|
break;
|
|
|
|
/*
|
|
* SBNI specific ioctl
|
|
*/
|
|
case SIOCGHWFLAGS: /* get flags */
|
|
SBNI_LOCK(sc);
|
|
bcopy((caddr_t)IF_LLADDR(sc->ifp)+3, (caddr_t) &flags, 3);
|
|
flags.rxl = sc->cur_rxl_index;
|
|
flags.rate = sc->csr1.rate;
|
|
flags.fixed_rxl = (sc->delta_rxl == 0);
|
|
flags.fixed_rate = 1;
|
|
SBNI_UNLOCK(sc);
|
|
ifr->ifr_data = *(caddr_t*) &flags;
|
|
break;
|
|
|
|
case SIOCGINSTATS:
|
|
in_stats = malloc(sizeof(struct sbni_in_stats), M_DEVBUF,
|
|
M_WAITOK);
|
|
SBNI_LOCK(sc);
|
|
bcopy(&sc->in_stats, in_stats, sizeof(struct sbni_in_stats));
|
|
SBNI_UNLOCK(sc);
|
|
error = copyout(ifr->ifr_data, in_stats,
|
|
sizeof(struct sbni_in_stats));
|
|
free(in_stats, M_DEVBUF);
|
|
break;
|
|
|
|
case SIOCSHWFLAGS: /* set flags */
|
|
/* root only */
|
|
error = priv_check(td, PRIV_DRIVER);
|
|
if (error)
|
|
break;
|
|
flags = *(struct sbni_flags*)&ifr->ifr_data;
|
|
SBNI_LOCK(sc);
|
|
if (flags.fixed_rxl) {
|
|
sc->delta_rxl = 0;
|
|
sc->cur_rxl_index = flags.rxl;
|
|
} else {
|
|
sc->delta_rxl = DEF_RXL_DELTA;
|
|
sc->cur_rxl_index = DEF_RXL;
|
|
}
|
|
sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
|
|
sc->csr1.rate = flags.fixed_rate ? flags.rate : DEFAULT_RATE;
|
|
if (flags.mac_addr)
|
|
bcopy((caddr_t) &flags,
|
|
(caddr_t) IF_LLADDR(sc->ifp)+3, 3);
|
|
|
|
/* Don't be afraid... */
|
|
sbni_outb(sc, CSR1, *(char*)(&sc->csr1) | PR_RES);
|
|
SBNI_UNLOCK(sc);
|
|
break;
|
|
|
|
case SIOCRINSTATS:
|
|
SBNI_LOCK(sc);
|
|
if (!(error = priv_check(td, PRIV_DRIVER))) /* root only */
|
|
bzero(&sc->in_stats, sizeof(struct sbni_in_stats));
|
|
SBNI_UNLOCK(sc);
|
|
break;
|
|
|
|
default:
|
|
error = ether_ioctl(ifp, command, data);
|
|
break;
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static u_int32_t
|
|
calc_crc32(u_int32_t crc, caddr_t p, u_int len)
|
|
{
|
|
while (len--)
|
|
crc = CRC32(*p++, crc);
|
|
|
|
return (crc);
|
|
}
|
|
|
|
static u_int32_t crc32tab[] __aligned(8) = {
|
|
0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
|
|
0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
|
|
0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
|
|
0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
|
|
0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
|
|
0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
|
|
0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
|
|
0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
|
|
0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
|
|
0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
|
|
0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
|
|
0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
|
|
0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
|
|
0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
|
|
0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
|
|
0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
|
|
0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
|
|
0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
|
|
0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
|
|
0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
|
|
0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
|
|
0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
|
|
0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
|
|
0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
|
|
0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
|
|
0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
|
|
0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
|
|
0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
|
|
0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
|
|
0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
|
|
0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
|
|
0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
|
|
0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
|
|
0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
|
|
0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
|
|
0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
|
|
0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
|
|
0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
|
|
0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
|
|
0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
|
|
0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
|
|
0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
|
|
0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
|
|
0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
|
|
0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
|
|
0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
|
|
0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
|
|
0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
|
|
0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
|
|
0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
|
|
0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
|
|
0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
|
|
0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
|
|
0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
|
|
0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
|
|
0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
|
|
0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
|
|
0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
|
|
0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
|
|
0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
|
|
0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
|
|
0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
|
|
0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
|
|
0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
|
|
};
|