ds26528t1.c

Sample driver code for Dallas DS26528 T1/E1 framer chip.

		break;

	case TMS_RXOOF:

		value = (f->rrts1 & RRTS1_RLOF) ? 1 : 0;
		break;

	case TMS_RXAIS:

		value = (f->rrts1 & RRTS1_RAIS) ? 1 : 0;
		break;

	case TMS_RXRAI:

		value = (f->rrts1 & RRTS1_RRAI) ? 1 : 0;
		break;

	default:
		retval = 0;
		break;
	}

	*valueptr = value;
	return(retval);
}

/*------------------------------------------------------------------------*/
/* This routine will retreive the loop information
 */
static int poll_loop(STUFF *sptr, int loop_type, int *set_clear)
{
int retval = 1;
int value = 0;
LIU *l = sptr->t1s.myliu;
STANDARD_DECLARE;

	switch(loop_type) {
	case LOOP_REMSWITCH:
		/* Remote is when the the receive signal is looped back
		 * at the analog layer to the remote device.
		 * This is also known as line loopback
		 */

		value = (f->rcr3 & RCR3_RLB) ? 1 : 0;

		break;

	case LOOP_LOCSWITCH:
		/* Local Loopback is when the voice channels are looped
		 * before the framer section.
		 */

		value = (l->lmcr & LMCR_LLB) ? 1 : 0;

		break;

	case LOOP_PAYSWITCH:
		/* Payload Loopback is when the framer receives the signal
		 * then, after the framer, the voice channels are re-sent out
		 * and the overhead is re-generated.
		 */

		value = (f->rcr3 & RCR3_PLB) ? 1 : 0;

		break;

	case LOOP_FRMSWITCH:	
		/* Framer Loopback is when the signal is set out of
		 * the framer and looped back to the framer but
		 * before it hits the LIU.  You will send and AIS while
		 * this happens.  The AIS is done by the chip and not the
		 * Upper layers.
		 */

		value = (f->rcr3 & RCR3_FLB) ? 1 : 0;

		break;

	case LOOP_REMRXUPCODE:

		value = (f->rrts3 & RRTS3_LUP) ? 1 : 0;
		break;

	case LOOP_REMRXDNCODE:

		value = (f->rrts3 & RRTS3_LDN) ? 1 : 0;
		break;

	default:
		retval = 0;
		break;
	}

	*set_clear = value;
	return(retval);
}

/*------------------------------------------------------------------------*/
/* This will retreive ALL 24 channels of signaling
 * It will fill the array of all_rxbits with all signaling channels
 * all_rxbits must be 24 ints long.
 */
static int poll_allrxbits(STUFF *sptr, int *all_rxbits)
{
int retval = 1;
int i, val, bits;
int *p;
STANDARD_DECLARE;

	p = all_rxbits;

	for(i = 0; i < MAX_T1_TIMESLOTS/2; i++) {
		val = f->rs[i];

		bits = sptr->ds0[i + 12].rxbits = val & 0x0f;

		if(sptr->cfg.framing == FF_ESF)
			bits = flip_table[bits & 0x0f];
		else
			bits = rxsf_flip_table[bits & 0x0f];

		*(p+i+12) = bits;

		bits = sptr->ds0[i].rxbits = (val >> 4) & 0xff;

		if(sptr->cfg.framing == FF_ESF)
			bits = flip_table[bits & 0x0f];
		else
			bits = rxsf_flip_table[bits & 0x0f];

		*(p+i) = bits;

	}

	return(retval);
}

/*------------------------------------------------------------------------*/
/* This routine will retreive the performance data
 */
static int get_pm(STUFF *sptr, T1_PERFINFO *pm)
{
int retval = 1;
STANDARD_DECLARE;

	pm->CVcount = ((f->lcvcr1 << 8) | f->lcvcr2);

	if(sptr->cfg.framing == FF_ESF) {
		pm->CRCcount = ((f->pcvcr1 << 8) | f->pcvcr2);
		pm->FEcount = ((f->foscr1 << 8) | f->foscr2);
	}
	else {
		pm->CRCcount = 0;
		pm->FEcount = ((f->pcvcr1 << 8) | f->pcvcr2);
	}

	pm->EBcount = 0;
	pm->SLevent = sptr->t1s.rxslip;
	sptr->t1s.rxslip = 0;

	pm->SEFEevent = (f->rls2 & RLS2_SEFE) ? 1 : 0;
	f->rls2 |= RLS2_SEFE;

	return(retval);


}

