apite1.inc

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

			if((retval = signal_clear(sptr, ts, 1)))
				sptr->ds0[ts].mode = DS0MODE_CLEAR;
		}
		break;

	case TE1DCTRL_SIGNLIDLE:
		{int ts;
		 unsigned char value;

			ts = va_arg(alist, int);
			value = (unsigned char)va_arg(alist, int);

			signal_clear(sptr, ts, 0);
			signal_rbcas(sptr, ts, 0);

			if((retval = signal_idle(sptr, ts, value, 1))) {
				sptr->ds0[ts].mode = DS0MODE_IDLE;
				sptr->ds0[ts].ipat = value;
			}
		}
		break;

	case TE1DCTRL_SIGNLRBIT:
		{int ts;
			ts = va_arg(alist, int);

			signal_clear(sptr, ts, 0);
			signal_idle(sptr, ts, -1, 0);

			if((retval = signal_rbcas(sptr, ts, 1)))
				sptr->ds0[ts].mode = DS0MODE_RBCAS;

		}
		break;

	case TE1DCTRL_SIGNLTXBITS:
		{int ts;
		 unsigned char dcba;

			ts = va_arg(alist, int);
			dcba = (unsigned char)va_arg(alist, int);

			if((retval = signal_txbits(sptr, ts, dcba)))
				sptr->ds0[ts].txbits = dcba;
		}
		break;


	case TE1DCTRL_ALARMINIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = alarm_init(sptr, set_clear)))
				sptr->alarm_init = set_clear;
		}
		break;

	case TE1DCTRL_ALARMTX:
		{int alarm_type, set_clear;
			alarm_type = va_arg(alist, int);
			set_clear = va_arg(alist, int);

			if((retval = transmit_alarm(sptr, alarm_type, 
				set_clear))) {

			   alarm_type &= ~TMS_TXALARM;

			   if(set_clear) 
				sptr->tx_alm |= alarm_type;
			   else
				sptr->tx_alm &= ~alarm_type;
			}
		}
		break;

	case TE1DCTRL_LOOPINIT:		/* Nothing to do in E1 */
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = loop_init(sptr, set_clear)))
				sptr->loop_init = set_clear;
		}
		break;

	case TE1DCTRL_LOOP:
		{int looptype, set_clear, code, bits;
			looptype = va_arg(alist, int);
			set_clear = va_arg(alist, int);
			code = va_arg(alist, int);
			bits = va_arg(alist, int); 

			if((retval = do_loopback(sptr, looptype, set_clear, 
			   bits, code))) {

			   switch(looptype) {
			   case LOOP_REMSWITCH:
				if(set_clear) 
					sptr->loopback |= DRV_LOOP_REMOTE;
				else
					sptr->loopback &= ~DRV_LOOP_REMOTE;
				break;

			   case LOOP_LOCSWITCH:
				if(set_clear) 
					sptr->loopback |= DRV_LOOP_LOCAL;
				else
					sptr->loopback &= ~DRV_LOOP_LOCAL;
				break;
			   case LOOP_PAYSWITCH:
				if(set_clear) 
					sptr->loopback |= DRV_LOOP_PAYLOAD;
				else
					sptr->loopback &= ~DRV_LOOP_PAYLOAD;
				break;
			   case LOOP_FRMSWITCH:
				if(set_clear) 
					sptr->loopback |= DRV_LOOP_FRAMER;
				else
					sptr->loopback &= ~DRV_LOOP_FRAMER;
				break;
#ifdef T1_DRIVER
			   case LOOP_REMTXUPCODE:
				sptr->txlup.bits = bits;
				sptr->txlup.code = code;
				break;

			   case LOOP_REMTXDNCODE:
				sptr->txldn.bits = bits;
				sptr->txldn.code = code;
				break;

			   case LOOP_REMRXUPCODE:
				sptr->rxlup.bits = bits;
				sptr->rxlup.code = code;
				break;

			   case LOOP_REMRXDNCODE:
				sptr->rxldn.bits = bits;
				sptr->rxldn.code = code;
				break;
#endif
			   default:
				break;
			   }
			}
		}
		break;

#ifdef T1_DRIVER
	case TE1DCTRL_T1231INIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = t1231_init(sptr,set_clear)))
				sptr->t1231_init = set_clear;
		}
		break;

	case TE1DCTRL_TR008INIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = tr008_init(sptr,set_clear)))
				sptr->tr008_init = set_clear;
		}
		break;

	case TE1DCTRL_TR008CMAS:
		{int bit_map;
			bit_map = va_arg(alist, int);

			if((retval = cmas_init(sptr,bit_map)))
				sptr->cmas_init = bit_map;
		}
		break;

	case TE1DCTRL_EXCESSZERO:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = exz_init(sptr, set_clear)))
				sptr->exz_init= set_clear;
		}
		break;

	case TE1DCTRL_T1403INIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = t1403_init(sptr, set_clear)))
				sptr->t1403_init = set_clear;
		}
		break;

	case TE1DCTRL_T1403TXPKT:
		{int byte_count;
		 unsigned char *p;

			byte_count = va_arg(alist, int);
			p = va_arg(alist, unsigned char *);

			if(sptr->pkttx.active) 
				break;

			if(byte_count > MAX_PACKET)
				break;

			drvMemcpy(sptr->pkttx.pkt, p, byte_count);
			sptr->pkttx.byte_count = byte_count;

			retval = send_fdl_packet(sptr, 1);
		}
		break;

	case TE1DCTRL_T1403TXBOC:
		{int set_clear;
		 int code;

			set_clear = va_arg(alist, int);
			code = va_arg(alist, int);

			sptr->boctx.active = set_clear;
			sptr->boctx.boc = code;

			retval = send_fdl_boc(sptr);
		}
		break;

	case TE1DCTRL_TR54016INIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = tr54016_init(sptr, set_clear)))
				sptr->tr54016_init = set_clear;
		}
		break;

