sdt.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

static inline void
sdt_suerm_su_in_error(sdt_t *sdt) /* RxISR */
{
	if ( sdt->statem.suerm_state == SDT_STATE_IN_SERVICE )
	{
		sdt->statem.Cs++;
		if ( sdt->statem.Cs >= sdt->config.T )
		{
			sdt->ucalls->lsc_link_failure(sdt); /*-upstream-*/
			sdt->statem.suerm_state = SDT_STATE_IDLE;
			return;
		}
		sdt->statem.Ns++;
		if ( sdt->statem.Ns >= sdt->config.D )
		{
			sdt->statem.Ns = 0;
			if ( sdt->statem.Cs )
				sdt->statem.Cs--;
		}
	}
}

static inline void
sdt_eim_su_in_error(sdt_t *sdt) /* RxISR */
{
	if ( sdt->statem.eim_state == SDT_STATE_MONITORING )
		sdt->statem.interval_error = 1;
}

static inline void
sdt_suerm_correct_su(sdt_t *sdt) /* RxISR */
{
	if ( sdt->statem.suerm_state == SDT_STATE_IN_SERVICE )
	{
		sdt->statem.Ns++;
		if ( sdt->statem.Ns >= sdt->config.D )
		{
			sdt->statem.Ns = 0;
			if ( sdt->statem.Cs )
				sdt->statem.Cs--;
		}
	}
}

static inline void
sdt_eim_correct_su(sdt_t *sdt) /* RxISR */
{
	if ( sdt->statem.eim_state == SDT_STATE_MONITORING )
		sdt->statem.su_received = 1;
}

static void sdt_t8_timeout(sdt_t *sdt);

static inline void
sdt_timer_stop_t8(sdt_t *sdt)
{
	if ( sdt->timers.t8 ) untimeout(sdt->timers.t8);
}

static inline void
sdt_timer_start_t8(sdt_t *sdt)
{
	sdt_timer_stop_t8(sdt);
	sdt->timers.t8 = timeout(
			(timo_fcn_t *)sdt_t8_timeout,
			(caddr_t)sdt, sdt->config.t8);
}


static void
sdt_t8_timeout(sdt_t *sdt)
{
	if ( sdt->statem.eim_state == SDT_STATE_MONITORING )
	{
		sdt_timer_start_t8(sdt);
#if 0   /* probably just limit compress count */
		if ( sdt->option.popt & SS7_POPT_PING )
		{
			int psw;            /* force frame once per t8 */
			SPLSTR(psw);
			sdt->device->ifflags &= ~SDT_IF_SU_REPEAT;
			SPLX(psw);
		}
#endif
		if (sdt->statem.su_received)
		{
			sdt->statem.su_received = 0;
			if ( !sdt->statem.interval_error )
			{
				if ( (sdt->statem.Ce -= sdt->config.De) < 0 )
					sdt->statem.Ce = 0;
				return;
			}
		}
		sdt->statem.Ce += sdt->config.Ue;
		sdt->statem.interval_error = 0;
		if ( sdt->statem.Ce > sdt->config.Te )
		{
			sdt->ucalls->lsc_link_failure(sdt); /*-upstream-*/
			sdt->statem.eim_state = SDT_STATE_IDLE;
		}
	}
}

static inline void
sdt_eim_start(sdt_t *sdt)
{
	sdt->statem.Ce = 0;
	sdt->statem.interval_error = 0;
	sdt->statem.su_received = 0;
	sdt_timer_start_t8(sdt);
	sdt->statem.eim_state = SDT_STATE_MONITORING;
}

static inline void
sdt_eim_stop(sdt_t *sdt)
{
	sdt->statem.eim_state = SDT_STATE_IDLE;
	sdt_timer_stop_t8(sdt);
}

static inline void
sdt_daedr_correct_su(sdt_t *sdt, int count)
{
	int i;
	for ( i=0; i<count; i++)
	{
		sdt_eim_correct_su(sdt);
		sdt_suerm_correct_su(sdt);
		sdt_aerm_correct_su(sdt);
	}
}

static inline void
sdt_daedr_su_in_error(sdt_t *sdt)
{
	sdt_suerm_su_in_error(sdt);
	sdt_aerm_su_in_error(sdt);
}

static inline void
sdt_daedr_received_bits(sdt_t *sdt, mblk_t *mp)
{
	sdt->ucalls->rc_signal_unit(sdt, mp);   /*-upstream-*/
	sdt_daedr_correct_su(sdt, 1);
}

static inline void
sdt_daedt_transmission_request(sdt_t *sdt)
{
	sdt->ucalls->txc_transmission_request(sdt); /*-upstream-*/
}

/*
 *  ==============================================================
 *
 *  SL->SDT Service Calls (Driver)
 *
 *  ==============================================================
 */

static void
sdt_daedt_xmit(sdt_t *sdt, mblk_t *mp)
{
	if ( sdt->statem.daedt_state != SDT_STATE_IDLE )
	{
		*((sdt_long *)mp->b_rptr) = SDL_DAEDT_TRANSMISSION_REQ;
		sdt->dcalls->daedt_xmit(sdt, mp);
	}
	assert(mp->b_datap->db_ref);
	freemsg(mp);
}