/*------------------------------------------------------------------------*/
/* This will transmit on the appriate line 
 */
static int transmit_alarm(STUFF *sptr, int alarm_type, int set_clear)
{
int retval = 1;
STANDARD_DECLARE;

	switch(alarm_type) {
	case TMS_TXRAI:
		if(set_clear) {
			f->tcr1 |= TCR1_TRAI;
		}
		else {
			f->tcr1 &= ~TCR1_TRAI;
		}
		break;
	case TMS_TXAIS:
		if(set_clear) {
			f->tcr1 |= TCR1_TAIS;
		}
		else {
			f->tcr1 &= ~TCR1_TAIS;
		}
		break;

	default:
		retval = 0;
		break;
	}

	return(retval);
}

/*------------------------------------------------------------------------*/
/* Enable t1231 processing on the line 
 */
static int t1231_init(STUFF *sptr, int set_clear)
{
int retval = 1;

	/* Nothing to do here */

	return(retval);
}

/*------------------------------------------------------------------------*/
/* Enable one sec processing on the approriate line
 */
static int onesec_init(STUFF *sptr, int set_clear)
{
int retval = 1;
STANDARD_DECLARE;


	if(set_clear) {
		retval = hook_isr(sptr, set_clear, INTFLAG_ONESEC);
		if(!retval)
			return(0);
		f->rim4 |= RIM4_TIMER;
	}
	else {
		f->rim4 &= ~RIM4_TIMER;
		retval = hook_isr(sptr, set_clear, INTFLAG_ONESEC);
		if(!retval)
			return(0);
	}
	return(retval);
}

#if (MAX_GLOBAL_TICKERS	> 0)

/* -------------------------------------------------------------------------- */
/* The device has global tickers associated with it so,
 * the following routine is called by the global file for processing of
 * the global tickers
 */
static void T1GlobalTickerHandler(GDEVICE *d, int ticker)
{
int i;
STUFF *sptr;

	switch(ticker) {
	case GLOBAL_ALARM_TICKER:
		for(i = 0; i < MAX_T1_CHANNELS; i++) {

			if (!((sptr = &T1stuff[d->id][i])->init))
				continue;	
		}
		break;

	default:
		break;
	}
}


/*------------------------------------------------------------------------*/
/* This routine is called by global when the first time a ticker is
 * registered.  This routine makes the call back to the approprate TMS
 * to get the ticker hooked up.
 */
static void T1RegTicker(STUFF *sptr, void (*global_handler)(),
	int on_off, int ticker, int ms, void *handle)
{

	if(on_off)
		(*sptr->cback)(sptr->lnPtr, TE1DCLBK_HOOKOSTIC, ms, handle,
			global_handler, sptr->d, ticker);
		
	else
		(*sptr->cback)(sptr->lnPtr, TE1DCLBK_UNHOOKOSTIC, 
			*((unsigned long *)(handle)));
}

/*------------------------------------------------------------------------*/
/* This routine start a global ticker going
 */
static void start_global_ticker(STUFF *sptr, int ticker, int onoff)
{

	NCID_GHOOKTICKER(sptr->d, DRVR_IDX_T1, ticker, onoff,
		T1RegTicker, sptr, T1GlobalTickerHandler);
}

#endif	/* MAX_GLOBAL_TICKERS */

/*------------------------------------------------------------------------*/
/* This routine enables alarms 
 * Alarms:
 *         LOS OOF AIS RAI
 */
static int alarm_init(STUFF *sptr, int set_clear)
{
int retval = 1;
STANDARD_DECLARE;

	if(set_clear) {
		retval = hook_isr(sptr, set_clear, INTFLAG_ALM);
		if(!retval)
			return(0);

		f->rim1 |= RIM1_RRAIC | RIM1_RAISC | RIM1_RLOSC |
			RIM1_RLOFC | RIM1_RRAID | RIM1_RAISD |
			RIM1_RLOSD | RIM1_RLOFD;
	}
	else {
		f->rim1 &= ~(RIM1_RRAIC | RIM1_RAISC | RIM1_RLOSC |
			RIM1_RLOFC | RIM1_RRAID | RIM1_RAISD |
			RIM1_RLOSD | RIM1_RLOFD);

		retval = hook_isr(sptr, set_clear, INTFLAG_ALM);
		if(!retval)
			return(0);
	}
			
	return(retval);
}


/*------------------------------------------------------------------------*/
/* Helper routine used to enable/disable transmission of loop codes
 */

