/*      $NetBSD: netif_sun.c,v 1.11 2021/04/12 09:19:10 mrg Exp $       */

/*-
* Copyright (c) 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Gordon W. Ross.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/*
* The Sun PROM has a fairly general set of network drivers,
* so it is easiest to just replace the netif module with
* this adaptation to the PROM network interface.
*/

#include <sys/param.h>
#include <sys/socket.h>

#include <net/if.h>
#include <net/if_ether.h>

#include <netinet/in.h>
#include <netinet/in_systm.h>

#include <machine/idprom.h>
#include <machine/mon.h>

#include <stand.h>
#include <net.h>

#include <lib/libkern/libkern.h>

#include <lib/libsa/saerrno.h>

#include "libsa.h"
#include "dvma.h"
#include "saio.h"
#include "netif.h"

#define PKT_BUF_SIZE 2048

struct iodesc sockets[SOPEN_MAX];

struct netif prom_netif;
struct devdata {
       struct saioreq dd_si;
       int rbuf_len;
       char *rbuf;
       int tbuf_len;
       char *tbuf;
       u_short dd_opens;
       u_char dd_myea[6];
} netif_devdata;

struct devdata * netif_init(void *);
void netif_fini(struct devdata *);
int netif_attach(struct netif *, struct iodesc *, void *);
void netif_detach(struct netif *);

void netif_getether(struct saif *, u_char *);


/*
* Open the PROM device.
* Return netif ptr on success.
*/
struct devdata *
netif_init(void *aux)
{
       struct devdata *dd = &netif_devdata;
       struct saioreq *si;
       struct bootparam *bp;
       int error;

       /*
        * Setup our part of the saioreq.
        * (determines what gets opened)
        */
       si = &dd->dd_si;
       memset(si, 0, sizeof(*si));
       bp = *romVectorPtr->bootParam;
       si->si_boottab = bp->bootDevice;
       si->si_ctlr = bp->ctlrNum;
       si->si_unit = bp->unitNum;
       si->si_boff = bp->partNum;

#ifdef NETIF_DEBUG
       if (debug)
               printf("netif_init: calling prom_iopen\n");
#endif

       /*
        * Note: Sun PROMs will do RARP on open, but does not tell
        * you the IP address it gets, so it is just noise to us...
        */
       if ((error = prom_iopen(si)) != 0) {
               printf("netif_init: prom_iopen, error=%d\n", error);
               return (NULL);
       }

       if (si->si_sif == NULL) {
               printf("netif_init: not a network device\n");
               prom_iclose(si);
               return (NULL);
       }

       /* Allocate the transmit/receive buffers. */
       if (dd->rbuf == NULL) {
               dd->rbuf_len = PKT_BUF_SIZE;
               dd->rbuf = dvma_alloc(dd->rbuf_len);
       }
       if (dd->tbuf == NULL) {
               dd->tbuf_len = PKT_BUF_SIZE;
               dd->tbuf = dvma_alloc(dd->tbuf_len);
       }
       if ((dd->rbuf == NULL) ||
           (dd->tbuf == NULL))
               panic("netif_init: malloc failed");

#ifdef NETIF_DEBUG
       if (debug)
               printf("netif_init: rbuf=0x%x, tbuf=0x%x\n",
                          dd->rbuf, dd->tbuf);
#endif

       /* Record our ethernet address. */
       netif_getether(si->si_sif, dd->dd_myea);

       dd->dd_opens = 0;

       return(dd);
}

void
netif_fini(struct devdata *dd)
{
       struct saioreq *si;

       si = &dd->dd_si;

#ifdef NETIF_DEBUG
       if (debug)
               printf("netif_fini: calling prom_iclose\n");
#endif

       prom_iclose(si);
       /* Dellocate the transmit/receive buffers. */
       if (dd->rbuf) {
               dvma_free(dd->rbuf, dd->rbuf_len);
               dd->rbuf = NULL;
       }
       if (dd->tbuf) {
               dvma_free(dd->tbuf, dd->tbuf_len);
               dd->tbuf = NULL;
       }
}

int
netif_attach(struct netif *nif, struct iodesc *s, void *aux)
{
       struct devdata *dd;

       dd = nif->nif_devdata;
       if (dd == NULL) {
               dd = netif_init(aux);
               if (dd == NULL)
                       return (ENXIO);
               nif->nif_devdata = dd;
       }
       dd->dd_opens++;
       MACPY(dd->dd_myea, s->myea);
       s->io_netif = nif;
       return(0);
}

void
netif_detach(struct netif *nif)
{
       struct devdata *dd;

       dd = nif->nif_devdata;
       if (dd == NULL)
               return;
       dd->dd_opens--;
       if (dd->dd_opens > 0)
               return;
       netif_fini(dd);
       nif->nif_devdata = NULL;
}

int
netif_open(void *aux)
{
       struct netif *nif;
       struct iodesc *s;
       int fd, error;

       /* find a free socket */
       for (fd = 0, s = sockets; fd < SOPEN_MAX; fd++, s++)
               if (s->io_netif == NULL)
                       goto found;
       errno = EMFILE;
       return (-1);

found:
       memset(s, 0, sizeof(*s));
       nif = &prom_netif;
       error = netif_attach(nif, s, aux);
       if (error != 0) {
               errno = error;
               return (-1);
       }
       return (fd);
}

int
netif_close(int fd)
{
       struct iodesc *s;
       struct netif *nif;

       if (fd < 0 || fd >= SOPEN_MAX) {
               errno = EBADF;
               return(-1);
       }
       s = &sockets[fd];
       nif = s->io_netif;
       /* Already closed? */
       if (nif == NULL)
               return(0);
       netif_detach(nif);
       s->io_netif = NULL;
       return(0);
}