static void
sdt_daedr_start(sdt_t *sdt)
{
	if ( sdt->statem.daedr_state == SDT_STATE_IDLE )
	{
		sdt->statem.daedr_state = SDT_STATE_IN_SERVICE;
		sdt->dcalls->daedr_start(sdt);
	}
}

static void
sdt_daedt_start(sdt_t *sdt)
{
	if ( sdt->statem.daedt_state == SDT_STATE_IDLE )
	{
		sdt->statem.daedt_state = SDT_STATE_IN_SERVICE;
		sdt->dcalls->daedt_start(sdt);
	}
}

static void
sdt_aerm_start(sdt_t *sdt)
{
	sdt->statem.Ca = 0;
	sdt->statem.aborted_proving = 0;
	sdt->statem.aerm_state = SDT_STATE_MONITORING;
}

static void
sdt_aerm_stop(sdt_t *sdt)
{
	sdt->statem.aerm_state = SDT_STATE_IDLE;
	sdt->statem.Ti = sdt->config.Tin;
}

static void
sdt_aerm_set_ti_to_tin(sdt_t *sdt)
{
	if ( sdt->statem.aerm_state == SDT_STATE_IDLE )
		sdt->statem.Ti = sdt->config.Tin;
}

static void
sdt_aerm_set_ti_to_tie(sdt_t *sdt)
{
	if ( sdt->statem.aerm_state == SDT_STATE_IDLE )
		sdt->statem.Ti = sdt->config.Tie;
}

static void
sdt_suerm_eim_start(sdt_t *sdt)
{
	if ( sdt->option.popt & SS7_POPT_HSL )
		sdt_eim_start(sdt);
	else	sdt_suerm_start(sdt);
}

static void
sdt_suerm_eim_stop(sdt_t *sdt)
{
	sdt_eim_stop(sdt);
	sdt_suerm_stop(sdt);
}

static sdt_dcalls_t sdt_drv_ops =
{
	sdt_daedt_xmit,		/* daedt_xmit	*/
	sdt_daedt_start,	/* daedt_start	*/
	sdt_daedr_start,	/* daedr_start	*/
	sdt_aerm_start,		/* aerm_start	*/
	sdt_aerm_stop,		/* aerm_stop	*/
	sdt_aerm_set_ti_to_tin,	/* aerm_set_tin	*/
	sdt_aerm_set_ti_to_tie,	/* aerm_set_tie	*/
	sdt_suerm_eim_start,	/* suerm_start	*/
	sdt_suerm_eim_stop	/* suerm_stop	*/
};

/*
 *  ==============================================================
 *
 *  SL->SDT Service Primitives (M_CTL, M_PROTO, M_PCPROTO)
 *
 *  ==============================================================
 */

static void sdt_daedt_xmit_req(sdt_t *sdt, mblk_t *mp)
{
	sdt_daedt_xmit(sdt, mp);
}
static void sdt_daedt_start_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_daedt_start(sdt);
}
static void sdt_daedr_start_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_daedr_start(sdt);
}
static void sdt_aerm_start_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_aerm_start(sdt);
}
static void sdt_aerm_stop_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_aerm_stop(sdt);
}
static void sdt_aerm_set_ti_to_tin_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_aerm_set_ti_to_tin(sdt);
}
static void sdt_aerm_set_ti_to_tie_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_aerm_set_ti_to_tie(sdt);
}
static void sdt_suerm_eim_start_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_suerm_eim_start(sdt);
}
static void sdt_suerm_eim_stop_req(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_suerm_eim_stop(sdt);
}
static void (*sdt_sl_ops[])(sdt_t *, mblk_t *) =
{
	sdt_daedt_xmit_req,		/* SDT_DAEDT_TRANSMISSION_REQ	*/
	sdt_daedt_start_req,		/* SDT_DAEDT_START_REQ		*/
	sdt_daedr_start_req,		/* SDT_DAEDR_START_REQ		*/
	sdt_aerm_start_req,		/* SDT_AERM_START_REQ		*/
	sdt_aerm_stop_req,		/* SDT_AERM_STOP_REQ		*/
	sdt_aerm_set_ti_to_tin_req,	/* SDT_AERM_SET_TI_TO_TIN_REQ	*/
	sdt_aerm_set_ti_to_tie_req,	/* SDT_AERM_SET_TI_TO_TIE_REQ	*/
	sdt_suerm_eim_start_req,	/* SDT_SUERM_START_REQ		*/
	sdt_suerm_eim_stop_req		/* SDT_SUERM_STOP_REQ		*/
};

/*
 *  ==============================================================
 *
 *  SDL->SDT Service Calls (Driver)  (WARNING: called at IRQ)
 *
 *  ==============================================================
 */

static void sdl_daedr_received_bits(sdl_t *sdl, mblk_t *mp)
{
	sdt_daedr_received_bits(sdl->module, mp);
}