static void txloop(STUFF *sptr, int enabled, int code, int bitcount)
{
int tc;
STANDARD_DECLARE;

	if (!enabled) {
		f->tcr3 &= ~TCR3_TLOOP;
		return;
	}

	code = (code << (8 - bitcount)) & 0xff;

	switch (bitcount) {
	   case 1: 
		code |= (code >> 1);
	   case 2: /* fall through intended */
		code |= (code >> 2);
	   case 4:	/* fall through intended */
		code |= (code >> 4);
	   case 8:
		tc = 3;
		break;
	   case 3: 
		code |= (code >> 3);
	   case 6:	/* fall through intended */
		tc = 1;
		break;
	   case 7:
		tc = 2;
		break;
	   case 5: 	/* fall through intended */
	   default:
		tc = 0;
		break;
	}

	f->tcd1 = code;
	f->tcd2 = code;

	f->tcr4 = (UC)((f->tcr4 & (~TCR4_TC(3))) | TCR4_TC(tc));

	f->tcr3 |= TCR3_TLOOP;
}

/*------------------------------------------------------------------------*/
/* This routine sets up loopbacks of the indicated type
 */

static int do_loopback(STUFF *sptr, int looptype, int set_clear, 
	int bits, int code)
{
int retval = 1;
LIU *l = sptr->t1s.myliu;
STANDARD_DECLARE;

	switch(looptype) {
	case LOOP_REMSWITCH:
		/* Remote is when the the receive signal is looped back
		 * at the analog layer to the remote device.
		 * This is also known as line loopback
		 */

		if(set_clear) {
			f->rcr3 |= RCR3_RLB;
		}
		else {
			f->rcr3 &= ~RCR3_RLB;
		}

		break;

	case LOOP_LOCSWITCH:
		/* Local Loopback is when the voice channels are looped
		 * before the framer section.
		 */
		if(set_clear) {
			l->lmcr |= LMCR_LLB;
		}
		else {
			l->lmcr &= ~LMCR_LLB;
		}

		break;

	case LOOP_PAYSWITCH:
		/* Payload Loopback is when the framer receives the signal
		 * then, after the framer, the voice channels are re-sent out
		 * and the overhead is re-generated.
		 */
		if(set_clear) {
			f->rcr3 |= RCR3_PLB;
		}
		else {
			f->rcr3 &= ~RCR3_PLB;
		}
		break;

	case LOOP_FRMSWITCH:	
		/* Framer Loopback is when the signal is set out of
		 * the framer and looped back to the framer but
		 * before it hits the LIU.  You will send and AIS while
		 * this happens.  The AIS is done by the chip and not the
		 * Upper layers.
		 */


		if(set_clear) {
			f->rcr3 |= RCR3_FLB;
		}
		else {
			f->rcr3 &= ~RCR3_FLB;
		}
		break;

	case LOOP_REMTXUPCODE:
	case LOOP_REMTXDNCODE:
		txloop(sptr, set_clear, code, bits);
		break;

	case LOOP_REMRXUPCODE:
	case LOOP_REMRXDNCODE:
		code = (code << (8 - bits)) & 0xff;
		switch(bits) {
		   case 1:
			code = code | (code >> 1);
		   case 2:	/* FALL THROUGH INTENDED */
			code = code | (code >> 2);
		   case 4:	/* FALL THROUGH INTENDED */
			code = code | (code >> 4);
		   case 8:	/* FALL THROUGH INTENDED */
			bits = 8;
			break;
		   case 5:
		   case 7:
			break;
		   case 3:
			code = code | (code >> 3);
		   case 6:	/* FALL THROUGH INTENDED */
			bits = 6;
			break;
		}
		if(looptype == LOOP_REMRXUPCODE) {
			f->rupcd2 = f->rupcd1 = code;
	
			f->ribcc_rcr2 = (UC)((f->ribcc_rcr2 & 
				(~(RIBCC_RUP(7)))) | RIBCC_RUP(bits - 1));
		}
		else {

			f->rdncd2 = f->rdncd1 = code;

			f->ribcc_rcr2 = (UC)((f->ribcc_rcr2 & 
				(~(RIBCC_RDN(7)))) | RIBCC_RDN(bits - 1));
		}

		break;

	default:
		retval = 0;
		break;
	}

	return(retval);
}

/*------------------------------------------------------------------------*/
/* This routine turns on and off loop detection 
 */
static int loop_init(STUFF *sptr, int set_clear)
{
int retval = 1;
STANDARD_DECLARE;