#endif
#ifdef E1_DRIVER
	case TE1DCTRL_G826INIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = g826_init(sptr,set_clear)))
				sptr->g826_init = set_clear;
		}
		break;

	case TE1DCTRL_RESYNC:
		retval = do_resync(sptr);
		break;

	case TE1DCTRL_E1SASIINIT:
		{int set_clear;
			set_clear = va_arg(alist, int);

			if((retval = sasi_init(sptr, set_clear)))
				sptr->sasi_init = set_clear;
		}
		break;

	case TE1DCTRL_E1SASISABYTE:
		{int sabyteN, sabyte;
			sabyteN = va_arg(alist, int);
			sabyte = va_arg(alist, int);

			if((retval = tx_sabyte(sptr, sabyteN, sabyte)))
				sptr->sabyte[sabyteN] = sabyte;
		}
		break;

	case TE1DCTRL_E1SASISABIT:
		{int sa_bits;
			sa_bits = va_arg(alist, int);

			if((retval = tx_sabits(sptr, sa_bits)))
				sptr->sa_bits = sa_bits;
		}
		break;

	case TE1DCTRL_E1SASISIBIT:
		{int si_bits;
			si_bits = va_arg(alist, int);

			if((retval = tx_sibits(sptr, si_bits)))
				sptr->si_bits = si_bits;
		}
		break;

	case TE1DCTRL_E1SASIXBIT:
		{int x_bits;
			x_bits = va_arg(alist, int);

			if((retval = tx_xbits(sptr, x_bits)))
				sptr->x_bits = x_bits;
		}
		break;
#endif

	default:
		break;
	}

	va_end (alist);
	return((retval) ? SUCCESS : ERR_FAILURE);
}


/*--------------------------------------------------------------------------*/
int TE1_POLLENTRY(void *LnPtr, TE1DPOLL_FC fcode, ...)
{
int retval = 0;
STUFF *sptr = (STUFF *)LnPtr;
va_list alist;

	if(LnPtr == NULL) {
		return(ERR_FAILURE);
	}

	va_start (alist, fcode);

	switch (fcode) {
	case TE1DPOLL_DEVICE:
		{unsigned long uparam1,uparam2,uparam3,uparam4;
			/* The call passes from the APP */
			/* 4 parameters as shown below */
			/* Below that is an example of how */
			/* to extract one parameter for use */

			/* param1 = (void * or ulong) user-defined
			 * param2 = (void * or ulong) user-defined
			 * param3 = (void * or ulong) user-defined
			 * param4 = (void * or ulong) user-defined
			 */

			uparam1 = va_arg (alist, unsigned long);
			uparam2 = va_arg (alist, unsigned long);
			uparam3 = va_arg (alist, unsigned long);
			uparam4 = va_arg (alist, unsigned long);

			retval = CUSTOM_POLL(sptr,
				uparam1, uparam2, uparam3, uparam4);
		}
		break;

	case TE1DPOLL_ALARMRX:
		{int alarm_type;
		 int *vptr;
			alarm_type = va_arg(alist, int);
			vptr = va_arg(alist, int *);

			retval = poll_alarm(sptr, alarm_type, vptr);
		}
		break;

	case TE1DPOLL_LOOP:
		{int loop_type;
		 int *vptr;
			loop_type = va_arg(alist, int);
			vptr = va_arg(alist, int *);

			retval = poll_loop(sptr, loop_type, vptr);
		}
		break;

	case TE1DPOLL_SIGNLALLBITS:
		{int *all_rxbits;
			all_rxbits = va_arg(alist, int *);

			retval = poll_allrxbits(sptr, all_rxbits);
		}
		break;

#ifdef T1_DRIVER
	case TE1DPOLL_PERFINFO:	/* retrive the latest counts */
		{T1_PERFINFO *t1perf_info;
			t1perf_info = va_arg(alist, T1_PERFINFO *);

			retval = get_pm(sptr, t1perf_info);
		}
		break;
#endif /* T1_DRIVER */

#ifdef E1_DRIVER
	case TE1DPOLL_PERFINFO:	/* retrive the latest counts */
		{E1_PERFINFO *e1perf_info;
			e1perf_info = va_arg(alist, E1_PERFINFO *);

			retval = get_pm(sptr, e1perf_info);
		}
		break;

	case TE1DPOLL_E1SASISABYTE:
		{int sabyteN, *sabyte;
			sabyteN = va_arg(alist, int);
			sabyte = va_arg(alist, int *);

			retval = poll_sabyte(sptr, sabyteN, sabyte);
		}
		break;

	case TE1DPOLL_E1SASISABIT:
		{int *sa_bits;
			sa_bits = va_arg(alist, int *);

			retval = poll_sabits(sptr, sa_bits);
		}
		break;

	case TE1DPOLL_E1SASISIBIT:
		{int *si_bit;
			si_bit = va_arg(alist, int *);

			retval = poll_sibits(sptr, si_bit);
		}
		break;

	case TE1DPOLL_E1SASIXBIT:
		{int *x_bit;
			x_bit = va_arg(alist, int *);

			retval = poll_xbits(sptr, x_bit);
		}
		break;
#endif /* E1_DRIVER */

	default:
		break;
	}

	va_end (alist);
	return((retval) ? SUCCESS : ERR_FAILURE);
}