struct iodesc *
socktodesc(int fd)
{
       if (fd < 0 || fd >= SOPEN_MAX) {
               errno = EBADF;
               return (NULL);
       }
       return (&sockets[fd]);
}


/*
* Send a packet.  The ether header is already there.
* Return the length sent (or -1 on error).
*/
int
netif_put(struct iodesc *desc, void *pkt, size_t len)
{
       struct netif *nif;
       struct devdata *dd;
       struct saioreq *si;
       struct saif *sif;
       int slen;

#ifdef NETIF_DEBUG
       if (debug > 1) {
               struct ether_header *eh;

               printf("netif_put: desc=0x%x pkt=0x%x len=%d\n",
                          desc, pkt, len);
               eh = pkt;
               printf("dst: %s ", ether_sprintf(eh->ether_dhost));
               printf("src: %s ", ether_sprintf(eh->ether_shost));
               printf("type: 0x%x\n", eh->ether_type & 0xFFFF);
       }
#endif

       nif = desc->io_netif;
       dd = nif->nif_devdata;
       si = &dd->dd_si;
       sif = si->si_sif;
       slen = len;

#ifdef PARANOID
       if (sif == NULL)
               panic("netif_put: no saif ptr");
#endif

       /*
        * Copy into our transmit buffer because the PROM
        * network driver might continue using the packet
        * after the sif_xmit call returns.  We never send
        * very much data anyway, so the copy is fine.
        */
       if (slen > dd->tbuf_len)
               panic("netif_put: slen=%d", slen);
       memcpy(dd->tbuf, pkt, slen);

       if (slen < 60) {
               slen = 60;
       }

       (void)(*sif->sif_xmit)(si->si_devdata, dd->tbuf, slen);

#ifdef NETIF_DEBUG
       if (debug > 1)
               printf("netif_put: xmit returned %d\n", rv);
#endif
       /*
        * Just ignore the return value.  If the PROM transmit
        * function fails, it will make some noise, such as:
        *      le: No Carrier
        */

       return len;
}

/*
* Receive a packet, including the ether header.
* Return the total length received (or -1 on error).
*/
ssize_t
netif_get(struct iodesc *desc, void *pkt, size_t maxlen, saseconds_t timo)
{
       struct netif *nif;
       struct devdata *dd;
       struct saioreq *si;
       struct saif *sif;
       int tick0, tmo_ticks;
       int rlen = 0;

#ifdef NETIF_DEBUG
       if (debug > 1)
               printf("netif_get: pkt=0x%x, maxlen=%d, tmo=%d\n",
                          pkt, maxlen, timo);
#endif

       nif = desc->io_netif;
       dd = nif->nif_devdata;
       si = &dd->dd_si;
       sif = si->si_sif;

       tmo_ticks = timo * hz;

       /* Have to receive into our own buffer and copy. */
       do {
               tick0 = getticks();
               do {
                       rlen = (*sif->sif_poll)(si->si_devdata, dd->rbuf);
                       if (rlen != 0)
                               goto break2;
               } while (getticks() == tick0);
       } while (--tmo_ticks > 0);

#if 0
       /* No packet arrived.  Better reset the interface. */
       printf("netif_get: timeout; resetting\n");
       (*sif->sif_reset)(si->si_devdata, si);
#endif

break2:

#ifdef NETIF_DEBUG
       if (debug > 1)
               printf("netif_get: received rlen=%d\n", rlen);
#endif

       /* Need at least a valid Ethernet header. */
       if (rlen < 12)
               return -1;

       /* If we went beyond our buffer, were dead! */
       if (rlen > dd->rbuf_len)
               panic("netif_get: rlen=%d", rlen);

       /* The caller's buffer may be smaller... */
       if (rlen > maxlen)
               rlen = maxlen;

       memcpy(pkt, dd->rbuf, rlen);

#ifdef NETIF_DEBUG
       if (debug > 1) {
               struct ether_header *eh = pkt;

               printf("dst: %s ", ether_sprintf(eh->ether_dhost));
               printf("src: %s ", ether_sprintf(eh->ether_shost));
               printf("type: 0x%x\n", eh->ether_type & 0xFFFF);
       }
#endif

       return rlen;
}

/*
* Copy our Ethernet address into the passed array.
*/
void
netif_getether(struct saif *sif, u_char *ea)
{
       char *rev;

       if (_is3x == 0) {
               /*
                * Sun3:  These usually have old PROMs
                * without the sif_macaddr function, but
                * reading the IDPROM on these machines is
                * very easy, so just always do that.
                */
               idprom_etheraddr(ea);
               return;
       }

       /*
        * Sun3X:  Want to use sif->sif_macaddr(), but
        * it's only in PROM revisions 3.0 and later,
        * so we have to check the PROM rev first.
        * Note that old PROMs prefix the rev string
        * with "Rev " (i.e. "Rev 2.6").
        */
       rev = romVectorPtr->monId;
       if (!strncmp(rev, "Rev ", 4))
               rev += 4;
       if (!strncmp(rev, "3.", 2)) {
               /* Great!  We can call the PROM. */
               (*sif->sif_macaddr)(ea);
               return;
       }

       /*
        * Sun3X with PROM rev < 3.0.
        * Finding the IDPROM is a pain, but
        * we have no choice.  Warn the user.
        */
       printf("netboot: Old PROM Rev (%s)\n", rev);
       idprom_etheraddr(ea);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.