2003-07-15 11:57:24 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2003
|
|
|
|
* Fraunhofer Institute for Open Communication Systems (FhG Fokus).
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* Author: Hartmut Brandt <harti@freebsd.org>
|
|
|
|
*
|
|
|
|
* Driver for IDT77252 based cards like ProSum's.
|
|
|
|
*/
|
2003-08-24 17:55:58 +00:00
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
2003-07-15 11:57:24 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include "opt_inet.h"
|
|
|
|
#include "opt_natm.h"
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/queue.h>
|
|
|
|
#include <sys/condvar.h>
|
|
|
|
#include <sys/endian.h>
|
|
|
|
#include <vm/uma.h>
|
|
|
|
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_media.h>
|
|
|
|
#include <net/if_atm.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#ifdef ENABLE_BPF
|
|
|
|
#include <net/bpf.h>
|
|
|
|
#endif
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/if_atm.h>
|
|
|
|
|
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <machine/resource.h>
|
|
|
|
#include <sys/bus.h>
|
|
|
|
#include <sys/rman.h>
|
|
|
|
#include <sys/mbpool.h>
|
|
|
|
|
|
|
|
#include <dev/utopia/utopia.h>
|
|
|
|
#include <dev/patm/idt77252reg.h>
|
|
|
|
#include <dev/patm/if_patmvar.h>
|
|
|
|
|
|
|
|
static void *patm_rcv_handle(struct patm_softc *sc, u_int handle);
|
|
|
|
static void patm_rcv_free(struct patm_softc *, void *, u_int handle);
|
|
|
|
static struct mbuf *patm_rcv_mbuf(struct patm_softc *, void *, u_int, int);
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
rct_write(struct patm_softc *sc, u_int cid, u_int w, u_int val)
|
|
|
|
{
|
|
|
|
patm_sram_write(sc, sc->mmap->rct + cid * IDT_RCT_ENTRY_SIZE + w, val);
|
|
|
|
}
|
|
|
|
static __inline u_int
|
|
|
|
rct_read(struct patm_softc *sc, u_int cid, u_int w)
|
|
|
|
{
|
|
|
|
return (patm_sram_read(sc, sc->mmap->rct +
|
|
|
|
cid * IDT_RCT_ENTRY_SIZE + w));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check if we can open this one */
|
|
|
|
int
|
|
|
|
patm_rx_vcc_can_open(struct patm_softc *sc, struct patm_vcc *vcc)
|
|
|
|
{
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* open the VCC
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
patm_rx_vcc_open(struct patm_softc *sc, struct patm_vcc *vcc)
|
|
|
|
{
|
|
|
|
uint32_t w1 = IDT_RCT_OPEN;
|
|
|
|
|
|
|
|
patm_debug(sc, VCC, "%u.%u RX opening", vcc->vcc.vpi, vcc->vcc.vci);
|
|
|
|
|
|
|
|
switch (vcc->vcc.aal) {
|
|
|
|
case ATMIO_AAL_0:
|
|
|
|
w1 |= IDT_RCT_AAL0 | IDT_RCT_FBP2 | IDT_RCT_RCI;
|
|
|
|
break;
|
|
|
|
case ATMIO_AAL_34:
|
|
|
|
w1 |= IDT_RCT_AAL34;
|
|
|
|
break;
|
|
|
|
case ATMIO_AAL_5:
|
|
|
|
w1 |= IDT_RCT_AAL5;
|
|
|
|
break;
|
|
|
|
case ATMIO_AAL_RAW:
|
|
|
|
w1 |= IDT_RCT_AALRAW | IDT_RCT_RCI;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vcc->cid != 0)
|
2003-07-26 14:57:26 +00:00
|
|
|
patm_sram_write4(sc, sc->mmap->rct + vcc->cid *
|
|
|
|
IDT_RCT_ENTRY_SIZE, w1, 0, 0, 0xffffffff);
|
2003-07-15 11:57:24 +00:00
|
|
|
else {
|
|
|
|
/* switch the interface into promiscuous mode */
|
|
|
|
patm_nor_write(sc, IDT_NOR_CFG, patm_nor_read(sc, IDT_NOR_CFG) |
|
|
|
|
IDT_CFG_ICAPT | IDT_CFG_VPECA);
|
|
|
|
}
|
|
|
|
|
|
|
|
vcc->vflags |= PATM_VCC_RX_OPEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* close the given vcc for transmission */
|
|
|
|
void
|
|
|
|
patm_rx_vcc_close(struct patm_softc *sc, struct patm_vcc *vcc)
|
|
|
|
{
|
|
|
|
u_int w1;
|
|
|
|
|
|
|
|
patm_debug(sc, VCC, "%u.%u RX closing", vcc->vcc.vpi, vcc->vcc.vci);
|
|
|
|
|
|
|
|
if (vcc->cid == 0) {
|
|
|
|
/* switch off promiscuous mode */
|
|
|
|
patm_nor_write(sc, IDT_NOR_CFG, patm_nor_read(sc, IDT_NOR_CFG) &
|
|
|
|
~(IDT_CFG_ICAPT | IDT_CFG_VPECA));
|
|
|
|
vcc->vflags &= ~PATM_VCC_RX_OPEN;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* close the connection but keep state */
|
|
|
|
w1 = rct_read(sc, vcc->cid, 0);
|
|
|
|
w1 &= ~IDT_RCT_OPEN;
|
|
|
|
rct_write(sc, vcc->cid, 0, w1);
|
|
|
|
|
|
|
|
/* minimum idle count */
|
|
|
|
w1 = (w1 & ~IDT_RCT_IACT_CNT_MASK) | (1 << IDT_RCT_IACT_CNT_SHIFT);
|
|
|
|
rct_write(sc, vcc->cid, 0, w1);
|
|
|
|
|
|
|
|
/* initialize scan */
|
|
|
|
patm_nor_write(sc, IDT_NOR_IRCP, vcc->cid);
|
|
|
|
|
|
|
|
vcc->vflags &= ~PATM_VCC_RX_OPEN;
|
|
|
|
vcc->vflags |= PATM_VCC_RX_CLOSING;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* check the RSQ
|
|
|
|
* This is a hack. The problem is, that although an entry is written
|
|
|
|
* to the RSQ, no interrupt is generated. Also we must wait 1 cell
|
|
|
|
* time for the SAR to process the scan of our connection.
|
|
|
|
*/
|
|
|
|
DELAY(1);
|
|
|
|
patm_intr_rsq(sc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* transmission side finally closed */
|
|
|
|
void
|
|
|
|
patm_rx_vcc_closed(struct patm_softc *sc, struct patm_vcc *vcc)
|
|
|
|
{
|
|
|
|
patm_debug(sc, VCC, "%u.%u RX finally closed",
|
|
|
|
vcc->vcc.vpi, vcc->vcc.vci);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle the given receive status queue entry
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
patm_rx(struct patm_softc *sc, struct idt_rsqe *rsqe)
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
void *buf;
|
|
|
|
u_int stat, cid, w, cells, len, h;
|
|
|
|
struct patm_vcc *vcc;
|
|
|
|
struct atm_pseudohdr aph;
|
|
|
|
u_char *trail;
|
|
|
|
|
|
|
|
cid = le32toh(rsqe->cid);
|
|
|
|
stat = le32toh(rsqe->stat);
|
|
|
|
h = le32toh(rsqe->handle);
|
|
|
|
|
|
|
|
cid = PATM_CID(sc, IDT_RSQE_VPI(cid), IDT_RSQE_VCI(cid));
|
|
|
|
vcc = sc->vccs[cid];
|
|
|
|
|
|
|
|
if (IDT_RSQE_TYPE(stat) == IDT_RSQE_IDLE) {
|
|
|
|
/* connection has gone idle */
|
|
|
|
if (stat & IDT_RSQE_BUF)
|
|
|
|
patm_rcv_free(sc, patm_rcv_handle(sc, h), h);
|
|
|
|
|
|
|
|
w = rct_read(sc, cid, 0);
|
|
|
|
if (w != 0 && !(w & IDT_RCT_OPEN))
|
|
|
|
rct_write(sc, cid, 0, 0);
|
|
|
|
if (vcc != NULL && (vcc->vflags & PATM_VCC_RX_CLOSING)) {
|
|
|
|
patm_debug(sc, VCC, "%u.%u RX closed", vcc->vcc.vpi,
|
|
|
|
vcc->vcc.vci);
|
|
|
|
vcc->vflags &= ~PATM_VCC_RX_CLOSING;
|
2003-08-06 13:09:36 +00:00
|
|
|
if (vcc->vcc.flags & ATMIO_FLAG_ASYNC) {
|
2003-07-15 11:57:24 +00:00
|
|
|
patm_rx_vcc_closed(sc, vcc);
|
|
|
|
if (!(vcc->vflags & PATM_VCC_OPEN))
|
|
|
|
patm_vcc_closed(sc, vcc);
|
|
|
|
} else
|
|
|
|
cv_signal(&sc->vcc_cv);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
buf = patm_rcv_handle(sc, h);
|
|
|
|
|
|
|
|
if (vcc == NULL || (vcc->vflags & PATM_VCC_RX_OPEN) == 0) {
|
|
|
|
patm_rcv_free(sc, buf, h);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cells = IDT_RSQE_CNT(stat);
|
|
|
|
KASSERT(cells > 0, ("zero cell count"));
|
|
|
|
|
|
|
|
if (vcc->vcc.aal == ATMIO_AAL_0) {
|
|
|
|
/* deliver this packet as it is */
|
|
|
|
if ((m = patm_rcv_mbuf(sc, buf, h, 1)) == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
m->m_len = cells * 48;
|
|
|
|
m->m_pkthdr.len = m->m_len;
|
|
|
|
m->m_pkthdr.rcvif = &sc->ifatm.ifnet;
|
|
|
|
|
|
|
|
} else if (vcc->vcc.aal == ATMIO_AAL_34) {
|
|
|
|
/* XXX AAL3/4 */
|
|
|
|
patm_rcv_free(sc, buf, h);
|
|
|
|
return;
|
|
|
|
|
|
|
|
} else if (vcc->vcc.aal == ATMIO_AAL_5) {
|
|
|
|
if (stat & IDT_RSQE_CRC) {
|
|
|
|
sc->ifatm.ifnet.if_ierrors++;
|
|
|
|
if (vcc->chain != NULL) {
|
|
|
|
m_freem(vcc->chain);
|
|
|
|
vcc->chain = vcc->last = NULL;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* append to current chain */
|
|
|
|
if (vcc->chain == NULL) {
|
|
|
|
if ((m = patm_rcv_mbuf(sc, buf, h, 1)) == NULL)
|
|
|
|
return;
|
|
|
|
m->m_len = cells * 48;
|
|
|
|
m->m_pkthdr.len = m->m_len;
|
|
|
|
m->m_pkthdr.rcvif = &sc->ifatm.ifnet;
|
|
|
|
vcc->chain = vcc->last = m;
|
|
|
|
} else {
|
|
|
|
if ((m = patm_rcv_mbuf(sc, buf, h, 0)) == NULL)
|
|
|
|
return;
|
|
|
|
m->m_len = cells * 48;
|
|
|
|
vcc->last->m_next = m;
|
|
|
|
vcc->last = m;
|
|
|
|
vcc->chain->m_pkthdr.len += m->m_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(stat & IDT_RSQE_EPDU))
|
|
|
|
return;
|
|
|
|
|
|
|
|
trail = mtod(m, u_char *) + m->m_len - 6;
|
|
|
|
len = (trail[0] << 8) + trail[1];
|
|
|
|
|
|
|
|
if ((u_int)vcc->chain->m_pkthdr.len < len + 8) {
|
|
|
|
patm_printf(sc, "%s: bad aal5 lengths %u %u\n",
|
|
|
|
__func__, (u_int)m->m_pkthdr.len, len);
|
|
|
|
m_freem(vcc->chain);
|
|
|
|
vcc->chain = vcc->last = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m->m_len -= vcc->chain->m_pkthdr.len - len;
|
|
|
|
KASSERT(m->m_len >= 0, ("bad last mbuf"));
|
|
|
|
|
|
|
|
m = vcc->chain;
|
|
|
|
vcc->chain = vcc->last = NULL;
|
|
|
|
m->m_pkthdr.len = len;
|
|
|
|
} else
|
|
|
|
panic("bad aal");
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
{
|
|
|
|
u_int i;
|
|
|
|
|
|
|
|
for (i = 0; i < m->m_len; i++) {
|
|
|
|
printf("%02x ", mtod(m, u_char *)[i]);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
sc->ifatm.ifnet.if_ipackets++;
|
|
|
|
/* this is in if_atmsubr.c */
|
|
|
|
/* sc->ifatm.ifnet.if_ibytes += m->m_pkthdr.len; */
|
|
|
|
|
|
|
|
vcc->ibytes += m->m_pkthdr.len;
|
|
|
|
vcc->ipackets++;
|
|
|
|
|
|
|
|
ATM_PH_FLAGS(&aph) = vcc->vcc.flags & 0xff;
|
|
|
|
ATM_PH_VPI(&aph) = IDT_RSQE_VPI(cid);
|
|
|
|
ATM_PH_SETVCI(&aph, IDT_RSQE_VCI(cid));
|
|
|
|
|
|
|
|
#ifdef ENABLE_BPF
|
|
|
|
if (!(vcc->vcc.flags & ATMIO_FLAG_NG) &&
|
2003-08-06 13:09:36 +00:00
|
|
|
(vcc->vcc.aal == ATMIO_AAL_5) &&
|
2003-07-15 11:57:24 +00:00
|
|
|
(vcc->vcc.flags & ATM_PH_LLCSNAP))
|
|
|
|
BPF_MTAP(&sc->ifatm.ifnet, m);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
atm_input(&sc->ifatm.ifnet, &aph, m, vcc->rxhand);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the buffer for a receive handle. This is either an mbuf for
|
|
|
|
* a large handle or a pool buffer for the others.
|
|
|
|
*/
|
|
|
|
static void *
|
|
|
|
patm_rcv_handle(struct patm_softc *sc, u_int handle)
|
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
u_int c;
|
|
|
|
|
|
|
|
if ((handle & ~MBUF_HMASK) == LMBUF_HANDLE) {
|
|
|
|
struct lmbuf *b;
|
|
|
|
|
|
|
|
c = handle & MBUF_HMASK;
|
|
|
|
b = &sc->lbufs[c];
|
|
|
|
|
|
|
|
buf = b->m;
|
|
|
|
b->m = NULL;
|
|
|
|
|
|
|
|
bus_dmamap_sync(sc->lbuf_tag, b->map, BUS_DMASYNC_POSTREAD);
|
|
|
|
patm_lbuf_free(sc, b);
|
|
|
|
|
|
|
|
} else if ((handle & ~MBUF_HMASK) == MBUF_VHANDLE) {
|
|
|
|
mbp_sync(sc->vbuf_pool, handle,
|
|
|
|
0, VMBUF_SIZE, BUS_DMASYNC_POSTREAD);
|
|
|
|
buf = mbp_get(sc->vbuf_pool, handle);
|
|
|
|
|
|
|
|
} else {
|
|
|
|
mbp_sync(sc->sbuf_pool, handle,
|
|
|
|
0, SMBUF_SIZE, BUS_DMASYNC_POSTREAD);
|
|
|
|
buf = mbp_get(sc->sbuf_pool, handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free a buffer.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
patm_rcv_free(struct patm_softc *sc, void *p, u_int handle)
|
|
|
|
{
|
|
|
|
if ((handle & ~MBUF_HMASK) == LMBUF_HANDLE)
|
|
|
|
m_free((struct mbuf *)p);
|
|
|
|
|
|
|
|
else if ((handle & ~MBUF_HMASK) == MBUF_VHANDLE)
|
|
|
|
mbp_free(sc->vbuf_pool, p);
|
|
|
|
|
|
|
|
else
|
|
|
|
mbp_free(sc->sbuf_pool, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make an mbuf around the buffer
|
|
|
|
*/
|
|
|
|
static struct mbuf *
|
|
|
|
patm_rcv_mbuf(struct patm_softc *sc, void *buf, u_int h, int hdr)
|
|
|
|
{
|
|
|
|
struct mbuf *m;
|
|
|
|
|
|
|
|
if ((h & ~MBUF_HMASK) == MBUF_LHANDLE)
|
|
|
|
return ((struct mbuf *)buf);
|
|
|
|
|
|
|
|
if (hdr)
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
|
|
else
|
|
|
|
MGET(m, M_DONTWAIT, MT_DATA);
|
|
|
|
if (m == NULL) {
|
|
|
|
patm_rcv_free(sc, buf, h);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((h & ~MBUF_HMASK) == MBUF_VHANDLE) {
|
|
|
|
m_extadd(m, (caddr_t)buf, VMBUF_SIZE, mbp_ext_free,
|
|
|
|
sc->vbuf_pool, M_PKTHDR, EXT_NET_DRV);
|
|
|
|
m->m_data += VMBUF_OFFSET;
|
|
|
|
} else {
|
|
|
|
m_extadd(m, (caddr_t)buf, SMBUF_SIZE, mbp_ext_free,
|
|
|
|
sc->sbuf_pool, M_PKTHDR, EXT_NET_DRV);
|
|
|
|
m->m_data += SMBUF_OFFSET;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(m->m_flags & M_EXT)) {
|
|
|
|
patm_rcv_free(sc, buf, h);
|
|
|
|
m_free(m);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
return (m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process the raw cell at the given address.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
patm_rx_raw(struct patm_softc *sc, u_char *cell)
|
|
|
|
{
|
|
|
|
u_int vpi, vci, cid;
|
|
|
|
struct patm_vcc *vcc;
|
|
|
|
struct mbuf *m;
|
|
|
|
u_char *dst;
|
|
|
|
struct timespec ts;
|
|
|
|
struct atm_pseudohdr aph;
|
|
|
|
uint64_t cts;
|
|
|
|
|
|
|
|
sc->stats.raw_cells++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For some non-appearant reason the cell header
|
|
|
|
* is in the wrong endian.
|
|
|
|
*/
|
|
|
|
*(uint32_t *)cell = bswap32(*(uint32_t *)cell);
|
|
|
|
|
|
|
|
vpi = ((cell[0] & 0xf) << 4) | ((cell[1] & 0xf0) >> 4);
|
|
|
|
vci = ((cell[1] & 0xf) << 12) | (cell[2] << 4) | ((cell[3] & 0xf0) >> 4);
|
|
|
|
cid = PATM_CID(sc, vpi, vci);
|
|
|
|
|
|
|
|
vcc = sc->vccs[cid];
|
|
|
|
if (vcc == NULL || !(vcc->vflags & PATM_VCC_RX_OPEN) ||
|
|
|
|
vcc->vcc.aal != ATMIO_AAL_RAW) {
|
|
|
|
vcc = sc->vccs[0];
|
|
|
|
if (vcc == NULL || !(vcc->vflags & PATM_VCC_RX_OPEN)) {
|
|
|
|
sc->stats.raw_no_vcc++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
|
|
if (m == NULL) {
|
|
|
|
sc->stats.raw_no_buf++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m->m_pkthdr.rcvif = &sc->ifatm.ifnet;
|
|
|
|
|
|
|
|
switch (vcc->vflags & PATM_RAW_FORMAT) {
|
|
|
|
|
|
|
|
default:
|
|
|
|
case PATM_RAW_CELL:
|
|
|
|
m->m_len = m->m_pkthdr.len = 53;
|
|
|
|
MH_ALIGN(m, 53);
|
|
|
|
dst = mtod(m, u_char *);
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = 0; /* HEC */
|
|
|
|
bcopy(cell + 12, dst, 48);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PATM_RAW_NOHEC:
|
|
|
|
m->m_len = m->m_pkthdr.len = 52;
|
|
|
|
MH_ALIGN(m, 52);
|
|
|
|
dst = mtod(m, u_char *);
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
bcopy(cell + 12, dst, 48);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PATM_RAW_CS:
|
|
|
|
m->m_len = m->m_pkthdr.len = 64;
|
|
|
|
MH_ALIGN(m, 64);
|
|
|
|
dst = mtod(m, u_char *);
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = *cell++;
|
|
|
|
*dst++ = 0; /* HEC */
|
|
|
|
*dst++ = 0; /* flags */
|
|
|
|
*dst++ = 0; /* reserved */
|
|
|
|
*dst++ = 0; /* reserved */
|
|
|
|
nanotime(&ts);
|
|
|
|
cts = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
|
|
|
|
bcopy(dst, &cts, 8);
|
|
|
|
bcopy(cell + 12, dst + 8, 48);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->ifatm.ifnet.if_ipackets++;
|
|
|
|
/* this is in if_atmsubr.c */
|
|
|
|
/* sc->ifatm.ifnet.if_ibytes += m->m_pkthdr.len; */
|
|
|
|
|
|
|
|
vcc->ibytes += m->m_pkthdr.len;
|
|
|
|
vcc->ipackets++;
|
|
|
|
|
|
|
|
ATM_PH_FLAGS(&aph) = vcc->vcc.flags & 0xff;
|
|
|
|
ATM_PH_VPI(&aph) = vcc->vcc.vpi;
|
|
|
|
ATM_PH_SETVCI(&aph, vcc->vcc.vci);
|
|
|
|
|
|
|
|
atm_input(&sc->ifatm.ifnet, &aph, m, vcc->rxhand);
|
|
|
|
}
|