mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-23 11:18:54 +00:00
370f7f7c05
- Wrap idt_atm_harpconn() in conditional define T_ATM_BUFQUEUE
767 lines
19 KiB
C
767 lines
19 KiB
C
/*
|
|
* Copyright (c) 2000, 2001 Richard Hodges and Matriplex, inc.
|
|
* 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 Matriplex, inc.
|
|
* 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.
|
|
*
|
|
******************************************************************************
|
|
*
|
|
* This driver is derived from the Nicstar driver by Mark Tinguely, and
|
|
* some of the original driver still exists here. Those portions are...
|
|
* Copyright (c) 1996, 1997, 1998, 1999 Mark Tinguely
|
|
* All rights reserved.
|
|
*
|
|
******************************************************************************
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/syslog.h>
|
|
|
|
#include <sys/bus.h>
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/module.h>
|
|
#include <machine/bus_memio.h>
|
|
#include <machine/bus.h>
|
|
#include <machine/resource.h>
|
|
#include <sys/rman.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/if_arp.h>
|
|
#include <net/netisr.h>
|
|
#include <net/if_var.h>
|
|
|
|
#include <netatm/port.h>
|
|
#include <netatm/queue.h>
|
|
#include <netatm/atm.h>
|
|
#include <netatm/atm_sys.h>
|
|
#include <netatm/atm_sap.h>
|
|
#include <netatm/atm_cm.h>
|
|
#include <netatm/atm_if.h>
|
|
#include <netatm/atm_stack.h>
|
|
#include <netatm/atm_pcb.h>
|
|
#include <netatm/atm_var.h>
|
|
#include <netatm/atm_vc.h>
|
|
|
|
#include <dev/idt/idtreg.h>
|
|
#include <dev/idt/idtvar.h>
|
|
|
|
/******************************************************************************
|
|
*
|
|
* HARP-specific definitions
|
|
*
|
|
*/
|
|
|
|
#define IDT_DEV_NAME "idt"
|
|
|
|
#define IDT_IFF_MTU 9188
|
|
#define IDT_MAX_VCI 1023 /* 0 - 1023 */
|
|
#define IDT_MAX_VPI 0
|
|
|
|
#define iv_next iv_cmn.cv_next
|
|
#define iv_toku iv_cmn.cv_toku
|
|
#define iv_upper iv_cmn.cv_upper
|
|
#define iv_vccb iv_cmn.cv_connvc /* HARP 3.0 */
|
|
#define iv_state iv_cmn.cv_state
|
|
#define iu_pif iu_cmn.cu_pif
|
|
#define iu_unit iu_cmn.cu_unit
|
|
#define iu_flags iu_cmn.cu_flags
|
|
#define iu_mtu iu_cmn.cu_mtu
|
|
#define iu_open_vcc iu_cmn.cu_open_vcc
|
|
#define iu_instvcc iu_cmn.cu_instvcc /* HARP 3.0 */
|
|
#define iu_vcc iu_cmn.cu_vcc
|
|
#define iu_vcc_zone iu_cmn.cu_vcc_zone
|
|
#define iu_nif_zone iu_cmn.cu_nif_zone
|
|
#define iu_ioctl iu_cmn.cu_ioctl
|
|
#define iu_openvcc iu_cmn.cu_openvcc
|
|
#define iu_closevcc iu_cmn.cu_closevcc
|
|
#define iu_output iu_cmn.cu_output
|
|
#define iu_config iu_cmn.cu_config
|
|
#define iu_softc iu_cmn.cu_softc
|
|
|
|
/*
|
|
* ATM Interface services
|
|
*/
|
|
static struct stack_defn idt_svaal5 = {
|
|
NULL,
|
|
SAP_CPCS_AAL5,
|
|
SDF_TERM,
|
|
atm_dev_inst,
|
|
atm_dev_lower,
|
|
NULL,
|
|
0,
|
|
};
|
|
static struct stack_defn idt_svaal4 = {
|
|
&idt_svaal5,
|
|
SAP_CPCS_AAL3_4,
|
|
SDF_TERM,
|
|
atm_dev_inst,
|
|
atm_dev_lower,
|
|
NULL,
|
|
0,
|
|
};
|
|
static struct stack_defn idt_svaal0 = {
|
|
&idt_svaal4,
|
|
SAP_ATM,
|
|
SDF_TERM,
|
|
atm_dev_inst,
|
|
atm_dev_lower,
|
|
NULL,
|
|
0,
|
|
};
|
|
struct stack_defn *idt_services = &idt_svaal0;
|
|
|
|
extern uma_zone_t idt_nif_zone;
|
|
extern uma_zone_t idt_vcc_zone;
|
|
|
|
static int idt_atm_bearerclass(struct attr_bearer *);
|
|
#ifdef T_ATM_BUFQUEUE
|
|
static CONNECTION *idt_atm_harpconn(Cmn_unit *, Cmn_vcc *);
|
|
#endif
|
|
static int idt_atm_ioctl(int, caddr_t, caddr_t);
|
|
|
|
static void idt_output(Cmn_unit *, Cmn_vcc *, KBuffer *);
|
|
static int idt_openvcc(Cmn_unit *, Cmn_vcc *);
|
|
static int idt_closevcc(Cmn_unit *, Cmn_vcc *);
|
|
static int idt_instvcc(Cmn_unit *, Cmn_vcc *);
|
|
|
|
static void idt_recv_stack(void *, KBuffer *);
|
|
|
|
/******************************************************************************
|
|
*
|
|
* HARP GLUE SECTION
|
|
*
|
|
******************************************************************************
|
|
*
|
|
* Handle netatm core service interface ioctl requests
|
|
*
|
|
* Called at splnet.
|
|
*
|
|
* Arguments:
|
|
* code ioctl function (sub)code
|
|
* data data to/from ioctl
|
|
* arg optional code-specific argument
|
|
*
|
|
* Returns:
|
|
* 0 request processed successfully
|
|
* error request failed - reason code
|
|
*
|
|
*/
|
|
static int
|
|
idt_atm_ioctl(int code, caddr_t addr, caddr_t arg)
|
|
{
|
|
#ifdef T_ATM_BUFQUEUE
|
|
CONNECTION *connection;
|
|
TX_QUEUE *txq;
|
|
struct mbuf *m;
|
|
Cmn_unit *cup;
|
|
Cmn_vcc *cvp;
|
|
int retval;
|
|
#endif
|
|
|
|
switch (code) {
|
|
|
|
#ifdef T_ATM_BUFQUEUE
|
|
case T_ATM_BUFQUEUE:
|
|
cup = (Cmn_unit *) addr;
|
|
cvp = (Cmn_vcc *) arg;
|
|
connection = idt_atm_harpconn(cup, cvp);
|
|
if (connection == NULL)
|
|
return (-1);
|
|
retval = 0;
|
|
txq = connection->queue;
|
|
if (txq == NULL)
|
|
return (-1);
|
|
for (m = txq->mget; m != NULL; m = m->m_nextpkt)
|
|
retval += m->m_pkthdr.len;
|
|
return (retval);
|
|
#endif
|
|
}
|
|
|
|
return (ENOSYS);
|
|
}
|
|
|
|
#ifdef T_ATM_BUFQUEUE
|
|
/*******************************************************************************
|
|
*
|
|
* Get connection pointer from Cmn_unit and Cmn_vcc
|
|
*
|
|
* in: Cmn_unit and Cmn_vcc
|
|
* out: connection (NULL=error)
|
|
*
|
|
* Date first: 05/31/2001 last: 05/31/2001
|
|
*/
|
|
|
|
static CONNECTION *
|
|
idt_atm_harpconn(Cmn_unit * cup, Cmn_vcc * cvp)
|
|
{
|
|
struct vccb *vccinf; /* from HARP struct */
|
|
IDT *idt;
|
|
int vpi;
|
|
int vci;
|
|
|
|
idt = (IDT *) cup;
|
|
if (idt == NULL || cvp == NULL)
|
|
return (NULL);
|
|
|
|
if (cvp->cv_connvc == NULL)
|
|
return (NULL);
|
|
|
|
vccinf = cvp->cv_connvc->cvc_vcc;
|
|
|
|
if (vccinf == NULL)
|
|
return (NULL);
|
|
|
|
vpi = vccinf->vc_vpi;
|
|
vci = vccinf->vc_vci;
|
|
|
|
return (idt_connect_find(idt, vpi, vci));
|
|
}
|
|
#endif /* T_ATM_BUFQUEUE */
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Get CBR/VBR/UBR class from bearer attribute
|
|
*
|
|
* in:
|
|
* out: NICCBR/NICVBR/NICABR/NICUBR
|
|
*
|
|
* Date first: 06/12/2001 last: 06/13/2001
|
|
*/
|
|
|
|
static int
|
|
idt_atm_bearerclass(struct attr_bearer * bearer)
|
|
{
|
|
switch (bearer->v.bearer_class) {
|
|
case T_ATM_CLASS_A:return (NICCBR);
|
|
case T_ATM_CLASS_C:
|
|
if (idt_sysctl_vbriscbr)
|
|
return (NICCBR); /* use CBR slots for VBR VC's */
|
|
else
|
|
return (NICVBR);
|
|
case T_ATM_CLASS_X:
|
|
if (bearer->v.traffic_type == T_ATM_CBR)
|
|
return (NICCBR);
|
|
if (bearer->v.traffic_type == T_ATM_VBR)
|
|
return (NICVBR);
|
|
return (NICUBR);
|
|
}
|
|
return (NICUBR);
|
|
}
|
|
|
|
/* The flag idt_sysctl_vbriscbr allows us to set up a CBR VC as if it were
|
|
* VBR. This is primarily to avoid cell loss at a switch that cannot seem
|
|
* to buffer one or two cells of jitter. This jitter is created when many
|
|
* CBR slots have been taken, and a new CBR VC cannot use the optimally
|
|
* spaced slots, and has to use nearby slots instead.
|
|
*
|
|
* In this case, we want to use the VC SCR as the CBR value. The PCR and MBS
|
|
* is only of interest to the switch.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* Initialize HARP service
|
|
* called from device attach
|
|
*/
|
|
|
|
int
|
|
idt_harp_init(nicstar_reg_t *idt)
|
|
{
|
|
long long tsc_val;
|
|
u_char idt_mac[6];
|
|
int i;
|
|
int error;
|
|
|
|
error = 0;
|
|
|
|
/*
|
|
* Start initializing it
|
|
*/
|
|
idt->iu_unit = device_get_unit(idt->dev);
|
|
idt->iu_mtu = IDT_IFF_MTU;
|
|
idt->iu_ioctl = idt_atm_ioctl;
|
|
idt->iu_openvcc = idt_openvcc;
|
|
idt->iu_instvcc = idt_instvcc;
|
|
idt->iu_closevcc = idt_closevcc;
|
|
idt->iu_output = idt_output;
|
|
idt->iu_vcc_zone = idt_vcc_zone;
|
|
idt->iu_nif_zone = idt_nif_zone;
|
|
idt->iu_softc = (void *)idt;
|
|
|
|
/*
|
|
* Copy serial number into config space
|
|
*/
|
|
idt->iu_config.ac_serial = 0;
|
|
|
|
idt->iu_config.ac_vendor = VENDOR_IDT;
|
|
idt->iu_config.ac_vendapi = VENDAPI_IDT_1;
|
|
idt->iu_config.ac_device = DEV_IDT_155;
|
|
idt->iu_config.ac_media = MEDIA_UNKNOWN;
|
|
idt->iu_config.ac_bustype = BUS_PCI;
|
|
|
|
idt->iu_pif.pif_pcr = idt->cellrate_rmax; /* ATM_PCR_OC3C; */
|
|
idt->iu_pif.pif_maxvpi = idt->conn_maxvpi;
|
|
idt->iu_pif.pif_maxvci = idt->conn_maxvci;
|
|
|
|
snprintf(idt->iu_config.ac_hard_vers,
|
|
sizeof(idt->iu_config.ac_hard_vers),
|
|
idt->hardware);
|
|
snprintf(idt->iu_config.ac_firm_vers,
|
|
sizeof(idt->iu_config.ac_firm_vers),
|
|
IDT_VERSION);
|
|
/*
|
|
* Save device ram info for user-level programs NOTE: This really
|
|
* points to start of EEPROM and includes all the device registers
|
|
* in the lower 2 Megabytes.
|
|
*/
|
|
idt->iu_config.ac_ram = NULL;
|
|
idt->iu_config.ac_ramsize = 0;
|
|
|
|
for (i = 0; i < 6; i++) {
|
|
idt_mac[i] = nicstar_eeprom_rd(idt, (0x6c + i));
|
|
}
|
|
|
|
/* looks like bad MAC */
|
|
if ((idt_mac[3] | idt_mac[4] | idt_mac[5]) == 0) {
|
|
GET_RDTSC(tsc_val); /* 24 bits on 500mhz CPU is about
|
|
* 30msec */
|
|
idt_mac[0] = 0x00;
|
|
idt_mac[1] = 0x20;
|
|
idt_mac[2] = 0x48; /* use Fore prefix */
|
|
idt_mac[3] = (tsc_val >> 16) & 0xff;
|
|
idt_mac[4] = (tsc_val >> 8) & 0xff;
|
|
idt_mac[5] = (tsc_val) & 0xff;
|
|
device_printf(idt->dev,
|
|
"Cannot read MAC address from EEPROM, generating it.\n");
|
|
}
|
|
bcopy(&idt_mac, &idt->iu_pif.pif_macaddr.ma_data, sizeof(idt_mac));
|
|
|
|
device_printf(idt->dev, "MAC address %6D, HWrev=%d\n",
|
|
(u_int8_t *)&idt->iu_pif.pif_macaddr.ma_data, ":",
|
|
idt->pci_rev);
|
|
|
|
idt->iu_config.ac_macaddr = idt->iu_pif.pif_macaddr;
|
|
|
|
/*
|
|
* Register this interface with ATM core services
|
|
*/
|
|
error = atm_physif_register(&idt->iu_cmn, IDT_DEV_NAME, idt_services);
|
|
if (error != 0) {
|
|
/*
|
|
* Registration failed - back everything out
|
|
*/
|
|
|
|
log(LOG_ERR, "%s(): atm_physif_register failed\n", __func__);
|
|
return (error);
|
|
}
|
|
idt->iu_flags |= CUF_INITED;
|
|
|
|
#if BSD >= 199506
|
|
/*
|
|
* Add hook to out shutdown function at_shutdown (
|
|
* (bootlist_fn)idt_pci_shutdown, idt, SHUTDOWN_POST_SYNC );
|
|
*/
|
|
#endif
|
|
|
|
return (error);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Output data
|
|
*/
|
|
|
|
static void
|
|
idt_output(Cmn_unit * cmnunit, Cmn_vcc * cmnvcc, KBuffer * m)
|
|
{
|
|
struct vccb *vccinf; /* from HARP struct */
|
|
IDT *idt;
|
|
int vpi;
|
|
int vci;
|
|
int flags;
|
|
|
|
idt = (IDT *) cmnunit;
|
|
flags = 0;
|
|
|
|
if (cmnvcc == NULL) {
|
|
device_printf(idt->dev, "idt_output arg error #1\n");
|
|
goto bad;
|
|
}
|
|
if (cmnvcc->cv_connvc == NULL) {
|
|
device_printf(idt->dev, "idt_output arg error #2\n");
|
|
goto bad;
|
|
}
|
|
vccinf = cmnvcc->cv_connvc->cvc_vcc;
|
|
if (vccinf == NULL) {
|
|
device_printf(idt->dev, "idt_output arg error #3\n");
|
|
goto bad;
|
|
}
|
|
vpi = vccinf->vc_vpi;
|
|
vci = vccinf->vc_vci;
|
|
|
|
#ifdef CVF_MPEG2TS /* option to split bufs into small TS bufs */
|
|
if (cmnvcc->cv_flags & CVF_MPEG2TS)
|
|
flags = 1;
|
|
#endif
|
|
|
|
idt_transmit(idt, m, vpi, vci, flags);
|
|
|
|
return;
|
|
bad:
|
|
m_freem(m);
|
|
return;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Open VCC
|
|
*/
|
|
|
|
static int
|
|
idt_openvcc(Cmn_unit * cmnunit, Cmn_vcc * cmnvcc)
|
|
{
|
|
Atm_attributes *attrib; /* from HARP struct */
|
|
struct vccb *vccinf; /* from HARP struct */
|
|
CONNECTION *connection;
|
|
IDT *idt;
|
|
int vpi;
|
|
int vci;
|
|
int class; /* NICCBR, NICVBR, or NICUBR */
|
|
|
|
idt = (IDT *) cmnunit;
|
|
|
|
if (cmnvcc == NULL || cmnvcc->cv_connvc == NULL) {
|
|
printf("idt_openvcc: bad request #1.\n");
|
|
return (1);
|
|
}
|
|
attrib = &cmnvcc->cv_connvc->cvc_attr;
|
|
vccinf = cmnvcc->cv_connvc->cvc_vcc;
|
|
|
|
if (attrib == NULL || vccinf == NULL) {
|
|
printf("idt_openvcc: bad request #2.\n");
|
|
return (1);
|
|
}
|
|
vpi = vccinf->vc_vpi;
|
|
vci = vccinf->vc_vci;
|
|
|
|
connection = idt_connect_find(idt, vpi, vci);
|
|
if (connection == NULL) {
|
|
printf("idt_openvcc: vpi/vci invalid: %d/%d\n", vpi, vci);
|
|
return (1);
|
|
}
|
|
if (connection->status) {
|
|
printf("idt_openvcc: connection already open %d/%d\n", vpi, vci);
|
|
return (1);
|
|
}
|
|
connection->status = 1;
|
|
connection->recv = NULL;
|
|
connection->rlen = 0;
|
|
connection->maxpdu = 20000;
|
|
connection->aal = IDTAAL5;
|
|
connection->traf_pcr = attrib->traffic.v.forward.PCR_all_traffic;
|
|
connection->traf_scr = attrib->traffic.v.forward.SCR_all_traffic;
|
|
connection->vccinf = vccinf; /* 12/15/2000 */
|
|
|
|
if (connection->traf_pcr <= 0)
|
|
connection->traf_pcr = connection->traf_scr;
|
|
if (connection->traf_scr <= 0)
|
|
connection->traf_scr = connection->traf_pcr;
|
|
|
|
class = idt_atm_bearerclass(&attrib->bearer);
|
|
if (vpi == 0 && vci == 5)
|
|
class = NICABR; /* higher priority than UBR */
|
|
if (vpi == 0 && vci == 16)
|
|
class = NICABR;
|
|
|
|
if (connection->traf_pcr < 0) { /* neither PCR nor SCR given */
|
|
connection->traf_pcr = 1;
|
|
connection->traf_scr = 1;
|
|
class = NICUBR; /* so give it lowest priority */
|
|
}
|
|
connection->class = class;
|
|
|
|
if (idt_connect_txopen(idt, connection)) {
|
|
device_printf(idt->dev, "cannot open connection for %d/%d\n",
|
|
vpi, vci);
|
|
return (1);
|
|
}
|
|
if (idt_sysctl_logvcs)
|
|
printf("idt_openvcc: %d/%d, PCR=%d, SCR=%d\n", vpi, vci,
|
|
connection->traf_pcr, connection->traf_scr);
|
|
idt_connect_opencls(idt, connection, 1); /* open entry in rcv
|
|
* connect table */
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* We really don't handle ABR, but use it as a higher priority UBR. The
|
|
* idea is that a UBR connection that gives a PCR (like 0/16) should
|
|
* be given preference over a UBR connection that wants "everything else".
|
|
*
|
|
* Note that CLASS_X is typically UBR, but the traffic type information
|
|
* element may still specify CBR or VBR.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* Close VCC
|
|
*/
|
|
|
|
static int
|
|
idt_closevcc(Cmn_unit * cmnunit, Cmn_vcc * cmnvcc)
|
|
{
|
|
CONNECTION *connection;
|
|
nicstar_reg_t *idt = (nicstar_reg_t *) cmnunit;
|
|
int vpi;
|
|
int vci;
|
|
|
|
if (cmnvcc && cmnvcc->cv_connvc && cmnvcc->cv_connvc->cvc_vcc) {
|
|
vpi = cmnvcc->cv_connvc->cvc_vcc->vc_vpi;
|
|
vci = cmnvcc->cv_connvc->cvc_vcc->vc_vci;
|
|
} else {
|
|
printf("idt_closevcc: bad vcivpi\n");
|
|
return (0);
|
|
}
|
|
connection = idt_connect_find(idt, vpi, vci);
|
|
|
|
if (connection == NULL) {
|
|
printf("idt_closevcc: vpi/vci invalid: %d/%d\n", vpi, vci);
|
|
return (0);
|
|
}
|
|
idt_connect_opencls(idt, connection, 0); /* close entry in rcv
|
|
* connect table */
|
|
|
|
if (connection->status == 0)
|
|
printf("idt_closevcc: close on empty connection %d/%d\n", vpi, vci);
|
|
if (connection->recv != NULL)
|
|
m_freem(connection->recv); /* recycle mbuf of partial PDU */
|
|
idt_connect_txclose(idt, connection);
|
|
connection->status = 0;
|
|
connection->recv = NULL;
|
|
connection->rlen = 0;
|
|
connection->maxpdu = 0;
|
|
connection->aal = 0;
|
|
connection->traf_pcr = 0;
|
|
connection->traf_scr = 0;
|
|
|
|
if (idt_sysctl_logvcs)
|
|
printf("idt_closevcc: vpi=%d vci=%d\n", vpi, vci);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* VCC Stack Instantiation
|
|
*
|
|
* This function is called via the common driver code during a device VCC
|
|
* stack instantiation. The common code has already validated some of
|
|
* the request so we just need to check a few more IDT-specific details.
|
|
*
|
|
* Called at splnet.
|
|
*
|
|
* Arguments:
|
|
* cup pointer to device common unit
|
|
* cvp pointer to common VCC entry
|
|
*
|
|
* Returns:
|
|
* 0 instantiation successful
|
|
* err instantiation failed - reason indicated
|
|
*
|
|
*/
|
|
static int
|
|
idt_instvcc(Cmn_unit * cmnunit, Cmn_vcc * cmnvcc)
|
|
{
|
|
Atm_attributes *attrib; /* from HARP struct */
|
|
IDT *idt;
|
|
int class, pcr, scr;
|
|
int slots_vc, slots_cur, slots_max;
|
|
|
|
if (cmnvcc == NULL)
|
|
return (EINVAL);
|
|
if (cmnvcc->cv_connvc == NULL)
|
|
return (EINVAL);
|
|
|
|
idt = (IDT *) cmnunit;
|
|
if (idt == NULL)
|
|
return (EINVAL);
|
|
|
|
attrib = &cmnvcc->cv_connvc->cvc_attr;
|
|
|
|
if (attrib == NULL)
|
|
return (EINVAL);
|
|
|
|
pcr = attrib->traffic.v.forward.PCR_all_traffic;
|
|
scr = attrib->traffic.v.forward.SCR_all_traffic;
|
|
|
|
if (pcr <= 0)
|
|
pcr = scr; /* if PCR missing, default to SCR */
|
|
if (pcr <= 0)
|
|
pcr = 1;
|
|
if (scr <= 0)
|
|
scr = pcr;
|
|
|
|
class = idt_atm_bearerclass(&attrib->bearer);
|
|
if (class == NICCBR) {
|
|
slots_max = idt->txslots_max;
|
|
slots_cur = idt->txslots_cur;
|
|
slots_vc = idt_slots_cbr(idt, scr); /* 06/13/2001: now using
|
|
* SCR */
|
|
if (slots_vc + slots_cur > slots_max) {
|
|
if (idt_sysctl_logvcs)
|
|
device_printf(idt->dev,
|
|
"Insufficient bandwidth (vc=%d cur=%d max=%d)\n",
|
|
slots_vc, slots_cur, slots_max);
|
|
return (EINVAL);
|
|
}
|
|
}
|
|
/* This part was take from /sys/dev/hfa/fore_vcm.c */
|
|
|
|
switch (attrib->aal.type) {
|
|
case ATM_AAL0:
|
|
break;
|
|
case ATM_AAL3_4:
|
|
if ((attrib->aal.v.aal4.forward_max_SDU_size > IDT_IFF_MTU) ||
|
|
(attrib->aal.v.aal4.backward_max_SDU_size > IDT_IFF_MTU))
|
|
return (EINVAL);
|
|
break;
|
|
case ATM_AAL5:
|
|
if ((attrib->aal.v.aal5.forward_max_SDU_size > IDT_IFF_MTU) ||
|
|
(attrib->aal.v.aal5.backward_max_SDU_size > IDT_IFF_MTU))
|
|
return (EINVAL);
|
|
break;
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Pass Incoming PDU up Stack
|
|
*
|
|
* This function is called via the core ATM interrupt queue callback
|
|
* set in fore_recv_drain(). It will pass the supplied incoming
|
|
* PDU up the incoming VCC's stack.
|
|
*
|
|
* Called at splnet.
|
|
*
|
|
* Arguments:
|
|
* tok token to identify stack instantiation
|
|
* m pointer to incoming PDU buffer chain
|
|
*
|
|
* Returns:
|
|
* none
|
|
*/
|
|
static void
|
|
idt_recv_stack(void *tok, KBuffer * m)
|
|
{
|
|
Idt_vcc *ivp = (Idt_vcc *) tok;
|
|
int err;
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0) {
|
|
printf("idt_recv_stack: Warning - mbuf chain has no header.\n");
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
/*
|
|
* Send the data up the stack
|
|
*/
|
|
STACK_CALL(CPCS_UNITDATA_SIG, ivp->iv_upper,
|
|
ivp->iv_toku, ivp->iv_vccb, (int)m, 0, err);
|
|
if (err)
|
|
KB_FREEALL(m);
|
|
|
|
return;
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* Enqueue received PDU for HARP to handle
|
|
*
|
|
* in: IDT device, mbuf, vpi, vci
|
|
*
|
|
* Date last: 12/14/2000
|
|
*/
|
|
|
|
void
|
|
idt_receive(nicstar_reg_t * idt, struct mbuf * m, int vpi, int vci)
|
|
{
|
|
caddr_t cp;
|
|
Cmn_vcc *vcc;
|
|
int space;
|
|
|
|
/*
|
|
* The STACK_CALL needs to happen at splnet() in order for the stack
|
|
* sequence processing to work. Schedule an interrupt queue
|
|
* callback at splnet() since we are currently at device level.
|
|
*/
|
|
|
|
/*
|
|
* Prepend callback function pointer and token value to buffer. We
|
|
* have already guaranteed that the space is available in the first
|
|
* buffer.
|
|
*/
|
|
|
|
/*
|
|
* vcc = atm_dev_vcc_find(&idt->iu_cmn, (vpivci>> 16), vpivci &
|
|
* 0xffff, VCC_IN);
|
|
*/
|
|
|
|
vcc = atm_dev_vcc_find(&idt->iu_cmn, vpi, vci, VCC_IN);
|
|
|
|
if (vcc == NULL) { /* harp stack not ready or no vcc */
|
|
printf("idt_receive: no VCC %d/%d\n", vpi, vci);
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
space = m->m_data - idt_mbuf_base(m);
|
|
if (space < sizeof(atm_intr_func_t) + sizeof(int)) {
|
|
printf("idt_receive: NOT enough buffer space (%d).\n", space);
|
|
KB_FREEALL(m);
|
|
return;
|
|
}
|
|
KB_HEADADJ(m, sizeof(atm_intr_func_t) + sizeof(int));
|
|
KB_DATASTART(m, cp, caddr_t);
|
|
*((atm_intr_func_t *) cp) = idt_recv_stack;
|
|
cp += sizeof(atm_intr_func_t);
|
|
|
|
*((void **)cp) = (void *)vcc;
|
|
|
|
/*
|
|
* Schedule callback
|
|
*/
|
|
if (! netisr_queue(NETISR_ATM, m))
|
|
KB_FREEALL(m);
|
|
}
|