freebsd-dev/sys/gnu/scsi/nic5000.c

1477 lines
30 KiB
C
Raw Normal View History

static char rcsid[] = "@(#)$Id: nic5000.c,v 1.1 1995/02/14 15:00:37 jkh Exp $";
/*******************************************************************************
* II - Version 0.1 $Revision: 1.1 $ $State: Exp $
*
* Copyright 1994 Dietmar Friede
*******************************************************************************
* Bug reports, patches, comments, suggestions should be sent to:
*
* jkr@saarlink.de or jkrause@guug.de
*
*******************************************************************************
* $Log: nic5000.c,v $
* Revision 1.1 1995/02/14 15:00:37 jkh
* An ISDN driver that supports the EDSS1 and the 1TR6 ISDN interfaces.
* EDSS1 is the "Euro-ISDN", 1TR6 is the soon obsolete german ISDN Interface.
* Obtained from: Dietmar Friede <dfriede@drnhh.neuhaus.de> and
* Juergen Krause <jkr@saarlink.de>
*
* This is only one part - the rest to follow in a couple of hours.
* This part is a benign import, since it doesn't affect anything else.
*
*
******************************************************************************/
/*
*
* Copyright (c) 1994 Dietmar Friede (dietmar@friede.de) All rights reserved.
* FSF/FSAG GNU Copyright applies
*
* A low level driver for the NICCY-5000 ISDN/SCSI device
*
*/
#include "snic.h"
#if NSNIC > 0
#define SPLSNIC splbio
#define ESUCCESS 0
#define SNIC_RETRIES 8
#include "sys/types.h"
#include "sys/param.h"
#include "sys/ioctl.h"
#include "sys/malloc.h"
#include "sys/kernel.h"
#include "scsi/scsi_all.h"
#include "scsi/scsiconf.h"
#include "gnu/isdn/isdn_ioctl.h"
#include "gnu/i386/isa/niccyreg.h"
#include "gnu/scsi/scsi_nic.h"
/* #define NETBSD */
#undef SCSI_NOMASK
#define OPEN 1
#define LOAD_HEAD 2
#define LOAD_DATA 4
#define LOAD_ENTITY 8
#define IS_DIAL(p) (((p)&0x20)==0)
#define IS_LISTEN(p) ((p)&0x20)
#define CHAN(pl) (((pl)&7)-1)
#define C_CHAN(x) ((x)&1)
#define APPL(pl) ((((pl)>>6)&0x7f)-1)
#define CARD(pl) (((pl)>>13)&7)
#define MK_APPL(pl) (((pl)+1)<<6)
#define min(a,b) ((a)<(b)?(a):(b))
#define SNICOUTSTANDING 2
extern int hz;
struct snic_data
{
struct scsi_switch *sc_sw; /* address of scsi low level switch */
int ctrl; /* so they know which one we want */
int targ; /* our scsi target ID */
int lu; /* out scsi lu */
int cmdscount; /* cmds allowed outstanding by board*/
int xfer_block_wait;
struct scsi_xfer *free_xfer;
struct scsi_xfer scsi_xfer[SNICOUTSTANDING]; /* XXX */
};
struct snic_driver
{
int size;
struct snic_data **snic_data;
}*snic_driver;
static int next_snic_unit = 0;
static unsigned dnlnum = 0;
static u_char ack_msg= 0xff;
static u_char snic_nxt_b;
typedef enum
{
DISCON, ISDISCON, DIAL, CALLED, CONNECT, IDLE, ACTIVE, WAITING, WAIT_ACK
} io_state;
typedef struct
{
char ctrl;
u_char msg_nr;
short plci;
short ncci;
short state;
Buffer o_buf;
} chan_t;
struct snic_softc
{
short sc_stat;
u_char sc_flags;
u_char sc_unit;
u_char sc_ctrl;
u_char sc_type;
u_short sc_istat;
struct scsi_msg sc_icmd;
Buffer sc_imsg;
Header sc_imsg0;
u_short sc_ostat;
struct scsi_msg sc_ocmd;
Buffer sc_omsg;
chan_t sc_chan[2];
u_char sc_state_ind[8];
u_char sc_gotack;
} snic_sc[NSNIC];
extern isdn_appl_t isdn_appl[];
extern isdn_ctrl_t isdn_ctrl[];
extern u_short isdn_state;
extern int ispy_applnr;
extern int Isdn_Appl, Isdn_Ctrl, Isdn_Typ;
extern void isdn_start_out();
static old_spy= 0;
static void snic_interupt();
static int snic_get_msg();
static void snic_start();
int snic_connect(), snic_listen(), snic_disconnect(), snic_accept();
int snic_output();
#ifdef NETBSD
int snicattach(int ctrl, struct scsi_switch *scsi_switch, int physid, int *sunit)
{
int targ, lu;
#else /* FreeBSD */
int snicattach(int ctrl, int targ, int lu, struct scsi_switch *scsi_switch)
{
#endif
int unit,i;
struct snic_data *snic, **snicrealloc;
struct snic_softc *sc;
int cn;
isdn_ctrl_t *ctrl0, *ctrl1;
#ifdef NETBSD
targ = physid >> 3;
lu = physid & 7;
#endif
if(next_snic_unit >= NSNIC)
return(0);
unit = next_snic_unit;
if (next_snic_unit == 0)
{
snic_driver =
malloc(sizeof(struct snic_driver),M_DEVBUF,M_NOWAIT);
if(!snic_driver)
{
printf("snic%d: malloc failed\n",unit);
return(0);
}
bzero(snic_driver,sizeof(snic_driver));
snic_driver->size = 0;
}
next_snic_unit++;
if(unit >= snic_driver->size)
{
snicrealloc =
malloc(sizeof(snic_driver->snic_data) * next_snic_unit,
M_DEVBUF,M_NOWAIT);
if(!snicrealloc)
{
printf("snic%d: malloc failed\n",unit);
return(0);
}
/* Make sure we have something to copy before we copy it */
bzero(snicrealloc,sizeof(snic_driver->snic_data) * next_snic_unit);
if(snic_driver->size)
{
bcopy(snic_driver->snic_data,snicrealloc,
sizeof(snic_driver->snic_data) * snic_driver->size);
free(snic_driver->snic_data,M_DEVBUF);
}
snic_driver->snic_data = snicrealloc;
snic_driver->snic_data[unit] = NULL;
snic_driver->size++;
}
if(snic_driver->snic_data[unit])
{
return(0);
}
snic = snic_driver->snic_data[unit] =
malloc(sizeof(struct snic_data),M_DEVBUF,M_NOWAIT);
if(!snic)
{
printf("snic%d: malloc failed\n",unit);
return(0);
}
#ifdef NETBSD
*sunit= unit;
#endif
bzero(snic,sizeof(struct snic_data));
snic->sc_sw = scsi_switch;
snic->ctrl = ctrl;
snic->targ = targ;
snic->lu = lu;
snic->cmdscount = SNICOUTSTANDING; /* XXX (ask the board) */
i = snic->cmdscount;
while(i-- )
{
snic->scsi_xfer[i].next = snic->free_xfer;
snic->free_xfer = &snic->scsi_xfer[i];
}
sc = &snic_sc[unit];
sc->sc_ctrl = -1;
sc->sc_gotack= 1;
if ((cn = isdn_ctrl_attach(2)) == -1)
{
return (0);
}
sc->sc_ctrl = cn;
sc->sc_chan[0].plci = sc->sc_chan[1].plci = -1;
ctrl0 = &isdn_ctrl[cn];
ctrl1 = &isdn_ctrl[cn + 1];
sc->sc_chan[0].ctrl = ctrl0->ctrl = cn;
sc->sc_chan[1].ctrl = ctrl1->ctrl = cn + 1;
ctrl0->o_buf = &sc->sc_chan[0].o_buf.Data[5];
ctrl1->o_buf = &sc->sc_chan[1].o_buf.Data[5];
ctrl0->listen = ctrl1->listen = snic_listen;
ctrl0->disconnect = ctrl1->disconnect = snic_disconnect;
ctrl0->accept = ctrl1->accept = snic_accept;
ctrl0->connect = ctrl1->connect = snic_connect;
ctrl0->output = ctrl1->output = snic_output;
ctrl0->unit = ctrl1->unit = unit;
ctrl0->appl = ctrl1->appl = -1;
ctrl0->o_len = ctrl1->o_len = -1;
sc->sc_flags= LOAD_ENTITY;
return(1);
}
static
struct scsi_xfer *snic_get_xs(int unit)
{
struct scsi_xfer *xs;
struct snic_data *snic;
int s;
snic = snic_driver->snic_data[unit];
if (xs = snic->free_xfer)
{
snic->free_xfer = xs->next;
xs->flags = 0;
}
return(xs);
}
static void
snic_free_xs(int unit, struct scsi_xfer *xs)
{
struct snic_data *snic;
snic = snic_driver->snic_data[unit];
xs->next = snic->free_xfer;
snic->free_xfer = xs;
}
static void
snic_timout(int unit)
{
struct snic_softc * sc= &snic_sc[unit&0xff];
if(sc->sc_istat&0x100)
{
snic_interupt(unit);
return;
}
if(sc->sc_istat & 2)
sc->sc_istat= sc->sc_ostat= 0;
else if((sc->sc_istat & 0x200) == 0 ) return;
if(sc->sc_ostat & 0xff)
{
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
return;
}
if(sc->sc_gotack) snic_start(unit);
snic_get_msg(unit);
}
static int
isdn_small_interupt(int unit, struct scsi_xfer *xs)
{
struct snic_data *snic = snic_driver->snic_data[unit];
struct snic_softc * sc= &snic_sc[unit];
Header *msg = &sc->sc_imsg0;
int c;
switch (msg->Type)
{
case 0:
if(sc->sc_istat&0x200)
break;
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
break;
case 0xff:
sc->sc_gotack= 1;
break;
case 0xfe:
printf("f");
sc->sc_gotack= 1;
for(c= 0; c < 2; c++)
{
chan_t *chan = &sc->sc_chan[c];
if(chan->state == WAIT_ACK)
{
chan->state = WAITING;
sc->sc_ostat |= c?0x800:0x400;
}
}
break;
case 0xfd:
printf("fd");
break;
default:
return(0);
}
sc->sc_istat&= ~0xff;
sc->sc_imsg0.Type= 0;
return(1);
}
static void
snic_get_done(int unit, struct scsi_xfer *xs)
{
struct snic_data *snic = snic_driver->snic_data[unit];
struct snic_softc * sc= &snic_sc[unit];
Header *msg = &sc->sc_imsg0;
int len, error;
error= xs->error;
switch(error)
{
case XS_NOERROR:
if(xs->datalen == 0)
sc->sc_imsg.h.Type= 0;
if(isdn_small_interupt(unit,xs)) break;
if(xs->datalen < (len=(msg->DataLen + 10)))
{
struct scsi_msg *scsi_cmd= &sc->sc_icmd;
/* resubmit it */
sc->sc_imsg.h.Type= 0xba;
scsi_cmd->len[1]= (len>>8)&0xff;
scsi_cmd->len[2]= len&0xff;
xs->retries= SNIC_RETRIES;
xs->error = XS_NOERROR;
xs->flags &= ~ITSDONE;
xs->data = (char *) &sc->sc_imsg;
xs->datalen = len;
xs->resid = len;
if ((*(snic->sc_sw->scsi_cmd))(xs) == SUCCESSFULLY_QUEUED)
{
return;
}
error= xs->error | 0x1000;
break;
}
if(xs->datalen <= 10)
{
sc->sc_istat|= 0x400;
sc->sc_imsg.h = sc->sc_imsg0;
}
sc->sc_imsg0.Type= 0;
break;
case XS_TIMEOUT:
case XS_BUSY:
case XS_DRIVER_STUFFUP:
break;
default:
printf("snic%d: unknown error %x\n",unit,xs->error);
}
if(error)
{
sc->sc_imsg.h.Type= sc->sc_imsg0.Type= 0;
sc->sc_istat&= 0x200;
if((sc->sc_istat&0x200) == 0)
{
sc->sc_istat= 0x200;
timeout(snic_timout,unit,2);
}
}
snic_free_xs(unit,xs);
if(sc->sc_istat&0x4ff == 0x400 )
sc->sc_istat|= 1;
if(sc->sc_istat&0xff)
{
snic_interupt(unit);
return;
}
if(sc->sc_gotack) snic_start(unit);
if(sc->sc_istat & 0x200)
return;
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
}
static int
snic_get_msg(unit)
int unit;
{
struct snic_data *snic = snic_driver->snic_data[unit];
struct snic_softc * sc= &snic_sc[unit];
struct scsi_msg *scsi_cmd= &sc->sc_icmd;
struct scsi_xfer *xs;
Header *data= &sc->sc_imsg0;
int retval;
if(sc->sc_istat&0xff)
return(-1);
sc->sc_istat |= 1;
data->Type= 0xbb;
sc->sc_istat &= ~0x200;
bzero(scsi_cmd, sizeof(struct scsi_msg));
bzero(data,10);
scsi_cmd->op_code = GET_MSG_COMMAND;
scsi_cmd->len[2]= 10;
xs = snic_get_xs(unit);
if(!xs)
{
sc->sc_istat&= ~0xff;
data->Type= 0;
return(EBUSY);
}
xs->flags |= (INUSE | SCSI_DATA_IN | SCSI_NOSLEEP);
xs->adapter = snic->ctrl;
xs->targ = snic->targ;
xs->lu = snic->lu;
xs->retries = SNIC_RETRIES;
xs->timeout = 2000;
xs->cmd = (struct scsi_generic *) scsi_cmd;
xs->cmdlen = sizeof(struct scsi_msg);
xs->data = (char *) data;
xs->datalen = 10;
xs->resid = 10;
xs->when_done = snic_get_done;
xs->done_arg = unit;
xs->done_arg2 = (int)xs;
xs->bp = NULL;
xs->error = XS_NOERROR;
if(retval = (*(snic->sc_sw->scsi_cmd))(xs))
{
sc->sc_istat= ~0xff;
data->Type= 0;
snic_free_xs(unit,xs);
}
return (retval);
}
static void
snic_put_done(int unit, struct scsi_xfer *xs)
{
int retval;
struct snic_data *snic = snic_driver->snic_data[unit];
struct snic_softc * sc= &snic_sc[unit];
Header *b= (Header *) xs->data;
int c;
sc->sc_ostat&= ~0xff;
if(xs->error != XS_NOERROR)
{
snic_free_xs(unit,xs);
switch(b->Type)
{
case 0:
return;
case 0xff:
sc->sc_ostat|= 0x100;
return;
case BD_DATA_B3_REQ | 0x40:
case BD_DATA_B3_REQ:
sc->sc_ostat|= 0x400;
return;
default:
sc->sc_ostat|= 0x200;
return;
}
}
snic_free_xs(unit,xs);
c= 0;
switch(b->Type)
{
case 0xff: break;
case BD_DATA_B3_REQ | 0x40:
c= 1;
case BD_DATA_B3_REQ:
sc->sc_chan[c].state = WAIT_ACK;
break;
default:
b->Type= 0;
}
if(sc->sc_istat&0x100)
{
snic_interupt(unit);
return;
}
if(sc->sc_ostat&0x100)
{
sc->sc_ostat&= ~0x100;
if(snic_put_msg(unit,&ack_msg,1,0))
sc->sc_ostat|= 0x100;
else return;
}
if(sc->sc_gotack) snic_start(unit);
if(sc->sc_istat&0x200)
return;
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
}
static void
snic_start(int unit)
{
int retval;
struct snic_softc * sc= &snic_sc[unit];
Header *b;
int c;
if(sc->sc_ostat&0x200)
{
b= &sc->sc_omsg.h;
sc->sc_ostat&= ~0x200;
if(snic_put_msg(unit,b, b->DataLen+10,2))
sc->sc_ostat|= 0x200;
else return;
}
for(c= 0; c<2; c++)
{
int cc= (snic_nxt_b++)&1;
u_short m= 0x400 << cc;
if(sc->sc_ostat&m)
{
chan_t *chan= &sc->sc_chan[cc];
b= &chan->o_buf.h;
sc->sc_ostat&= ~m;
if(chan->state == WAITING)
{
chan->state= ACTIVE;
if(snic_put_msg(unit,b, b->DataLen+10,4))
{
chan->state= WAITING;
sc->sc_ostat|= m;
}
else return;
}
}
}
}
int
snic_put_msg(int unit, Header *data, unsigned len, int w)
{
struct snic_softc *sc = &snic_sc[unit];
struct scsi_msg *scsi_cmd = &sc->sc_ocmd;
int retval;
struct scsi_xfer *xs;
struct snic_data *snic = snic_driver->snic_data[unit];
if(data->Type==0)
return(0);
if(sc->sc_ostat&0xff)
return(EBUSY);
sc->sc_ostat |= 1;
if((data->Type == 0xa8) || (data->Type == 0xe8))
{
if(sc->sc_gotack==0)
{
sc->sc_ostat &= ~0xff;
return(EBUSY);
}
}
if(data->Type != 0xff)
sc->sc_gotack= 0;
bzero(scsi_cmd, sizeof(struct scsi_msg));
scsi_cmd->op_code = PUT_MSG_COMMAND;
if(len > 2063)
{
printf("snic%d: unsupported length %d\n",unit,len);
sc->sc_ostat &= ~0xff;
return(ENODEV);
}
scsi_cmd->len[1]= (len >> 8) & 0xff;
scsi_cmd->len[2]= len & 0xff;
xs = snic_get_xs(unit);
if(!xs)
{
printf("snic pm%d: busy %d\n", unit, w);
sc->sc_ostat &= ~0xff;
return(EBUSY);
}
xs->flags |= (INUSE | SCSI_DATA_OUT | SCSI_NOSLEEP);
xs->adapter = snic->ctrl;
xs->targ = snic->targ;
xs->lu = snic->lu;
xs->retries = SNIC_RETRIES;
xs->timeout = 2000;
xs->cmd = (struct scsi_generic *) scsi_cmd;
xs->cmdlen = sizeof(struct scsi_msg);
xs->data = (char *)data;
xs->datalen = len;
xs->resid = len;
xs->when_done = snic_put_done;
xs->done_arg = unit;
xs->done_arg2 = (int)xs;
xs->bp = NULL;
xs->error = XS_NOERROR;
if(retval = (*(snic->sc_sw->scsi_cmd))(xs))
{
sc->sc_ostat &= ~0xff;
snic_free_xs(unit,xs);
return(EBUSY);
}
return(0);
}
int
snicopen(dev_t dev, int flag)
{
struct snic_softc *sc;
u_char unit;
int x;
unsigned error;
u_char b= 0xff;
unit = minor(dev);
/* minor number out of limits ? */
if (unit >= next_snic_unit)
return (ENXIO);
sc = &snic_sc[unit];
x= splhigh();
/* Card busy ? */
if (sc->sc_flags & 7)
{
splx(x);
return (EBUSY);
}
sc->sc_flags |= OPEN;
if(sc->sc_flags & LOAD_ENTITY)
{
snic_get_msg(unit);
/*
if(snic_put_msg(unit,(Header *) &ack_msg,1,5))
sc->sc_ostat|= 0x100;
*/
}
splx(x);
return (0);
}
int
snicclose(dev_t dev, int flag)
{
struct snic_softc *sc = &snic_sc[minor(dev)];
sc->sc_flags &= ~7;
return (0);
}
int
snicioctl(dev_t dev, int cmd, caddr_t data, int flag)
{
int error;
u_char unit= minor(dev);
int i, x;
struct snic_softc *sc = &snic_sc[minor(dev)];
Buffer *b= &sc->sc_omsg;
error = 0;
x= splhigh();
while(sc->sc_ostat || (sc->sc_gotack==0))
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "ioctl", 2);
if (error != EWOULDBLOCK)
{
splx(x);
return(error);
}
}
switch (cmd)
{
case NICCY_DEBUG:
data[0]= 0x50;
bcopy(sc->sc_state_ind,data+1,8);
break;
case NICCY_LOAD:
{
struct head *head = (struct head *) data;
int len, l, off;
bzero(b, 22);
b->h.Type = MD_DNL_MOD_REQ;
sc->sc_type = head->typ;
b->h.SubType = head->typ;
b->h.DataLen = 12;
bcopy(head->nam, b->Data, 8);
bcopy(&head->len, &b->Data[8], 4);
sc->sc_flags |= LOAD_HEAD;
sc->sc_stat = -1;
while((error= snic_put_msg(unit,(Header *) b,22,6)) == EBUSY)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic1", 1);
if (error != EWOULDBLOCK)
break;
}
if(error == 0)
{
while (sc->sc_flags & LOAD_HEAD)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic2", 1);
if (error != EWOULDBLOCK)
break;
error= 0;
}
}
if (sc->sc_flags & 7)
sc->sc_flags = (sc->sc_flags & ~7 ) | OPEN;
if(error)
{
head->status = sc->sc_stat;
splx(x);
return (error);
}
len= head->d_len;
off= 0;
while(len > 0)
{
while(sc->sc_ostat || (sc->sc_gotack==0))
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic7", 2);
if (error != EWOULDBLOCK)
{
splx(x);
return(error);
}
}
bzero(b,10);
b->h.Type = MD_DNL_MOD_DATA;
sc->sc_type = head->typ;
b->h.SubType = head->typ;
l= min(len,512);
len-= l;
b->h.DataLen = l + 8;
b->h.Number = dnlnum++;
b->h.MoreData= len>0;
bcopy(head->nam, b->Data, 8);
if(error= copyin(head->data+off, b->Data+8, l))
{
splx(x);
return(error);
}
off+= l;
sc->sc_flags |= LOAD_DATA;
sc->sc_stat = -1;
while((error= snic_put_msg(unit,(Header *) b,b->h.DataLen+10,7)) == EBUSY)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic3", 1);
if (error != EWOULDBLOCK)
break;
}
}
if(error == 0)
{
while (sc->sc_flags & LOAD_DATA)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic4", 1);
if (error != EWOULDBLOCK)
break;
error= 0;
}
}
if (sc->sc_flags & 7)
sc->sc_flags = (sc->sc_flags & ~7 ) | OPEN;
head->status = sc->sc_stat;
splx(x);
return (error);
}
case NICCY_SET_CLOCK:
bzero(b,10);
b->h.Type = MD_SET_CLOCK_REQ;
b->h.DataLen = 14;
bcopy(data, b->Data,14);
while((error= snic_put_msg(unit,(Header *) b,24,8)) == EBUSY)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic5", 1);
if (error != EWOULDBLOCK)
break;
}
splx(x);
return (error);
case NICCY_SPY:
bzero(b,10);
b->h.Type = MD_MANUFACT_REQ;
b->h.SubType = 18;
b->h.DataLen = 1;
/* There are ilegal states. So I use them to toggle */
if((data[0] == 0) && (old_spy == 0)) data[0]= 255;
else if(data[0] && old_spy ) data[0]= 0;
old_spy= b->Data[0]= data[0];
while((error= snic_put_msg(unit,(Header *) b,11,9)) == EBUSY)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic6", 1);
if (error != EWOULDBLOCK)
break;
}
splx(x);
return (error);
case NICCY_RESET:
bzero(b,10);
b->h.Type = MD_RESET_REQ;
while((error= snic_put_msg(unit,(Header *) b,10,9)) == EBUSY)
{
error = tsleep((caddr_t) sc, PZERO | PCATCH, "nic6", 1);
if (error != EWOULDBLOCK)
break;
}
sc->sc_flags|= LOAD_ENTITY;
splx(x);
return (error);
default:
error = ENODEV;
}
splx(x);
return (error);
}
#define con_b3_req(unit,mb,pl) en_q(unit,mb|BD_CONN_B3_REQ,0,pl,0,NULL)
#define con_act_resp(unit,pl) en_q(unit,DD_CONN_ACT_RSP,0, pl,0,NULL)
#define discon_resp(sc,pl) en_q(unit,DD_DISC_RSP,0, pl,0,NULL)
#define inf_resp(unit,pl) en_q(unit,DD_INFO_RSP,0, pl,0,NULL)
#define listen_b3_req(unit,mb,pl) en_q(unit,mb|BD_LIST_B3_REQ,0,pl,0,NULL)
#define con_resp(unit,pl,rea) en_q(unit,DD_CONN_RSP,0, pl, 1,(u_char *) &rea)
static int
en_q(int unit, int t, int st, int pl, int l, u_char *val)
{
struct snic_softc * sc= &snic_sc[unit];
Buffer *b= &sc->sc_omsg;
int error= 0;
if(b->h.Type)
{
return(EBUSY);
}
bzero(b,10);
if(( t >= 0x80) && CHAN(pl) && ((t & 0x40) == 0))
printf("?%x %x",t,pl);
if(t>=0x40)
printf("S%x %x",t,pl);
b->h.Type = t;
b->h.SubType = st;
b->h.PLCI = pl;
if(l)
{
b->h.DataLen= l;
bcopy(val,b->Data,l);
}
if((error= snic_put_msg(unit,(Header *) b,10+l,13)) == EBUSY)
{
sc->sc_ostat|= 0x200;
return(0);
}
return(error);
}
static int
reset_plci(int w, chan_t * chan, short p)
{
isdn_ctrl_t *ctrl;
if (p == -1)
return (-1);
if(chan == NULL)
return(p);
ctrl = &isdn_ctrl[chan->ctrl];
if(chan->plci == p)
{
if (ISBUSY(ctrl->appl))
{
isdn_disconn_ind(ctrl->appl);
isdn_appl[ctrl->appl].ctrl = -1;
isdn_appl[ctrl->appl].state = 0;
}
ctrl->appl = -1;
ctrl->o_len = -1;
chan->plci = -1;
chan->ncci = -1;
chan->state = DISCON;
chan->o_buf.h.Type= 0;
}
return (p);
}
static int
sel_b2_prot_req(int unit, int c, int pl, dlpd_t * dlpd)
{
return(en_q(unit, (c ? 0x40 : 0)| BD_SEL_PROT_REQ, 2, pl, sizeof(dlpd_t), (u_char *) dlpd));
}
static int
sel_b3_prot_req(int unit, int mb, u_short pl, ncpd_t * ncpd)
{
return(en_q(unit, mb | BD_SEL_PROT_REQ, 3, pl, sizeof(ncpd_t), (u_char *) ncpd));
}
static int
discon_req(int w, int unit , int pl, int rea, int err)
{
if((pl == 0) || (pl == -1))
return(0);
return(en_q(unit, DD_DISC_REQ,0, pl, 1, (u_char *) &rea));
}
static int
state_ind(int unit, int api, int spv)
{
u_char buf[3];
buf[0]= unit; buf[1]= api; buf[2]= spv;
return(en_q(unit, MD_STATE_IND,0, 0, 3, buf));
}
static int
con_b3_resp(int unit, int mb, u_short ncci, u_short pl, u_char reject)
{
u_char buf[32];
int l = 4;
bzero(buf, 32);
*(u_short *) buf = ncci;
buf[2] = reject;
buf[3] = 0; /* ncpi ??? */
l += 15;
return(en_q(unit, mb | BD_CONN_B3_RSP,0, pl, l, buf));
}
int
snic_connect(int cn, int ap, int b_channel, int inf_mask, int out_serv
,int out_serv_add, int src_subadr, unsigned ad_len
,char *dest_addr, int spv)
{
char buf[128];
if (ad_len > 118)
return (-1);
buf[0] = spv ? 0x53 : 0;
buf[1] = b_channel;
if (spv)
inf_mask |= 0x40000000;
*(u_long *) & buf[2] = inf_mask;
buf[6] = out_serv;
buf[7] = out_serv_add;
buf[8] = src_subadr;
buf[9] = ad_len;
bcopy(dest_addr, &buf[10], ad_len);
return (en_q(isdn_ctrl[cn].unit, DD_CONN_REQ, 0, MK_APPL(ap), ad_len + 10, buf));
}
int
snic_listen(int cn, int ap, int inf_mask, int subadr_mask, int si_mask, int spv)
{
u_short sbuf[4];
if (spv)
inf_mask |= 0x40000000;
*(u_long *) sbuf = inf_mask;
sbuf[2] = subadr_mask;
sbuf[3] = si_mask;
return (en_q(isdn_ctrl[cn].unit, DD_LISTEN_REQ, 0, MK_APPL(ap), 8, (u_char *) sbuf));
}
int
snic_disconnect(int cn, int rea)
{
isdn_ctrl_t *ctrl = &isdn_ctrl[cn];
chan_t *chan = &snic_sc[ctrl->unit].sc_chan[C_CHAN(cn)];
int p, err;
u_char buf[16];
if(chan->ncci != -1)
{
bzero(buf,16);
*(u_short *) buf = chan->ncci;
err= en_q(ctrl->unit, (C_CHAN(cn)?0x40:0)|BD_DISC_B3_REQ, 0
, chan->plci, 3+sizeof(ncpi_t), buf);
if((err==0) && (ctrl->o_len == 0))
ctrl->o_len= -1;
return(err);
}
p = chan->plci;
if ((p == 0) || (p == -1))
return (ENODEV);
err= en_q(ctrl->unit, DD_DISC_REQ, 0, p, 1, (u_char *) &rea);
if((err==0) && (ctrl->o_len == 0))
ctrl->o_len= -1;
return(err);
}
int
snic_accept(int cn, int an, int rea)
{
isdn_ctrl_t *ctrl = &isdn_ctrl[cn];
struct snic_softc *sc = &snic_sc[ctrl->unit];
chan_t *chan = &sc->sc_chan[C_CHAN(cn)];
isdn_appl_t *appl = &isdn_appl[an];
if(ISFREE(ctrl->appl))
return(ENODEV);
if (rea)
{
ctrl->appl= -1;
return(discon_req(1, ctrl->unit, chan->plci, rea, 0));
}
ctrl->appl= an;
ctrl->lastact = time.tv_sec;
appl->ctrl= cn;
appl->state= 4;
return(sel_b2_prot_req(ctrl->unit, C_CHAN(cn), chan->plci, &appl->dlpd));
}
int
snic_output(int cn)
{
isdn_ctrl_t *ctrl = &isdn_ctrl[cn];
struct snic_softc *sc = &snic_sc[ctrl->unit];
chan_t *chan = &sc->sc_chan[C_CHAN(cn)];
int len= ctrl->o_len;
Buffer *b= &chan->o_buf;
int error= 0;
if (sc->sc_state_ind[1] || (chan->ncci == -1))
return (ENODEV);
if(chan->state != IDLE)
return(EBUSY);
chan->state= WAITING;
bzero(b,10);
b->h.Type = BD_DATA_B3_REQ;
if(C_CHAN(cn)) b->h.Type |= 0x40;
b->h.PLCI = chan->plci;
b->h.DataLen= len+5;
*(u_short *) b->Data = chan->ncci;
*(u_short *) &b->Data[2] = 0;
b->h.Number = b->Data[4] = chan->msg_nr++;
chan->state = ACTIVE;
ctrl->lastact = time.tv_sec;
if((error= snic_put_msg(ctrl->unit,(Header *) b,15+len,14)) == EBUSY)
{
sc->sc_ostat|= C_CHAN(cn)?0x800:0x400;
chan->state= WAITING;
return(0);
}
return(error);
}
static void
badstate(Header *h, int n)
{
int i;
u_char *p= (u_char *)h;
printf("Niccy: not implemented %x.%x len %d at %d", h->Type,
h->SubType, h->DataLen,n);
if(h->DataLen)
{
p+= 10;
for(i=0; i < h->DataLen ; i++) printf(" %x",p[i]);
}
printf("\n");
}
unsigned SavMsgTyp;
static void
snic_interupt(unsigned unit)
{
struct snic_softc * sc= &snic_sc[unit&0xff];
Buffer *msg;
chan_t *chan;
u_short n, mb, c, pl, err = 0;
isdn_ctrl_t *ctrl;
isdn_appl_t *appl;
int error= 0;
msg = &sc->sc_imsg;
chan= NULL;
ctrl= NULL;
appl= NULL;
SavMsgTyp= msg->h.Type;
if(sc->sc_istat & 2)
return;
if(sc->sc_ostat&0xff)
{
sc->sc_istat|= 0x101;
if(sc->sc_istat&0x200)
return;
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
return;
}
mb= 0;
pl = msg->h.PLCI;
if(pl && (msg->h.Type >= 0x40) && (msg->h.Type < 0xfd) && (msg->h.Type != 0x47))
{
if ((c = CHAN(pl)) < 2)
{
chan = &sc->sc_chan[c];
ctrl = &isdn_ctrl[chan->ctrl];
} else
{
c = 0xffff;
chan= NULL;
ctrl= NULL;
}
if(ctrl && (ctrl->appl & 0xC0) == 0)
appl= &isdn_appl[ctrl->appl];
else if( APPL(pl) < 0x30)
appl = &isdn_appl[APPL(pl)];
else if( APPL(pl) < 0x40)
appl= NULL;
else goto fin;
if(msg->h.Type >= 0x80)
{
mb= msg->h.Type & 0x40;
msg->h.Type &= 0xbf;
}
}
SavMsgTyp|= 0x100;
if(msg->h.Type>=0x40)
printf("I%x %x %x",msg->h.Type,pl,mb);
switch (msg->h.Type)
{
case 0x01: /* INIT IND */
case 0x15: /* POLL IND */
error= en_q(unit,msg->h.Type|0x20,0,0,0,NULL);
break;
case 0x04: /* DNL MOD CONF */
sc->sc_stat = msg->Data[0];
if (sc->sc_flags & 7)
sc->sc_flags = (sc->sc_flags & ~7) | OPEN;
break;
case 0x06: /* DNL MOD IND */
sc->sc_stat = msg->Data[0];
error= en_q(unit,msg->h.Type|0x20,sc->sc_type,0,1, &msg->Data[1]);
if(sc->sc_flags & LOAD_ENTITY)
{
sc->sc_istat= sc->sc_ostat= 2;
timeout(snic_timout,unit,hz);
msg->h.Type= 0;
return;
}
if (sc->sc_flags)
sc->sc_flags = OPEN;
break;
case 0x0e: /* SET CLOCK CONF */
error= state_ind(unit,1,0);
break;
case 0x16: /* STATE IND */
if(sc->sc_flags & LOAD_ENTITY)
{
if(sc->sc_flags & 7)
sc->sc_flags = OPEN;
else sc->sc_flags= 0;
}
bcopy( msg->Data, sc->sc_state_ind, 8);
error= en_q(unit,msg->h.Type|0x20,0,0,0,NULL);
break;
case 0x17: /* STATE RESP */
bcopy( msg->Data, sc->sc_state_ind, 8);
break;
case 0x1e: /* MANUFACT CONF */
if(msg->h.SubType == 18)
break;
badstate(&msg->h,1);
break;
case 0x1f: /* MANUFACT IND */
if(msg->h.SubType == 19)
{
isdn_input(ispy_applnr, msg->h.DataLen, msg->Data,0);
error= en_q(unit,msg->h.Type|0x20,msg->h.SubType,0,0,NULL);
break;
}
badstate(&msg->h,2);
break;
case 0x40: /* CONNECT CONF */
err = *(u_short *) msg->Data;
if (err || (appl == NULL) || (chan == NULL) || (ctrl == NULL))
{
if(chan) reset_plci(3, chan, pl);
if(appl) appl->state= 0;
break;
}
if (ISBUSY(ctrl->appl))
{
error= discon_req(2, unit, pl, 0, 0);
break;
}
chan->plci = pl;
chan->msg_nr = 0;
chan->ncci = -1;
ctrl->lastact = time.tv_sec;
ctrl->appl = APPL(pl);
appl->ctrl = chan->ctrl;
ctrl->islisten= 0;
chan->state = DIAL;
appl->state= 3;
break;
case 0x41: /* CONNECT IND */
if (ISBUSY(ctrl->appl))
{
error= discon_req(3, unit, pl, 0, 0);
break;
}
chan->plci = pl;
chan->msg_nr = 0;
chan->ncci = -1;
ctrl->lastact = time.tv_sec;
ctrl->appl = 0x7f;
ctrl->islisten= 1;
chan->state = CALLED;
msg->Data[msg->Data[3] + 4] = 0;
isdn_accept_con_ind(APPL(pl), chan->ctrl, msg->Data[0], msg->Data[1]
,msg->Data[2], msg->Data[3], (char *) &msg->Data[4]);
break;
case 0x42: /* CONNECT ACTIVE IND */
error= con_act_resp(unit, pl);
if (IS_LISTEN(pl))
{
isdn_conn_ind(ctrl->appl,chan->ctrl,0);
break;
}
isdn_conn_ind(APPL(pl),chan->ctrl,1);
chan->state = CONNECT;
ctrl->appl = APPL(pl);
appl->ctrl = chan->ctrl;
break;
case 0x43: /* DISCONNECT CONF */
reset_plci(4, chan, pl);
break;
case 0x44: /* DISCONNECT IND */
error= discon_resp(unit, reset_plci(5, chan, pl));
break;
case 0x47: /* LISTEN CONF */
isdn_state = *(u_short *) msg->Data;
break;
case 0x4a: /* INFO IND */
isdn_info(APPL(pl),*(u_short *)msg->Data, msg->Data[2], msg->Data+3);
error= inf_resp(unit, pl);
break;
case 0x80: /* SELECT PROT CONF */
err = *(u_short *) msg->Data;
if (err)
{
error= discon_req(4, unit, pl, 0, err);
break;
}
switch (msg->h.SubType)
{
case 2:/* SELECT B2 PROTOCOL */
if(ISFREE(ctrl->appl))
break;
error= sel_b3_prot_req(unit, mb, pl, &isdn_appl[ctrl->appl].ncpd);
break;
case 3:/* SELECT B3 PROTOCOL */
if (IS_DIAL(pl))
error= con_b3_req(unit, mb, pl);
else
error= listen_b3_req(unit, mb, pl);
break;
}
break;
case 0x81: /* LISTEN B3 CONF */
err = *(u_short *) msg->Data;
if (err)
{
error= discon_req(5, unit, pl, 0, err);
break;
}
error= con_resp(unit, pl, err);
break;
case 0x82: /* CONNECT B3 CONF */
err = *(u_short *) (msg->Data + 2);
n = *(u_short *) msg->Data;
if (err)
{
error= discon_req(6, unit, pl, 0, err);
break;
}
if(ISFREE(ctrl->appl))
break;
chan->ncci = n;
chan->state = CONNECT;
break;
case 0x83: /* CONNECT B3 IND */
if(ISFREE(ctrl->appl))
break;
n = *(u_short *) msg->Data;
chan->ncci = n;
chan->state = CONNECT;
error= con_b3_resp(unit, mb, n, pl, 0);
break;
case 0x84: /* CONNECT B3 ACTIVE IND */
if(ISFREE(ctrl->appl))
break;
if (chan->state < IDLE)
{
chan->state = IDLE;
ctrl->o_len = 0;
timeout(isdn_start_out,chan->ctrl,hz/5);
}
break;
case 0x85: /* DISCONNECT B3 CONF */
if(ISBUSY(ctrl->appl))
chan->state = ISDISCON;
err = *(u_short *) (msg->Data + 2);
if (err)
{
error= discon_req(7, unit, pl, 0, err);
break;
}
break;
case 0x86: /* DISCONNECT B3 IND */
if(ISBUSY(ctrl->appl))
chan->state = ISDISCON;
err = *(u_short *) (msg->Data + 2);
error= discon_req(8, unit, pl, 0, err);
break;
case 0x88: /* DATA B3 CONF */
if(ISFREE(ctrl->appl))
break;
err = *(u_short *) (msg->Data + 2);
if (err)
{
printf("e%x\n",err);
ctrl->send_err++;
isdn_appl[ctrl->appl].send_err++;
}
chan->state = IDLE;
chan->o_buf.h.Type= 0;
ctrl->o_len = 0;
isdn_start_out(chan->ctrl);
break;
case 0x89: /* DATA B3 IND */
if(ISFREE(ctrl->appl))
break;
if(isdn_input(ctrl->appl, msg->h.DataLen-5, msg->Data+5,ctrl->islisten))
ctrl->lastact = time.tv_sec;
break;
default:
badstate(&msg->h,3);
break;
}
fin:
if(error)
{
printf("x%x %x %x %x %x\n",error,msg->h.Type,sc->sc_istat,sc->sc_ostat,sc->sc_omsg.h.Type);
sc->sc_istat|= 0x101;
if(sc->sc_istat&0x200)
return;
sc->sc_istat|= 0x200;
timeout(snic_timout,unit,2);
return;
}
msg->h.Type= 0;
if(snic_put_msg(unit,(Header *) &ack_msg,1,15))
sc->sc_ostat|= 0x100;
sc->sc_istat= 0x200;
snic_get_msg(unit);
}
#endif /* NSNIC > 0 */