static void sdl_daedr_correct_su(sdl_t *sdl, int count)
{
	sdt_daedr_correct_su(sdl->module, count);
}

static void sdl_daedr_su_in_error(sdl_t *sdl)
{
	sdt_daedr_su_in_error(sdl->module);
}

/* driver calls */

static sdl_ucalls_t sdt_drv_ucalls =
{
	sdl_daedr_received_bits,/* daedr_received_bits	*/
	sdl_daedr_correct_su,	/* daedr_correct_su	*/
	sdl_daedr_su_in_error	/* daedr_su_in_error	*/
};

/*
 *  ==============================================================
 *
 *  SDL->SDT Service Primitives (M_CTL, M_PROTO, M_PCPROTO)
 *
 *  ==============================================================
 */

static void sdl_daedr_received_bits_ind(sdt_t *sdt, mblk_t *mp)
{
	sdt_daedr_received_bits(sdt, mp);
}
static void sdl_daedr_correct_su_ind(sdt_t *sdt, mblk_t *mp)
{
	int count = ((sdl_daedr_correct_su_ind_t *)mp->b_rptr)->sdl_count;
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_daedr_correct_su(sdt, count);
}
static void sdl_daedr_su_in_error_ind(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_daedr_su_in_error(sdt);
}

static void sdl_daedt_transmission_request_ind(sdt_t *sdt, mblk_t *mp)
{
	assert(mp->b_datap->db_ref);
	freemsg(mp);
	sdt_daedt_transmission_request(sdt);
}

static void (*sdt_sdl_ops[])(sdt_t *, mblk_t *) =
{
	sdl_daedr_received_bits_ind,		/* SDL_DAEDR_RECEIVED_BITS_IND		*/
	sdl_daedr_correct_su_ind,		/* SDL_DAEDR_CORRECT_SU_IND		*/
	sdl_daedr_su_in_error_ind,		/* SDL_DAEDR_SU_IN_ERROR_IND		*/
	sdl_daedt_transmission_request_ind	/* SDL_DAEDT_TRANSMISSION_REQUEST_IND	*/
};

/*
 *  =======================================================================
 *
 *  M_IOCTL handling
 *
 *  =======================================================================
 */

static int
sdt_do_ioctl(lmi_t *sdt, int cmd, void *arg)
{
	lmi_driver_t *drv;
	int nr = _IOC_NR(cmd);
	if ( _IOC_TYPE(cmd) == SDT_IOC_MAGIC )
		if ( SDT_IOC_FIRST <= nr && nr <= SDT_IOC_LAST )
			if ( sdt_ioc_lmiops[nr] )
				return sdt_ioc_lmiops[nr]((sdt_t *)sdt, cmd, arg);
	if ( (drv = sdt->driver) )
		return drv->ops.lmi.ioctl(sdt, cmd, arg);
	return -ENXIO;
}

#ifndef abs
#define abs(x) ((x)<0 ? -(x):(x))
#endif

static inline int
sdt_m_ioctl(queue_t *q, mblk_t *mp)
{
	sdt_t *sdt = (sdt_t *)q->q_ptr;
	struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
	void *arg = mp->b_cont?mp->b_cont->b_rptr:NULL;
	int cmd = iocp->ioc_cmd, size = iocp->ioc_count;
	int ret = -EINVAL;
	if ( size >= _IOC_SIZE(cmd) )
		ret = sdt_do_ioctl((lmi_t *)sdt, cmd, arg);
	if ( abs(ret) == ENXIO )
	{
		seldom();
		if ( q->q_next )
		{
			rare();
			putnext(q, mp);
			return(0);
		}
	}
	if ( ret == 0 )
	{
		mp->b_datap->db_type = M_IOCACK;
		iocp->ioc_error = 0;
		iocp->ioc_rval  = 0;
	}
	else
	{
		seldom();
		mp->b_datap->db_type = M_IOCNAK;
		iocp->ioc_error = abs(ret);
		iocp->ioc_rval  = -1;
	}
	qreply(q, mp);
	return(0);
}

/*
 *  =======================================================================
 *
 *  M_PROTO, M_PCPROTO handling
 *
 *  =======================================================================
 */

static inline int
sdt_m_proto(queue_t *q, mblk_t *mp)
{
	int err = LMI_BADPRIM + EOPNOTSUPP;
	sdt_t *sdt = (sdt_t *)q->q_ptr;
	int prim = *((sdt_long *)mp->b_rptr);
	if ( SDT_DSTR_FIRST <= prim && prim <= SDT_DSTR_LAST )
	{
		(*sdt_sl_ops[prim - SDT_DSTR_FIRST])(sdt, mp);
		return(0);
	}
	if ( q->q_next)
	{
		putnext(q, mp);
		return (0);
	}
	if ( LMI_DSTR_FIRST <= prim && prim <= LMI_DSTR_LAST )
	{
		err = (*lmi_lmi_ops[prim - LMI_DSTR_FIRST])((lmi_t *)sdt, mp);
	}
	return err;
}

static inline int
sdl_m_proto(queue_t *q, mblk_t *mp)
{