Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/arch/sun3/netboot/le_poll.c

509 lines
14 KiB
C
Raw Blame History

/* $NetBSD: le_poll.c,v 1.3 1994/10/26 09:11:48 cgd Exp $ */
/*
* Copyright (c) 1993 Adam Glass
* 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, 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Adam Glass.
* 4. The name of the Author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Adam Glass ``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 REGENTS 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.
*/
#include <sys/param.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include "netboot/netboot.h"
#include "netboot/netif.h"
#include "config.h"
#include "machine/obio.h"
#include "../dev/if_lereg.h"
#include "../dev/if_le_subr.h"
int le_debug = 1;
int le_probe();
int le_match();
void le_init();
int le_get();
int le_put();
void le_end();
struct netif_stats le_stats;
struct netif le_netif = {
"le", /* netif_bname */
0, /* netif_unit */
0, /* netif_exhausted */
le_match, /* netif_match */
le_probe, /* netif_probe */
le_init, /* netif_init */
le_get, /* netif_get */
le_put, /* netif_put */
le_end, /* netif_end */
&le_stats
};
struct le_configuration {
unsigned int obio_addr;
int used;
} le_config[] = {
{OBIO_AMD_ETHER, 0}
};
int nle_config = sizeof(le_config)/(sizeof(le_config[0]));
#define LE_UNIT le_netif.netif_unit
struct {
struct lereg1 *sc_r1; /* LANCE registers */
struct lereg2 *sc_r2; /* RAM */
int next_rmd;
int next_tmd;
} le_softc;
int le_match(machdep_hint, unitp)
void *machdep_hint;
int *unitp;
{
char *name;
int i, val = 0;
name = machdep_hint;
if (name && !strncmp(le_netif.netif_bname, name,2))
val += 10;
for (i = 0; i < nle_config; i++) {
if (le_config[i].used) continue;
*unitp = i;
if (le_debug)
printf("le%d: le_match --> %d\n", i, val+1);
le_config[i].used++;
return val+1;
}
if (le_debug)
printf("le%d: le_match --> 0\n", i);
return 0;
}
int le_probe(machdep_hint)
void *machdep_hint;
{
/* the set unit is the current unit */
if (le_debug)
printf("le%d: le_probe called\n", LE_UNIT);
return 0;
}
void le_sanity_check(str)
char *str;
{
struct lereg1 *ler1 = le_softc.sc_r1;
struct lereg2 *ler2 = le_softc.sc_r2;
unsigned int a;
int i;
for (i = 0; i < LERBUF; i++) {
a = LANCE_ADDR(&ler2->ler2_rbuf[i]);
if ((ler2->ler2_rmd[i].rmd0 != (a & LE_ADDR_LOW_MASK)) ||
(ler2->ler2_rmd[i].rmd1_hadr != (a >> 16))) {
printf("le%d: ler2_rmd[%d] addrs bad\n", LE_UNIT, i);
printf("le%d: string: %s\n", LE_UNIT, str);
panic("addrs trashed\n");
}
}
for (i = 0; i < LETBUF; i++) {
a = LANCE_ADDR(&ler2->ler2_tbuf[i]);
if ((ler2->ler2_tmd[i].tmd0 != (a & LE_ADDR_LOW_MASK)) ||
(ler2->ler2_tmd[i].tmd1_hadr != (a >> 16))) {
printf("le%d: ler2_tmd[%d] addrs bad\n", LE_UNIT, i);
printf("le%d: string: %s\n", LE_UNIT, str);
panic("addrs trashed\n");
}
}
}
void le_mem_summary()
{
struct lereg1 *ler1 = le_softc.sc_r1;
struct lereg2 *ler2 = le_softc.sc_r2;
int i;
printf("le%d: obio addr = %x\n", LE_UNIT, ler1);
printf("le%d: dvma addr = %x\n", LE_UNIT, ler2);
#if 0
ler1->ler1_rap = LE_CSR0;
ler1->ler1_rdp = LE_STOP;
printf("le%d: csr0 = %x\n", LE_UNIT, ler1->ler1_rdp);
ler1->ler1_rap = LE_CSR1;
printf("le%d: csr1 = %x\n", LE_UNIT, ler1->ler1_rdp);
ler1->ler1_rap = LE_CSR2;
printf("le%d: csr2 = %x\n", LE_UNIT, ler1->ler1_rdp);
ler1->ler1_rap = LE_CSR3;
printf("le%d: csr3 = %x\n", LE_UNIT, ler1->ler1_rdp);
#endif
printf("le%d: ladrf0 = %x\n", LE_UNIT, ler2->ler2_ladrf0);
printf("le%d: ladrf1 = %x\n", LE_UNIT, ler2->ler2_ladrf1);
printf("le%d: ler2_rdra = %x\n", LE_UNIT, ler2->ler2_rdra);
printf("le%d: ler2_rlen = %x\n", LE_UNIT, ler2->ler2_rlen);
printf("le%d: ler2_tdra = %x\n", LE_UNIT, ler2->ler2_tdra);
printf("le%d: ler2_tlen = %x\n", LE_UNIT, ler2->ler2_tlen);
for (i = 0; i < LERBUF; i++) {
printf("le%d: ler2_rmd[%d].rmd0 (ladr) = %x\n", LE_UNIT, i,
ler2->ler2_rmd[i].rmd0);
printf("le%d: ler2_rmd[%d].rmd1_bits = %x\n", LE_UNIT, i,
ler2->ler2_rmd[i].rmd1_bits);
printf("le%d: ler2_rmd[%d].rmd1_hadr = %x\n", LE_UNIT, i,
ler2->ler2_rmd[i].rmd1_hadr);
printf("le%d: ler2_rmd[%d].rmd2 (-bcnt) = %x\n", LE_UNIT, i,
ler2->ler2_rmd[i].rmd2);
printf("le%d: ler2_rmd[%d].rmd3 (mcnt) = %x\n", LE_UNIT, i,
ler2->ler2_rmd[i].rmd3);
printf("le%d: ler2_rbuf[%d] addr = %x\n", LE_UNIT, i,
&ler2->ler2_rbuf[i]);
}
for (i = 0; i < LETBUF; i++) {
printf("le%d: ler2_tmd[%d].tmd0 = %x\n", LE_UNIT, i,
ler2->ler2_tmd[i].tmd0);
printf("le%d: ler2_tmd[%d].tmd1_bits = %x\n", LE_UNIT, i,
ler2->ler2_tmd[i].tmd1_bits);
printf("le%d: ler2_tmd[%d].tmd1_hadr = %x\n", LE_UNIT, i,
ler2->ler2_tmd[i].tmd1_hadr);
printf("le%d: ler2_tmd[%d].tmd2 (bcnt) = %x\n", LE_UNIT, i,
ler2->ler2_tmd[i].tmd2);
printf("le%d: ler2_tmd[%d].tmd3 = %x\n", LE_UNIT, i,
ler2->ler2_tmd[i].tmd3);
printf("le%d: ler2_tbuf[%d] addr = %x\n", LE_UNIT, i,
&ler2->ler2_tbuf[i]);
}
}
void le_error(str, ler1)
char *str;
struct lereg1 *ler1;
{
/* ler1->ler1_rap = LE_CSRO done in caller */
if (ler1->ler1_rdp & LE_BABL)
panic("le%d: been babbling, found by '%s'\n", LE_UNIT, str);
if (ler1->ler1_rdp & LE_CERR) {
le_stats.collision_error++;
ler1->ler1_rdp = LE_CERR;
}
if (ler1->ler1_rdp & LE_MISS) {
le_stats.missed++;
ler1->ler1_rdp = LE_MISS;
}
if (ler1->ler1_rdp & LE_MERR) {
printf("le%d: memory error in '%s'\n", LE_UNIT, str);
le_mem_summary();
panic("bye");
}
}
void le_reset(myea)
u_char *myea;
{
struct lereg1 *ler1 = le_softc.sc_r1;
struct lereg2 *ler2 = le_softc.sc_r2;
unsigned int a;
int timo = 100000, stat, i;
if (le_debug)
printf("le%d: le_reset called\n", LE_UNIT);
ler1->ler1_rap = LE_CSR0;
ler1->ler1_rdp = LE_STOP; /* do nothing until we are finished */
bzero(ler2, sizeof(*ler2));
ler2->ler2_mode = LE_MODE;
ler2->ler2_padr[0] = myea[1];
ler2->ler2_padr[1] = myea[0];
ler2->ler2_padr[2] = myea[3];
ler2->ler2_padr[3] = myea[2];
ler2->ler2_padr[4] = myea[5];
ler2->ler2_padr[5] = myea[4];
ler2->ler2_ladrf0 = 0;
ler2->ler2_ladrf1 = 0;
a = LANCE_ADDR(ler2->ler2_rmd);
#ifdef RECV_DEBUG
ler2->ler2_rlen = 0 | (a >> 16);
#undef LERBUF
#define LERBUF 1
#else
ler2->ler2_rlen = LE_RLEN | (a >> 16);
#endif
ler2->ler2_rdra = a & LE_ADDR_LOW_MASK;
a = LANCE_ADDR(ler2->ler2_tmd);
ler2->ler2_tlen = LE_TLEN | (a >> 16);
ler2->ler2_tdra = a & LE_ADDR_LOW_MASK;
ler1->ler1_rap = LE_CSR1;
a = LANCE_ADDR(ler2);
ler1->ler1_rdp = a & LE_ADDR_LOW_MASK;
ler1->ler1_rap = LE_CSR2;
ler1->ler1_rdp = a >> 16;
for (i = 0; i < LERBUF; i++) {
a = LANCE_ADDR(&ler2->ler2_rbuf[i]);
ler2->ler2_rmd[i].rmd0 = a & LE_ADDR_LOW_MASK;
ler2->ler2_rmd[i].rmd1_bits = LE_OWN;
ler2->ler2_rmd[i].rmd1_hadr = a >> 16;
if (le_debug)
printf("le rbuf[%d] = %x%x\n", i, a >>16, a & LE_ADDR_LOW_MASK);
ler2->ler2_rmd[i].rmd2 = -LEMTU;
ler2->ler2_rmd[i].rmd3 = 0;
}
for (i = 0; i < LETBUF; i++) {
a = LANCE_ADDR(&ler2->ler2_tbuf[i]);
ler2->ler2_tmd[i].tmd0 = a & LE_ADDR_LOW_MASK;
ler2->ler2_tmd[i].tmd1_bits = 0;
ler2->ler2_tmd[i].tmd1_hadr = a >> 16;
if (le_debug)
printf("le tbuf[%d] = %x%x\n", i, a >>16, a & LE_ADDR_LOW_MASK );
ler2->ler2_tmd[i].tmd2 = 0;
ler2->ler2_tmd[i].tmd3 = 0;
}
ler1->ler1_rap = LE_CSR3;
ler1->ler1_rdp = LE_BSWP;
ler1->ler1_rap = LE_CSR0;
ler1->ler1_rdp = LE_INIT;
do {
if (--timo == 0) {
printf("le%d: init timeout, stat = 0x%x\n",
le_netif.netif_unit, stat);
break;
}
stat = ler1->ler1_rdp;
} while ((stat & LE_IDON) == 0);
ler1->ler1_rdp = LE_IDON;
le_softc.next_rmd = 0;
le_softc.next_tmd = 0;
ler1->ler1_rap = LE_CSR0;
ler1->ler1_rdp = LE_STRT;
le_mem_summary();
}
int le_poll(desc, pkt, len)
struct iodesc *desc;
void *pkt;
int len;
{
struct lereg1 *ler1 = le_softc.sc_r1;
struct lereg2 *ler2 = le_softc.sc_r2;
unsigned int a;
int length;
struct lermd *rmd;
printf("next_rmd on poll attempt %d\n", le_softc.next_rmd);
ler1->ler1_rap = LE_CSR0;
if ((ler1->ler1_rdp & LE_RINT) == 0)
return 0;
ler1->ler1_rdp = LE_RINT;
rmd = &ler2->ler2_rmd[le_softc.next_rmd];
if (le_debug) {
printf("next_rmd %d\n", le_softc.next_rmd);
printf("rmd->rmd1_bits %x\n", rmd->rmd1_bits);
printf("rmd->rmd2 %x, rmd->rmd3 %x\n", rmd->rmd2, rmd->rmd3);
printf("rmd->rbuf msg %d buf %d\n", rmd->rmd3, -rmd->rmd2 );
}
if (rmd->rmd1_bits & LE_OWN)
panic("le_poll: rmd still owned by lance");
if (ler1->ler1_rdp & LE_SERR)
le_error("le_poll", ler1);
if (rmd->rmd1_bits & LE_ERR) {
printf("le%d_poll: rmd status 0x%x\n", rmd->rmd1_bits);
length = 0;
goto cleanup;
}
if ((rmd->rmd1_bits & (LE_STP|LE_ENP)) != (LE_STP|LE_ENP))
panic("le_poll: chained packet\n");
length = rmd->rmd3;
printf("le_poll: length %d\n", length);
if (length >= LEMTU) {
length = 0;
panic("csr0 when bad things happen: %x\n", ler1->ler1_rdp);
goto cleanup;
}
if (!length) goto cleanup;
length -= 4;
if (length > 0)
bcopy(&ler2->ler2_rbuf[le_softc.next_rmd], pkt, length);
cleanup:
le_sanity_check("before forced rmd sanity");
a = LANCE_ADDR(&ler2->ler2_rbuf[le_softc.next_rmd]);
rmd->rmd0 = a & LE_ADDR_LOW_MASK;
rmd->rmd1_hadr = a >> 16;
rmd->rmd2 = -LEMTU;
le_softc.next_rmd =
(le_softc.next_rmd == (LERBUF - 1)) ? 0 : (le_softc.next_rmd + 1);
printf("new next_rmd %d\n", le_softc.next_rmd);
le_sanity_check("after forced rmd sanity");
rmd->rmd1_bits = LE_OWN;
return length;
}
int le_put(desc, pkt, len)
struct iodesc *desc;
void *pkt;
int len;
{
volatile struct lereg1 *ler1 = le_softc.sc_r1;
volatile struct lereg2 *ler2 = le_softc.sc_r2;
volatile struct letmd *tmd;
int timo = 100000, stat, i;
unsigned int a;
if (le_debug)
printf("le%d: le_put called\n", LE_UNIT);
printf("wierd place le_next_rmd %d\n", le_softc.next_rmd);
le_sanity_check("before transmit");
ler1->ler1_rap = LE_CSR0;
if (ler1->ler1_rdp & LE_SERR)
le_error("le_put(way before xmit)", ler1);
tmd = &ler2->ler2_tmd[le_softc.next_tmd];
while(tmd->tmd1_bits & LE_OWN) {
printf("le%d: output buffer busy\n");
}
bcopy(pkt, ler2->ler2_tbuf[le_softc.next_tmd], len);
if (len < 64)
tmd->tmd2 = -64;
else
tmd->tmd2 = -len;
tmd->tmd3 = 0;
if (ler1->ler1_rdp & LE_SERR)
le_error("le_put(before xmit)", ler1);
tmd->tmd1_bits = LE_STP | LE_ENP | LE_OWN;
a = LANCE_ADDR(&ler2->ler2_tbuf[le_softc.next_tmd]);
tmd->tmd0 = a & LE_ADDR_LOW_MASK;
tmd->tmd1_hadr = a >> 16;
ler1->ler1_rdp = LE_TDMD;
if (ler1->ler1_rdp & LE_SERR)
le_error("le_put(after xmit)", ler1);
do {
if (--timo == 0) {
printf("le%d: transmit timeout, stat = 0x%x\n",
le_netif.netif_unit, stat);
if (ler1->ler1_rdp & LE_SERR)
le_error("le_put(timeout)", ler1);
break;
}
stat = ler1->ler1_rdp;
} while ((stat & LE_TINT) == 0);
ler1->ler1_rdp = LE_TINT;
if (ler1->ler1_rdp & LE_SERR) {
printf("le_put: xmit error, buf %d\n", le_softc.next_tmd);
le_error("le_put(xmit error)", ler1);
}
le_sanity_check("after transmit");
le_softc.next_tmd = 0;
le_sanity_check("after next tmd");
/* (le_softc.next_tmd == (LETBUF - 1)) ? 0 : le_softc.next_tmd + 1;*/
if (tmd->tmd1_bits & LE_DEF) le_stats.deferred++;
if (tmd->tmd1_bits & LE_ONE) le_stats.collisions++;
if (tmd->tmd1_bits & LE_MORE) le_stats.collisions+=2;
le_sanity_check("bits check");
if (tmd->tmd1_bits & LE_ERR) {
printf("le%d: transmit error, error = 0x%x\n", LE_UNIT,
tmd->tmd3);
return -1;
}
le_sanity_check("le_debug check");
if (le_debug) {
printf("le%d: le_put() successful: sent %d\n", LE_UNIT, len);
printf("le%d: le_put(): tmd1_bits: %x tmd3: %x\n", LE_UNIT,
(unsigned int) tmd->tmd1_bits,
(unsigned int) tmd->tmd3);
}
le_sanity_check("after le_put return len");
return len;
}
int le_get(desc, pkt, len, timeout)
struct iodesc *desc;
void *pkt;
int len;
time_t timeout;
{
time_t t;
int cc;
t = getsecs();
cc = 0;
while (((getsecs() - t) < timeout) && !cc) {
cc = le_poll(desc, pkt, len);
}
return cc;
}
void le_init(desc, machdep_hint)
struct iodesc *desc;
void *machdep_hint;
{
caddr_t addr;
if (le_debug)
printf("le%d: le_init called\n", LE_UNIT);
bzero(&le_softc, sizeof(le_softc));
addr = obio_alloc((caddr_t) OBIO_AMD_ETHER, OBIO_AMD_ETHER_SIZE,
OBIO_WRITE);
if (addr == NULL)
panic("le%d: out of obio memory???", le_netif.netif_unit);
le_softc.sc_r1 = (struct lereg1 *) addr;
addr = dvma_malloc(sizeof(struct lereg2));
if (addr == NULL)
panic("le%d: no dvma space???", le_netif.netif_unit);
le_softc.sc_r2 = (struct lereg2 *) addr;
le_reset(desc->myea);
}
void le_end()
{
struct lereg1 *ler1 = le_softc.sc_r1;
if (le_debug)
printf("le%d: le_end called\n", LE_UNIT);
ler1->ler1_rap = LE_CSR0;
ler1->ler1_rdp = LE_STOP;
obio_free(le_softc.sc_r1);
dvma_free(le_softc.sc_r2);
}
Reference in New Issue View Git Blame Copy Permalink