1399 lines
31 KiB
C
1399 lines
31 KiB
C
/* $NetBSD: if_dse.c,v 1.5 2024/01/01 22:29:48 gutteridge Exp $ */
|
|
|
|
/*
|
|
* Driver for DaynaPORT SCSI/Link SCSI-Ethernet
|
|
*
|
|
* Written by Hiroshi Noguchi <ngc@ff.iij4u.or.jp>
|
|
*
|
|
* Modified by Matt Sandstrom <mattias@beauty.se> for NetBSD 1.5.3
|
|
*
|
|
* This driver is written based on "if_se.c".
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 1997 Ian W. Dall <ian.dall@dsto.defence.gov.au>
|
|
* 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 Ian W. Dall.
|
|
* 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 THE AUTHOR ``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 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 "opt_inet.h"
|
|
#include "opt_atalk.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/callout.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/file.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/device.h>
|
|
#include <sys/disklabel.h>
|
|
#include <sys/disk.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/workqueue.h>
|
|
|
|
#include <dev/scsipi/scsipi_all.h>
|
|
#include <dev/scsipi/scsiconf.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/socket.h>
|
|
#include <net/if.h>
|
|
#include <net/if_dl.h>
|
|
#include <net/if_ether.h>
|
|
#include <net/if_media.h>
|
|
|
|
#ifdef INET
|
|
#include <netinet/in.h>
|
|
#include <netinet/if_inarp.h>
|
|
#endif
|
|
|
|
#ifdef NETATALK
|
|
#include <netatalk/at.h>
|
|
#endif
|
|
|
|
#include <net/bpf.h>
|
|
|
|
|
|
/*
|
|
* debug flag
|
|
*/
|
|
#if 0
|
|
#define DSE_DEBUG
|
|
#endif
|
|
|
|
|
|
#define DSE_TIMEOUT 100000
|
|
#define DSE_OUTSTANDING 4
|
|
#define DSE_RETRIES 4
|
|
#define DSE_MINSIZE 60
|
|
|
|
#define DSE_HEADER_TX 4
|
|
#define DSE_TAIL_TX 4
|
|
#define DSE_EXTRAS_TX (DSE_HEADER_TX + DSE_TAIL_TX)
|
|
|
|
#define DSE_HEADER_RX 6
|
|
#define DSE_TAIL_RX 0
|
|
#define DSE_EXTRAS_RX (DSE_HEADER_RX + DSE_TAIL_RX)
|
|
|
|
#define MAX_BYTES_RX (ETHERMTU + sizeof(struct ether_header) + ETHER_CRC_LEN)
|
|
|
|
/* 10 full length packets appears to be the max ever returned. 16k is OK */
|
|
#define RBUF_LEN (16 * 1024)
|
|
|
|
/*
|
|
* Tuning parameters:
|
|
* We will attempt to adapt to polling fast enough to get RDATA_GOAL packets
|
|
* per read
|
|
*/
|
|
#define RDATA_MAX 10 /* maximum of returned packets (guessed) */
|
|
#define RDATA_GOAL 8
|
|
|
|
/*
|
|
* maximum of available multicast address entries (guessed)
|
|
*/
|
|
#define DSE_MCAST_MAX 10
|
|
|
|
|
|
/* dse_poll and dse_poll0 are the normal polling rate and the minimum
|
|
* polling rate respectively. dse_poll0 should be chosen so that at
|
|
* maximum ethernet speed, we will read nearly RDATA_MAX packets. dse_poll
|
|
* should be chosen for reasonable maximum latency.
|
|
* In practice, if we are being saturated with min length packets, we
|
|
* can't poll fast enough. Polling with zero delay actually
|
|
* worsens performance. dse_poll0 is enforced to be always at least 1
|
|
*/
|
|
#if MAC68K_DEBUG
|
|
#define DSE_POLL 50 /* default in milliseconds */
|
|
#define DSE_POLL0 30 /* default in milliseconds */
|
|
#else
|
|
#define DSE_POLL 80 /* default in milliseconds */
|
|
#define DSE_POLL0 40 /* default in milliseconds */
|
|
#endif
|
|
int dse_poll = 0; /* Delay in ticks set at attach time */
|
|
int dse_poll0 = 0;
|
|
int dse_max_received = 0; /* Instrumentation */
|
|
|
|
|
|
|
|
|
|
/*==========================================
|
|
data type defs
|
|
==========================================*/
|
|
typedef struct scsipi_inquiry_data dayna_ether_inquiry_data;
|
|
|
|
typedef struct {
|
|
uint8_t opcode[2];
|
|
uint8_t byte3;
|
|
uint8_t length[2];
|
|
uint8_t byte6;
|
|
} scsi_dayna_ether_generic;
|
|
|
|
#define DAYNA_CMD_SEND 0x0A /* same as generic "Write" */
|
|
#define DAYNA_CMD_RECV 0x08 /* same as generic "Read" */
|
|
|
|
#define DAYNA_CMD_GET_ADDR 0x09 /* ???: read MAC address ? */
|
|
#define REQ_LEN_GET_ADDR 0x12
|
|
|
|
#define DAYNA_CMD_SET_MULTI 0x0D /* set multicast address */
|
|
|
|
#define DAYNA_CMD_VENDOR1 0x0E /* ???: initialize signal ? */
|
|
|
|
#define IS_SEND(generic) ((generic)->opcode == DAYNA_CMD_SEND)
|
|
#define IS_RECV(generic) ((generic)->opcode == DAYNA_CMD_RECV)
|
|
|
|
struct dse_softc {
|
|
device_t sc_dev;
|
|
struct ethercom sc_ethercom; /* Ethernet common part */
|
|
struct scsipi_periph *sc_periph;/* contains our targ, lun, etc. */
|
|
|
|
struct callout sc_recv_ch;
|
|
struct kmutex sc_iflock;
|
|
struct if_percpuq *sc_ipq;
|
|
struct workqueue *sc_recv_wq, *sc_send_wq;
|
|
struct work sc_recv_work, sc_send_work;
|
|
int sc_recv_work_pending, sc_send_work_pending;
|
|
|
|
char *sc_tbuf;
|
|
char *sc_rbuf;
|
|
int sc_debug;
|
|
int sc_flags;
|
|
int sc_last_timeout;
|
|
int sc_enabled;
|
|
int sc_attach_state;
|
|
};
|
|
|
|
/* bit defs of "sc_flags" */
|
|
#define DSE_NEED_RECV 0x1
|
|
|
|
static int dsematch(device_t, cfdata_t, void *);
|
|
static void dseattach(device_t, device_t, void *);
|
|
static int dsedetach(device_t, int);
|
|
|
|
static void dse_ifstart(struct ifnet *);
|
|
static void dse_send_worker(struct work *wk, void *cookie);
|
|
|
|
static void dsedone(struct scsipi_xfer *, int);
|
|
static int dse_ioctl(struct ifnet *, u_long, void *);
|
|
static void dsewatchdog(struct ifnet *);
|
|
|
|
static void dse_recv_callout(void *);
|
|
static void dse_recv_worker(struct work *wk, void *cookie);
|
|
static void dse_recv(struct dse_softc *);
|
|
static struct mbuf* dse_get(struct dse_softc *, uint8_t *, int);
|
|
static int dse_read(struct dse_softc *, uint8_t *, int);
|
|
|
|
static int dse_init_adaptor(struct dse_softc *);
|
|
static int dse_get_addr(struct dse_softc *, uint8_t *);
|
|
static int dse_set_multi(struct dse_softc *);
|
|
|
|
static int dse_reset(struct dse_softc *);
|
|
|
|
#if 0 /* 07/16/2000 comment-out */
|
|
static int dse_set_mode(struct dse_softc *, int, int);
|
|
#endif
|
|
static int dse_init(struct dse_softc *);
|
|
static void dse_stop(struct dse_softc *);
|
|
|
|
#if 0
|
|
static __inline uint16_t ether_cmp(void *, void *);
|
|
#endif
|
|
|
|
static inline int dse_scsipi_cmd(struct scsipi_periph *periph,
|
|
struct scsipi_generic *scsipi_cmd,
|
|
int cmdlen, u_char *data_addr, int datalen,
|
|
int retries, int timeout, struct buf *bp,
|
|
int flags);
|
|
|
|
int dse_enable(struct dse_softc *);
|
|
void dse_disable(struct dse_softc *);
|
|
|
|
|
|
CFATTACH_DECL_NEW(dse, sizeof(struct dse_softc),
|
|
dsematch, dseattach, dsedetach, NULL);
|
|
|
|
extern struct cfdriver dse_cd;
|
|
|
|
dev_type_open(dseopen);
|
|
dev_type_close(dseclose);
|
|
dev_type_ioctl(dseioctl);
|
|
|
|
const struct cdevsw dse_cdevsw = {
|
|
.d_open = dseopen,
|
|
.d_close = dseclose,
|
|
.d_read = noread,
|
|
.d_write = nowrite,
|
|
.d_ioctl = dseioctl,
|
|
.d_stop = nostop,
|
|
.d_tty = notty,
|
|
.d_poll = nopoll,
|
|
.d_mmap = nommap,
|
|
.d_kqfilter = nokqfilter,
|
|
.d_discard = nodiscard,
|
|
.d_flag = D_OTHER | D_MPSAFE
|
|
};
|
|
|
|
const struct scsipi_periphsw dse_switch = {
|
|
|
|
NULL, /* Use default error handler */
|
|
NULL, /* have no queue */
|
|
NULL, /* have no async handler */
|
|
dsedone, /* deal with stats at interrupt time */
|
|
};
|
|
|
|
struct scsipi_inquiry_pattern dse_patterns[] = {
|
|
{ T_PROCESSOR, T_FIXED,
|
|
"Dayna", "SCSI/Link", "" },
|
|
};
|
|
|
|
|
|
|
|
/*====================================================
|
|
definitions for SCSI commands
|
|
====================================================*/
|
|
|
|
/*
|
|
* command templates
|
|
*/
|
|
/* unknown commands */
|
|
/* Vendor #1 */
|
|
static const scsi_dayna_ether_generic sonic_ether_vendor1 = {
|
|
{ DAYNA_CMD_VENDOR1, 0x00 },
|
|
0x00,
|
|
{ 0x00, 0x00 },
|
|
0x80
|
|
};
|
|
|
|
|
|
|
|
#if 0
|
|
/*
|
|
* Compare two Ether/802 addresses for equality, inlined and
|
|
* unrolled for speed.
|
|
* Note: use this like memcmp()
|
|
*/
|
|
static __inline uint16_t
|
|
ether_cmp(void *one, void *two)
|
|
{
|
|
uint16_t* a;
|
|
uint16_t* b;
|
|
uint16_t diff;
|
|
|
|
a = (uint16_t *) one;
|
|
b = (uint16_t *) two;
|
|
|
|
diff = (a[0] - b[0]) | (a[1] - b[1]) | (a[2] - b[2]);
|
|
|
|
return (diff);
|
|
}
|
|
|
|
#define ETHER_CMP ether_cmp
|
|
#endif
|
|
|
|
/*
|
|
* check to match with SCSI inquiry information
|
|
*/
|
|
static int
|
|
dsematch(device_t parent, cfdata_t match, void *aux)
|
|
{
|
|
struct scsipibus_attach_args *sa = aux;
|
|
int priority;
|
|
|
|
(void)scsipi_inqmatch(&sa->sa_inqbuf,
|
|
dse_patterns, sizeof(dse_patterns) / sizeof(dse_patterns[0]),
|
|
sizeof(dse_patterns[0]), &priority);
|
|
return priority;
|
|
}
|
|
|
|
|
|
/*
|
|
* The routine called by the low level scsi routine when it discovers
|
|
* a device suitable for this driver.
|
|
*/
|
|
static void
|
|
dseattach(device_t parent, device_t self, void *aux)
|
|
{
|
|
struct dse_softc *sc = device_private(self);
|
|
struct scsipibus_attach_args *sa = aux;
|
|
struct scsipi_periph *periph = sa->sa_periph;
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
uint8_t myaddr[ETHER_ADDR_LEN];
|
|
char wqname[MAXCOMLEN];
|
|
int rv;
|
|
|
|
sc->sc_dev = self;
|
|
|
|
aprint_normal("\n");
|
|
SC_DEBUG(periph, SCSIPI_DB2, ("dseattach: "));
|
|
|
|
sc->sc_attach_state = 0;
|
|
callout_init(&sc->sc_recv_ch, CALLOUT_MPSAFE);
|
|
callout_setfunc(&sc->sc_recv_ch, dse_recv_callout, (void *)sc);
|
|
mutex_init(&sc->sc_iflock, MUTEX_DEFAULT, IPL_SOFTNET);
|
|
|
|
/*
|
|
* Store information needed to contact our base driver
|
|
*/
|
|
sc->sc_periph = periph;
|
|
periph->periph_dev = sc->sc_dev;
|
|
periph->periph_switch = &dse_switch;
|
|
#if 0
|
|
sc_periph->sc_link_dbflags = SCSIPI_DB1;
|
|
#endif
|
|
|
|
dse_poll = mstohz(DSE_POLL);
|
|
dse_poll = dse_poll? dse_poll: 1;
|
|
dse_poll0 = mstohz(DSE_POLL0);
|
|
dse_poll0 = dse_poll0? dse_poll0: 1;
|
|
|
|
/*
|
|
* Initialize and attach send and receive buffers
|
|
*/
|
|
sc->sc_tbuf = malloc(ETHERMTU + sizeof(struct ether_header) +
|
|
DSE_EXTRAS_TX + 16, M_DEVBUF, M_WAITOK);
|
|
|
|
sc->sc_rbuf = malloc(RBUF_LEN + 16, M_DEVBUF, M_WAITOK);
|
|
|
|
/* initialize adaptor and obtain MAC address */
|
|
dse_init_adaptor(sc);
|
|
sc->sc_attach_state = 1;
|
|
|
|
/* Initialize ifnet structure. */
|
|
strcpy(ifp->if_xname, device_xname(sc->sc_dev));
|
|
ifp->if_softc = sc;
|
|
ifp->if_start = dse_ifstart;
|
|
ifp->if_ioctl = dse_ioctl;
|
|
ifp->if_watchdog = dsewatchdog;
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
|
|
ifp->if_extflags = IFEF_MPSAFE;
|
|
|
|
dse_get_addr(sc, myaddr);
|
|
|
|
/* Attach the interface. */
|
|
if_initialize(ifp);
|
|
|
|
snprintf(wqname, sizeof(wqname), "%sRx", device_xname(sc->sc_dev));
|
|
rv = workqueue_create(&sc->sc_recv_wq, wqname, dse_recv_worker, sc,
|
|
PRI_SOFTNET, IPL_NET, WQ_MPSAFE);
|
|
if (rv != 0) {
|
|
aprint_error_dev(sc->sc_dev,
|
|
"unable to create recv Rx workqueue\n");
|
|
dsedetach(sc->sc_dev, 0);
|
|
return; /* Error */
|
|
}
|
|
sc->sc_recv_work_pending = false;
|
|
sc->sc_attach_state = 2;
|
|
|
|
snprintf(wqname, sizeof(wqname), "%sTx", device_xname(sc->sc_dev));
|
|
rv = workqueue_create(&sc->sc_send_wq, wqname, dse_send_worker, ifp,
|
|
PRI_SOFTNET, IPL_NET, WQ_MPSAFE);
|
|
if (rv != 0) {
|
|
aprint_error_dev(sc->sc_dev,
|
|
"unable to create send Tx workqueue\n");
|
|
dsedetach(sc->sc_dev, 0);
|
|
return; /* Error */
|
|
}
|
|
sc->sc_send_work_pending = false;
|
|
sc->sc_ipq = if_percpuq_create(&sc->sc_ethercom.ec_if);
|
|
ether_ifattach(ifp, myaddr);
|
|
if_register(ifp);
|
|
sc->sc_attach_state = 4;
|
|
|
|
bpf_attach(ifp, DLT_EN10MB, sizeof(struct ether_header));
|
|
}
|
|
|
|
static int
|
|
dsedetach(device_t self, int flags)
|
|
{
|
|
struct dse_softc *sc = device_private(self);
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
|
|
switch(sc->sc_attach_state) {
|
|
case 4:
|
|
dse_stop(sc);
|
|
mutex_enter(&sc->sc_iflock);
|
|
ifp->if_flags &= ~IFF_RUNNING;
|
|
dse_disable(sc);
|
|
ether_ifdetach(ifp);
|
|
if_detach(ifp);
|
|
mutex_exit(&sc->sc_iflock);
|
|
if_percpuq_destroy(sc->sc_ipq);
|
|
/*FALLTHROUGH*/
|
|
case 3:
|
|
workqueue_destroy(sc->sc_send_wq);
|
|
/*FALLTHROUGH*/
|
|
case 2:
|
|
workqueue_destroy(sc->sc_recv_wq);
|
|
/*FALLTHROUGH*/
|
|
case 1:
|
|
free(sc->sc_rbuf, M_DEVBUF);
|
|
free(sc->sc_tbuf, M_DEVBUF);
|
|
callout_destroy(&sc->sc_recv_ch);
|
|
mutex_destroy(&sc->sc_iflock);
|
|
break;
|
|
default:
|
|
aprint_error_dev(sc->sc_dev, "detach failed (state %d)\n",
|
|
sc->sc_attach_state);
|
|
return 1;
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* submit SCSI command
|
|
*/
|
|
static __inline int
|
|
dse_scsipi_cmd(struct scsipi_periph *periph, struct scsipi_generic *cmd,
|
|
int cmdlen, u_char *data_addr, int datalen, int retries, int timeout,
|
|
struct buf *bp, int flags)
|
|
{
|
|
int error = 0;
|
|
|
|
error = scsipi_command(periph, cmd, cmdlen, data_addr,
|
|
datalen, retries, timeout, bp, flags);
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
/*
|
|
* Start routine for calling from network sub system
|
|
*/
|
|
static void
|
|
dse_ifstart(struct ifnet *ifp)
|
|
{
|
|
struct dse_softc *sc = ifp->if_softc;
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
if (!sc->sc_send_work_pending) {
|
|
sc->sc_send_work_pending = true;
|
|
workqueue_enqueue(sc->sc_send_wq, &sc->sc_send_work, NULL);
|
|
}
|
|
mutex_exit(&sc->sc_iflock);
|
|
if (sc->sc_flags & DSE_NEED_RECV) {
|
|
sc->sc_flags &= ~DSE_NEED_RECV;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Invoke the transmit workqueue and transmission on the interface.
|
|
*/
|
|
static void
|
|
dse_send_worker(struct work *wk, void *cookie)
|
|
{
|
|
struct ifnet *ifp = cookie;
|
|
struct dse_softc *sc = ifp->if_softc;
|
|
scsi_dayna_ether_generic cmd_send;
|
|
struct mbuf *m, *m0;
|
|
int len, error;
|
|
u_char *cp;
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
sc->sc_send_work_pending = false;
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
KASSERT(if_is_mpsafe(ifp));
|
|
|
|
/* Don't transmit if interface is busy or not running */
|
|
if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
|
|
return;
|
|
|
|
while (1) {
|
|
IFQ_DEQUEUE(&ifp->if_snd, m0);
|
|
if (m0 == NULL)
|
|
break;
|
|
/* If BPF is listening on this interface, let it see the
|
|
* packet before we commit it to the wire.
|
|
*/
|
|
bpf_mtap(ifp, m0, BPF_D_OUT);
|
|
|
|
/* We need to use m->m_pkthdr.len, so require the header */
|
|
if ((m0->m_flags & M_PKTHDR) == 0)
|
|
panic("ctscstart: no header mbuf");
|
|
len = m0->m_pkthdr.len;
|
|
|
|
/* Mark the interface busy. */
|
|
ifp->if_flags |= IFF_OACTIVE;
|
|
|
|
/* Chain; copy into linear buffer allocated at attach time. */
|
|
cp = sc->sc_tbuf;
|
|
for (m = m0; m != NULL; ) {
|
|
memcpy(cp, mtod(m, u_char *), m->m_len);
|
|
cp += m->m_len;
|
|
m = m0 = m_free(m);
|
|
}
|
|
if (len < DSE_MINSIZE) {
|
|
#ifdef DSE_DEBUG
|
|
if (sc->sc_debug)
|
|
aprint_error_dev(sc->sc_dev,
|
|
"packet size %d (%zu) < %d\n", len,
|
|
cp - (u_char *)sc->sc_tbuf, DSE_MINSIZE);
|
|
#endif
|
|
memset(cp, 0, DSE_MINSIZE - len);
|
|
len = DSE_MINSIZE;
|
|
}
|
|
|
|
/* Fill out SCSI command. */
|
|
memset(&cmd_send, 0, sizeof(cmd_send));
|
|
cmd_send.opcode[0] = DAYNA_CMD_SEND;
|
|
_lto2b(len, &(cmd_send.length[0]));
|
|
cmd_send.byte6 = 0x00;
|
|
|
|
/* Send command to device. */
|
|
error = dse_scsipi_cmd(sc->sc_periph,
|
|
(void *)&cmd_send, sizeof(cmd_send),
|
|
sc->sc_tbuf, len, DSE_RETRIES,
|
|
DSE_TIMEOUT, NULL, XS_CTL_NOSLEEP | XS_CTL_POLL |
|
|
XS_CTL_DATA_OUT);
|
|
if (error) {
|
|
aprint_error_dev(sc->sc_dev,
|
|
"not queued, error %d\n", error);
|
|
if_statinc(ifp, if_oerrors);
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
} else
|
|
if_statinc(ifp, if_opackets);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Called from the scsibus layer via our scsi device switch.
|
|
*/
|
|
static void
|
|
dsedone(struct scsipi_xfer *xs, int error)
|
|
{
|
|
struct dse_softc *sc = device_private(xs->xs_periph->periph_dev);
|
|
struct scsipi_generic *cmd = xs->cmd;
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
|
|
if (IS_SEND(cmd)) {
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
} else if (IS_RECV(cmd)) {
|
|
/* RECV complete */
|
|
/* pass data up. reschedule a recv */
|
|
/* scsipi_free_xs will call start. Harmless. */
|
|
|
|
if (error) {
|
|
/* Reschedule after a delay */
|
|
callout_schedule(&sc->sc_recv_ch, dse_poll);
|
|
} else {
|
|
int n, ntimeo;
|
|
n = dse_read(sc, xs->data, xs->datalen - xs->resid);
|
|
if (n > dse_max_received)
|
|
dse_max_received = n;
|
|
if (n == 0)
|
|
ntimeo = dse_poll;
|
|
else if (n >= RDATA_MAX)
|
|
ntimeo = dse_poll0;
|
|
else {
|
|
ntimeo = sc->sc_last_timeout;
|
|
ntimeo = (ntimeo * RDATA_GOAL)/n;
|
|
ntimeo = (ntimeo < dse_poll0?
|
|
dse_poll0: ntimeo);
|
|
ntimeo = (ntimeo > dse_poll?
|
|
dse_poll: ntimeo);
|
|
}
|
|
sc->sc_last_timeout = ntimeo;
|
|
callout_schedule(&sc->sc_recv_ch, ntimeo);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Setup a receive command by queuing the work.
|
|
* Usually called from a callout, but also from se_init().
|
|
*/
|
|
static void
|
|
dse_recv_callout(void *v)
|
|
{
|
|
/* do a recv command */
|
|
struct dse_softc *sc = (struct dse_softc *) v;
|
|
|
|
if (sc->sc_enabled == 0)
|
|
return;
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
if (sc->sc_recv_work_pending == true) {
|
|
callout_schedule(&sc->sc_recv_ch, dse_poll);
|
|
mutex_exit(&sc->sc_iflock);
|
|
return;
|
|
}
|
|
|
|
sc->sc_recv_work_pending = true;
|
|
workqueue_enqueue(sc->sc_recv_wq, &sc->sc_recv_work, NULL);
|
|
mutex_exit(&sc->sc_iflock);
|
|
}
|
|
|
|
/*
|
|
* Invoke the receive workqueue
|
|
*/
|
|
static void
|
|
dse_recv_worker(struct work *wk, void *cookie)
|
|
{
|
|
struct dse_softc *sc = (struct dse_softc *) cookie;
|
|
|
|
dse_recv(sc);
|
|
mutex_enter(&sc->sc_iflock);
|
|
sc->sc_recv_work_pending = false;
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
}
|
|
|
|
/*
|
|
* Do the actual work of receiving data.
|
|
*/
|
|
static void
|
|
dse_recv(struct dse_softc *sc)
|
|
{
|
|
scsi_dayna_ether_generic cmd_recv;
|
|
int error, len;
|
|
|
|
/* do a recv command */
|
|
/* fill out command buffer */
|
|
memset(&cmd_recv, 0, sizeof(cmd_recv));
|
|
cmd_recv.opcode[0] = DAYNA_CMD_RECV;
|
|
len = MAX_BYTES_RX + DSE_EXTRAS_RX;
|
|
_lto2b(len, &(cmd_recv.length[0]));
|
|
cmd_recv.byte6 = 0xC0;
|
|
|
|
error = dse_scsipi_cmd(sc->sc_periph,
|
|
(void *)&cmd_recv, sizeof(cmd_recv),
|
|
sc->sc_rbuf, RBUF_LEN, DSE_RETRIES, DSE_TIMEOUT, NULL,
|
|
XS_CTL_NOSLEEP | XS_CTL_POLL | XS_CTL_DATA_IN);
|
|
if (error)
|
|
callout_schedule(&sc->sc_recv_ch, dse_poll);
|
|
}
|
|
|
|
|
|
/*
|
|
* We copy the data into mbufs. When full cluster sized units are present
|
|
* we copy into clusters.
|
|
*/
|
|
static struct mbuf *
|
|
dse_get(struct dse_softc *sc, uint8_t *data, int totlen)
|
|
{
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
struct mbuf *m, *m0, *newm;
|
|
int len;
|
|
|
|
MGETHDR(m0, M_DONTWAIT, MT_DATA);
|
|
if (m0 == NULL)
|
|
return NULL;
|
|
|
|
m_set_rcvif(m0, ifp);
|
|
m0->m_pkthdr.len = totlen;
|
|
len = MHLEN;
|
|
m = m0;
|
|
|
|
while (totlen > 0) {
|
|
if (totlen >= MINCLSIZE) {
|
|
MCLGET(m, M_DONTWAIT);
|
|
if((m->m_flags & M_EXT) == 0)
|
|
goto bad;
|
|
|
|
len = MCLBYTES;
|
|
}
|
|
|
|
if (m == m0) {
|
|
char *newdata = (char *)
|
|
ALIGN(m->m_data + sizeof(struct ether_header)) -
|
|
sizeof(struct ether_header);
|
|
len -= newdata - m->m_data;
|
|
m->m_data = newdata;
|
|
}
|
|
|
|
m->m_len = len = uimin(totlen, len);
|
|
memcpy(mtod(m, void *), data, len);
|
|
data += len;
|
|
|
|
totlen -= len;
|
|
if (totlen > 0) {
|
|
MGET(newm, M_DONTWAIT, MT_DATA);
|
|
if (newm == NULL)
|
|
goto bad;
|
|
|
|
len = MLEN;
|
|
m = m->m_next = newm;
|
|
}
|
|
}
|
|
|
|
return m0;
|
|
|
|
bad:
|
|
m_freem(m0);
|
|
return NULL ;
|
|
}
|
|
|
|
|
|
#ifdef MAC68K_DEBUG
|
|
static int
|
|
peek_packet(uint8_t* buf)
|
|
{
|
|
struct ether_header *eh;
|
|
uint16_t type;
|
|
int len;
|
|
|
|
eh = (struct ether_header*)buf;
|
|
type = _2btol((uint8_t*)&(eh->ether_type));
|
|
|
|
len = sizeof(struct ether_header);
|
|
|
|
if (type <= ETHERMTU) {
|
|
/* for 802.3 */
|
|
len += type;
|
|
} else{
|
|
/* for Ethernet II (DIX) */
|
|
switch (type) {
|
|
case ETHERTYPE_ARP:
|
|
len += 28;
|
|
break;
|
|
case ETHERTYPE_IP:
|
|
len += _2btol(buf + sizeof(struct ether_header) + 2);
|
|
break;
|
|
default:
|
|
len = 0;
|
|
goto l_end;
|
|
break;
|
|
}
|
|
}
|
|
if (len < DSE_MINSIZE) {
|
|
len = DSE_MINSIZE;
|
|
}
|
|
len += ETHER_CRC_LEN;
|
|
|
|
l_end:;
|
|
return len;
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Pass packets to higher levels.
|
|
*/
|
|
static int
|
|
dse_read(struct dse_softc *sc, uint8_t *data, int datalen)
|
|
{
|
|
struct mbuf *m;
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
int len;
|
|
int n;
|
|
#ifdef MAC68K_DEBUG
|
|
int peek_flag = 1;
|
|
#endif
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
n = 0;
|
|
while (datalen >= DSE_HEADER_RX) {
|
|
/*
|
|
* fetch bytes of stream.
|
|
* here length = (ether frame length) + (FCS's 4 bytes)
|
|
*/
|
|
/* fetch frame length */
|
|
len = _2btol(data);
|
|
|
|
/* skip header part */
|
|
data += DSE_HEADER_RX;
|
|
datalen -= DSE_HEADER_RX;
|
|
|
|
#if 0 /* 03/10/2001 only for debug */
|
|
{
|
|
printf("DATALEN %d len %d\n", datalen, len);
|
|
int j;
|
|
printf("\ndump[%d]: ",n);
|
|
for ( j = 0 ; j < datalen ; j++ ) {
|
|
printf("%02X ",data[j-DSE_HEADER_RX]);
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef MAC68K_DEBUG
|
|
if (peek_flag) {
|
|
peek_flag = 0;
|
|
len = peek_packet(data);
|
|
}
|
|
#endif
|
|
if (len == 0)
|
|
break;
|
|
|
|
#ifdef DSE_DEBUG
|
|
aprint_error_dev(sc->sc_dev, "dse_read: datalen = %d, packetlen"
|
|
" = %d, proto = 0x%04x\n", datalen, len,
|
|
ntohs(((struct ether_header *)data)->ether_type));
|
|
#endif
|
|
if ((len < (DSE_MINSIZE + ETHER_CRC_LEN)) ||
|
|
(MAX_BYTES_RX < len)) {
|
|
#ifdef DSE_DEBUG
|
|
aprint_error_dev(sc->sc_dev, "invalid packet size "
|
|
"%d; dropping\n", len);
|
|
#endif
|
|
if_statinc(ifp, if_ierrors);
|
|
break;
|
|
}
|
|
|
|
/* Don't need crc. Must keep ether header for BPF */
|
|
m = dse_get(sc, data, len - ETHER_CRC_LEN);
|
|
if (m == NULL) {
|
|
#ifdef DSE_DEBUG
|
|
if (sc->sc_debug)
|
|
aprint_error_dev(sc->sc_dev, "dse_read: "
|
|
"dse_get returned null\n");
|
|
#endif
|
|
if_statinc(ifp, if_ierrors);
|
|
goto next_packet;
|
|
}
|
|
if_statinc(ifp, if_ipackets);
|
|
|
|
/*
|
|
* Check if there's a BPF listener on this interface.
|
|
* If so, hand off the raw packet to BPF.
|
|
*/
|
|
if (ifp->if_bpf)
|
|
bpf_mtap(ifp, m, BPF_D_OUT);
|
|
|
|
/* Pass the packet up. */
|
|
if_percpuq_enqueue(sc->sc_ipq, m);
|
|
|
|
next_packet:
|
|
data += len;
|
|
datalen -= len;
|
|
n++;
|
|
}
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
return n;
|
|
}
|
|
|
|
|
|
static void
|
|
dsewatchdog(struct ifnet *ifp)
|
|
{
|
|
struct dse_softc *sc = ifp->if_softc;
|
|
|
|
log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev));
|
|
if_statinc(ifp, if_oerrors);
|
|
|
|
dse_reset(sc);
|
|
}
|
|
|
|
|
|
static int
|
|
dse_reset(struct dse_softc *sc)
|
|
{
|
|
int error;
|
|
#if 0
|
|
/* Maybe we don't *really* want to reset the entire bus
|
|
* because the ctron isn't working. We would like to send a
|
|
* "BUS DEVICE RESET" message, but don't think the ctron
|
|
* understands it.
|
|
*/
|
|
error = dse_scsipi_cmd(sc->sc_periph, 0, 0, 0, 0, DSE_RETRIES, 2000,
|
|
NULL, XS_CTL_RESET);
|
|
#endif
|
|
error = dse_init(sc);
|
|
return error;
|
|
}
|
|
|
|
|
|
static int
|
|
dse_init_adaptor(struct dse_softc *sc)
|
|
{
|
|
scsi_dayna_ether_generic cmd_vend1;
|
|
u_char tmpbuf[sizeof(cmd_vend1)];
|
|
int error;
|
|
|
|
#if 0 /* 07/21/2001 for test */
|
|
/* Maybe we don't *really* want to reset the entire bus
|
|
* because the ctron isn't working. We would like to send a
|
|
* "BUS DEVICE RESET" message, but don't think the ctron
|
|
* understands it.
|
|
*/
|
|
error = dse_scsipi_cmd(sc->sc_periph, 0, 0, 0, 0, DSE_RETRIES,
|
|
2000, NULL, XS_CTL_RESET);
|
|
#endif
|
|
|
|
cmd_vend1 = sonic_ether_vendor1;
|
|
|
|
error = dse_scsipi_cmd(sc->sc_periph,
|
|
(struct scsipi_generic *)&cmd_vend1, sizeof(cmd_vend1),
|
|
&(tmpbuf[0]), sizeof(tmpbuf),
|
|
DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_POLL | XS_CTL_DATA_IN);
|
|
|
|
if (error)
|
|
goto l_end;
|
|
|
|
/* wait 500 msec */
|
|
kpause("dsesleep", false, hz / 2, NULL);
|
|
|
|
l_end:
|
|
return error;
|
|
}
|
|
|
|
|
|
static int
|
|
dse_get_addr(struct dse_softc *sc, uint8_t *myaddr)
|
|
{
|
|
scsi_dayna_ether_generic cmd_get_addr;
|
|
u_char tmpbuf[REQ_LEN_GET_ADDR];
|
|
int error;
|
|
|
|
memset(&cmd_get_addr, 0, sizeof(cmd_get_addr));
|
|
cmd_get_addr.opcode[0] = DAYNA_CMD_GET_ADDR;
|
|
_lto2b(REQ_LEN_GET_ADDR, cmd_get_addr.length);
|
|
|
|
error = dse_scsipi_cmd(sc->sc_periph,
|
|
(struct scsipi_generic *)&cmd_get_addr, sizeof(cmd_get_addr),
|
|
tmpbuf, sizeof(tmpbuf),
|
|
DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_POLL | XS_CTL_DATA_IN);
|
|
|
|
if (error == 0) {
|
|
memcpy(myaddr, &(tmpbuf[0]), ETHER_ADDR_LEN);
|
|
|
|
aprint_error_dev(sc->sc_dev, "ethernet address %s\n",
|
|
ether_sprintf(myaddr));
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
#if 0 /* 07/16/2000 comment-out */
|
|
static int
|
|
dse_set_mode(struct dse_softc *sc, int len, int mode)
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
static int
|
|
dse_init(struct dse_softc *sc)
|
|
{
|
|
struct ifnet *ifp = &sc->sc_ethercom.ec_if;
|
|
int error = 0;
|
|
|
|
if ((ifp->if_flags & (IFF_RUNNING | IFF_UP)) == IFF_UP) {
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
mutex_enter(&sc->sc_iflock);
|
|
if (!sc->sc_recv_work_pending) {
|
|
sc->sc_recv_work_pending = true;
|
|
workqueue_enqueue(sc->sc_recv_wq, &sc->sc_recv_work,
|
|
NULL);
|
|
}
|
|
mutex_exit(&sc->sc_iflock);
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
mutex_enter(&sc->sc_iflock);
|
|
if (!sc->sc_send_work_pending) {
|
|
sc->sc_send_work_pending = true;
|
|
workqueue_enqueue(sc->sc_send_wq, &sc->sc_send_work,
|
|
NULL);
|
|
}
|
|
mutex_exit(&sc->sc_iflock);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
|
|
static uint8_t BROADCAST_ADDR[ETHER_ADDR_LEN] =
|
|
{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
|
|
|
|
|
|
static int
|
|
dse_set_multi(struct dse_softc *sc)
|
|
{
|
|
scsi_dayna_ether_generic cmd_set_multi;
|
|
struct ether_multistep step;
|
|
struct ether_multi *enm;
|
|
u_char *cp, *mybuf;
|
|
int error, len;
|
|
|
|
error = 0;
|
|
|
|
#ifdef DSE_DEBUG
|
|
aprint_error_dev(sc->sc_dev, "dse_set_multi\n");
|
|
#endif
|
|
|
|
mybuf = malloc(ETHER_ADDR_LEN * DSE_MCAST_MAX, M_DEVBUF, M_NOWAIT);
|
|
if (mybuf == NULL) {
|
|
error = EIO;
|
|
goto l_end;
|
|
}
|
|
|
|
/*
|
|
* copy all entries to transfer buffer
|
|
*/
|
|
cp = mybuf;
|
|
len = 0;
|
|
ETHER_FIRST_MULTI(step, &(sc->sc_ethercom), enm);
|
|
while ((len < (DSE_MCAST_MAX - 1)) && (enm != NULL)) {
|
|
/* ### refer low side entry */
|
|
memcpy(cp, enm->enm_addrlo, ETHER_ADDR_LEN);
|
|
|
|
cp += ETHER_ADDR_LEN;
|
|
len++;
|
|
ETHER_NEXT_MULTI(step, enm);
|
|
}
|
|
|
|
/* add broadcast address as default */
|
|
memcpy(cp, BROADCAST_ADDR, ETHER_ADDR_LEN);
|
|
len++;
|
|
|
|
len *= ETHER_ADDR_LEN;
|
|
|
|
memset(&cmd_set_multi, 0, sizeof(cmd_set_multi));
|
|
cmd_set_multi.opcode[0] = DAYNA_CMD_SET_MULTI;
|
|
_lto2b(len, cmd_set_multi.length);
|
|
|
|
error = dse_scsipi_cmd(sc->sc_periph,
|
|
(struct scsipi_generic*)&cmd_set_multi, sizeof(cmd_set_multi),
|
|
mybuf, len, DSE_RETRIES, DSE_TIMEOUT, NULL, XS_CTL_POLL | XS_CTL_DATA_OUT);
|
|
|
|
free(mybuf, M_DEVBUF);
|
|
|
|
l_end:
|
|
return error;
|
|
}
|
|
|
|
|
|
static void
|
|
dse_stop(struct dse_softc *sc)
|
|
{
|
|
/* Don't schedule any reads */
|
|
callout_stop(&sc->sc_recv_ch);
|
|
|
|
/* Wait for the workqueues to finish */
|
|
mutex_enter(&sc->sc_iflock);
|
|
workqueue_wait(sc->sc_recv_wq, &sc->sc_recv_work);
|
|
workqueue_wait(sc->sc_send_wq, &sc->sc_send_work);
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
/* Abort any scsi cmds in progress */
|
|
mutex_enter(chan_mtx(sc->sc_periph->periph_channel));
|
|
scsipi_kill_pending(sc->sc_periph);
|
|
mutex_exit(chan_mtx(sc->sc_periph->periph_channel));
|
|
}
|
|
|
|
|
|
/*
|
|
* Process an ioctl request.
|
|
*/
|
|
static int
|
|
dse_ioctl(struct ifnet *ifp, u_long cmd, void *data)
|
|
{
|
|
struct dse_softc *sc;
|
|
struct ifaddr *ifa;
|
|
struct ifreq *ifr;
|
|
struct sockaddr *sa;
|
|
int error;
|
|
|
|
error = 0;
|
|
sc = ifp->if_softc;
|
|
ifa = (struct ifaddr *)data;
|
|
ifr = (struct ifreq *)data;
|
|
|
|
switch (cmd) {
|
|
case SIOCINITIFADDR:
|
|
mutex_enter(&sc->sc_iflock);
|
|
if ((error = dse_enable(sc)) != 0)
|
|
break;
|
|
ifp->if_flags |= IFF_UP;
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
#if 0
|
|
if ((error = dse_set_media(sc, CMEDIA_AUTOSENSE)) != 0)
|
|
break;
|
|
#endif
|
|
|
|
switch (ifa->ifa_addr->sa_family) {
|
|
#ifdef INET
|
|
case AF_INET:
|
|
if ((error = dse_init(sc)) != 0)
|
|
break;
|
|
arp_ifinit(ifp, ifa);
|
|
break;
|
|
#endif
|
|
#ifdef NETATALK
|
|
case AF_APPLETALK:
|
|
if ((error = dse_init(sc)) != 0)
|
|
break;
|
|
break;
|
|
#endif
|
|
default:
|
|
error = dse_init(sc);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case SIOCSIFADDR:
|
|
mutex_enter(&sc->sc_iflock);
|
|
error = dse_enable(sc);
|
|
mutex_exit(&sc->sc_iflock);
|
|
if (error != 0)
|
|
break;
|
|
ifp->if_flags |= IFF_UP;
|
|
|
|
switch (ifa->ifa_addr->sa_family) {
|
|
#ifdef INET
|
|
case AF_INET:
|
|
if ((error = dse_init(sc)) != 0)
|
|
break;
|
|
arp_ifinit(ifp, ifa);
|
|
break;
|
|
#endif
|
|
#ifdef NETATALK
|
|
case AF_APPLETALK:
|
|
if ((error = dse_init(sc)) != 0)
|
|
break;
|
|
break;
|
|
#endif
|
|
default:
|
|
error = dse_init(sc);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SIOCSIFFLAGS:
|
|
if ((error = ifioctl_common(ifp, cmd, data)) != 0)
|
|
break;
|
|
/* XXX re-use ether_ioctl() */
|
|
switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
|
|
case IFF_RUNNING:
|
|
/*
|
|
* If interface is marked down and it is running, then
|
|
* stop it.
|
|
*/
|
|
dse_stop(sc);
|
|
mutex_enter(&sc->sc_iflock);
|
|
ifp->if_flags &= ~IFF_RUNNING;
|
|
dse_disable(sc);
|
|
mutex_exit(&sc->sc_iflock);
|
|
break;
|
|
case IFF_UP:
|
|
/*
|
|
* If interface is marked up and it is stopped, then
|
|
* start it.
|
|
*/
|
|
mutex_enter(&sc->sc_iflock);
|
|
error = dse_enable(sc);
|
|
mutex_exit(&sc->sc_iflock);
|
|
if (error)
|
|
break;
|
|
error = dse_init(sc);
|
|
break;
|
|
default:
|
|
/*
|
|
* Reset the interface to pick up changes in any other
|
|
* flags that affect hardware registers.
|
|
*/
|
|
mutex_enter(&sc->sc_iflock);
|
|
if (sc->sc_enabled)
|
|
error = dse_init(sc);
|
|
mutex_exit(&sc->sc_iflock);
|
|
break;
|
|
}
|
|
#ifdef DSE_DEBUG
|
|
if (ifp->if_flags & IFF_DEBUG)
|
|
sc->sc_debug = 1;
|
|
else
|
|
sc->sc_debug = 0;
|
|
#endif
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
if (sc->sc_enabled == 0) {
|
|
error = EIO;
|
|
break;
|
|
}
|
|
mutex_enter(&sc->sc_iflock);
|
|
sa = sockaddr_dup(ifreq_getaddr(cmd, ifr), M_WAITOK);
|
|
mutex_exit(&sc->sc_iflock);
|
|
if (ether_addmulti(sa, &sc->sc_ethercom) == ENETRESET) {
|
|
error = dse_set_multi(sc);
|
|
#ifdef DSE_DEBUG
|
|
aprint_error_dev(sc->sc_dev, "add multi: %s\n",
|
|
ether_sprintf(ifr->ifr_addr.sa_data));
|
|
#endif
|
|
} else
|
|
error = 0;
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
sockaddr_free(sa);
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
break;
|
|
|
|
case SIOCDELMULTI:
|
|
if (sc->sc_enabled == 0) {
|
|
error = EIO;
|
|
break;
|
|
}
|
|
mutex_enter(&sc->sc_iflock);
|
|
sa = sockaddr_dup(ifreq_getaddr(cmd, ifr), M_WAITOK);
|
|
mutex_exit(&sc->sc_iflock);
|
|
if (ether_delmulti(sa, &sc->sc_ethercom) == ENETRESET) {
|
|
error = dse_set_multi(sc);
|
|
#ifdef DSE_DEBUG
|
|
aprint_error_dev(sc->sc_dev, "delete multi: %s\n",
|
|
ether_sprintf(ifr->ifr_addr.sa_data));
|
|
#endif
|
|
} else
|
|
error = 0;
|
|
|
|
mutex_enter(&sc->sc_iflock);
|
|
sockaddr_free(sa);
|
|
mutex_exit(&sc->sc_iflock);
|
|
|
|
break;
|
|
|
|
default:
|
|
error = ether_ioctl(ifp, cmd, data);
|
|
break;
|
|
}
|
|
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
/*
|
|
* Enable the network interface.
|
|
*/
|
|
int
|
|
dse_enable(struct dse_softc *sc)
|
|
{
|
|
struct scsipi_periph *periph = sc->sc_periph;
|
|
struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
|
|
int error = 0;
|
|
|
|
if (sc->sc_enabled == 0) {
|
|
if ((error = scsipi_adapter_addref(adapt)) == 0)
|
|
sc->sc_enabled = 1;
|
|
else
|
|
aprint_error_dev(sc->sc_dev, "device enable failed\n");
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
/*
|
|
* Disable the network interface.
|
|
*/
|
|
void
|
|
dse_disable(struct dse_softc *sc)
|
|
{
|
|
struct scsipi_periph *periph = sc->sc_periph;
|
|
struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
|
|
if (sc->sc_enabled != 0) {
|
|
scsipi_adapter_delref(adapt);
|
|
sc->sc_enabled = 0;
|
|
}
|
|
}
|
|
|
|
|
|
#define DSEUNIT(z) (minor(z))
|
|
|
|
/*
|
|
* open the device.
|
|
*/
|
|
int
|
|
dseopen(dev_t dev, int flag, int fmt, struct lwp *l)
|
|
{
|
|
int unit, error;
|
|
struct dse_softc *sc;
|
|
struct scsipi_periph *periph;
|
|
struct scsipi_adapter *adapt;
|
|
|
|
unit = DSEUNIT(dev);
|
|
sc = device_lookup_private(&dse_cd, unit);
|
|
if (sc == NULL)
|
|
return ENXIO;
|
|
|
|
periph = sc->sc_periph;
|
|
adapt = periph->periph_channel->chan_adapter;
|
|
|
|
if ((error = scsipi_adapter_addref(adapt)) != 0)
|
|
return error;
|
|
|
|
SC_DEBUG(periph, SCSIPI_DB1,
|
|
("scopen: dev=0x%"PRIx64" (unit %d (of %d))\n", dev, unit,
|
|
dse_cd.cd_ndevs));
|
|
|
|
periph->periph_flags |= PERIPH_OPEN;
|
|
|
|
SC_DEBUG(periph, SCSIPI_DB3, ("open complete\n"));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* close the device.. only called if we are the LAST
|
|
* occurence of an open device
|
|
*/
|
|
int
|
|
dseclose(dev_t dev, int flag, int fmt, struct lwp *l)
|
|
{
|
|
struct dse_softc *sc = device_lookup_private(&dse_cd, DSEUNIT(dev));
|
|
struct scsipi_periph *periph = sc->sc_periph;
|
|
struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter;
|
|
|
|
SC_DEBUG(sc->sc_periph, SCSIPI_DB1, ("closing\n"));
|
|
|
|
scsipi_wait_drain(periph);
|
|
|
|
scsipi_adapter_delref(adapt);
|
|
periph->periph_flags &= ~PERIPH_OPEN;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Perform special action on behalf of the user
|
|
* Only does generic scsi ioctls.
|
|
*/
|
|
int
|
|
dseioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
|
|
{
|
|
struct dse_softc *sc = device_lookup_private(&dse_cd, DSEUNIT(dev));
|
|
|
|
return (scsipi_do_ioctl(sc->sc_periph, dev, cmd, addr, flag, l));
|
|
}
|
|
|