sl.c

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

	sl_l3_in_service,			/* sl_in_service	*/
	sl_l3_out_of_service,			/* sl_out_of_service	*/
	sl_l3_remote_processor_outage,		/* sl_rpoutage		*/
	sl_l3_remote_processor_recovered,	/* sl_rprecovered	*/
	sl_l3_rtb_cleared			/* sl_rtb_cleared	*/
};

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

static inline void sl_dprim(sl_t *sl, int type, int prim)
{
	mblk_t *mp;
	if ( (mp = allocb(sizeof(sl_long), BPRI_HI)) )
	{
		mp->b_datap->db_type = type;
		*((sl_long *)mp->b_wptr)++ = prim;
		putnext(sl->wq, mp);
	}
}

static void sdt_daedt_xmit_req(sl_t *sl, mblk_t *mp)
{
	if ( mp->b_datap->db_type != M_DATA )
	{
		*((sl_long *)mp->b_rptr) = SDT_DAEDT_TRANSMISSION_REQ;
		mp->b_datap->db_type = M_PROTO;
	}
	putnext(sl->wq, mp);
}
static void sdt_daedt_start_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_DAEDT_START_REQ);
}
static void sdt_daedr_start_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_DAEDR_START_REQ);
}
static void sdt_aerm_start_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_AERM_START_REQ);
}
static void sdt_aerm_stop_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_AERM_STOP_REQ);
}
static void sdt_aerm_set_ti_to_tin_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_AERM_SET_TI_TO_TIN_REQ);
}
static void sdt_aerm_set_ti_to_tie_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_AERM_SET_TI_TO_TIE_REQ);
}
static void sdt_suerm_start_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_SUERM_START_REQ);
}
static void sdt_suerm_stop_req(sl_t *sl)
{
	sl_dprim(sl, M_PCPROTO, SDT_SUERM_STOP_REQ);
}
static sl_mcalls_t sl_mod_dcalls =
{
	sdt_daedt_xmit_req,		/* daedt_xmit	*/
	sdt_daedt_start_req,		/* daedt_start	*/
	sdt_daedr_start_req,		/* daedr_start	*/
	sdt_aerm_start_req,		/* aerm_start	*/
	sdt_aerm_stop_req,		/* aerm_stop	*/
	sdt_aerm_set_ti_to_tin_req,	/* aerm_set_tin	*/
	sdt_aerm_set_ti_to_tie_req,	/* aerm_set_tie	*/
	sdt_suerm_start_req,		/* suerm_start	*/
	sdt_suerm_stop_req		/* suerm_stop	*/
};

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

static void sdt_daedt_xmit(sl_t *sl, mblk_t *mp)
{
	sl->driver->dcalls->daedt_xmit(sl->device, mp);
}
static void sdt_daedt_start(sl_t *sl)
{
	sl->driver->dcalls->daedt_start(sl->device);
}
static void sdt_daedr_start(sl_t *sl)
{
	sl->driver->dcalls->daedr_start(sl->device);
}
static void sdt_aerm_start(sl_t *sl) {
    sl->driver->dcalls->aerm_start(sl->device);
}
static void sdt_aerm_stop(sl_t *sl) {
    sl->driver->dcalls->aerm_stop(sl->device);
}
static void sdt_aerm_set_ti_to_tin(sl_t *sl)
{
	sl->driver->dcalls->aerm_set_tin(sl->device);
}
static void sdt_aerm_set_ti_to_tie(sl_t *sl)
{
	sl->driver->dcalls->aerm_set_tie(sl->device);
}
static void sdt_suerm_start(sl_t *sl)
{
	sl->driver->dcalls->suerm_start(sl->device);
}
static void sdt_suerm_stop(sl_t *sl)
{
	sl->driver->dcalls->suerm_stop(sl->device);
}

static sl_mcalls_t sl_drv_dcalls =
{
	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_start,	/* suerm_start	*/
	sdt_suerm_stop		/* uerm_stop	*/
};

/*
 *  =======================================================================
 *
 *  PROTOCOL STATE MACHINES
 *
 *  =======================================================================
 */

#include "sl_sm.h"

/*
 *  =======================================================================
 *
 *  SL<-LK Serivce Calls (Driver)
 *
 *  =======================================================================
 */

static inline void sl_pdu(sl_t *sl, mblk_t *mp)
{
	sl_lsc_pdu(sl, mp);
}
static inline void sl_emergency(sl_t *sl)
{
	sl_lsc_emergency(sl);
}
static inline void sl_emergency_ceases(sl_t *sl)
{
	sl_lsc_emergency_ceases(sl);
}
static inline void sl_start(sl_t *sl)
{
	sl_lsc_start(sl);
}
static inline void sl_stop(sl_t *sl)
{
	sl_lsc_stop(sl);
}
static inline void sl_retrieve_bsnt(sl_t *sl)
{
	sl_lsc_retrieve_bsnt(sl);
}
static inline void sl_retrieval_request_and_fsnc(sl_t *sl, int fsnc)
{
	sl_lsc_retrieval_request_and_fsnc(sl, fsnc);
}
static inline void sl_resume(sl_t *sl)
{
	sl_lsc_resume(sl);
}
static inline void sl_clear_buffers(sl_t *sl)
{
	sl_lsc_clear_buffers(sl);
}
static inline void sl_clear_rtb(sl_t *sl)
{
	sl_lsc_clear_rtb(sl);
}
static inline void sl_local_processor_outage(sl_t *sl)
{
	sl_lsc_local_processor_outage(sl);
}
static inline void sl_congestion_discard(sl_t *sl)
{
	sl_lsc_congestion_discard(sl);
}
static inline void sl_congestion_accept(sl_t *sl)
{
	sl_lsc_congestion_accept(sl);
}
static inline void sl_no_congestion(sl_t *sl)
{
	sl_lsc_no_congestion(sl);
}
static inline void sl_power_on(sl_t *sl)
{
	sl_lsc_power_on(sl);
}

#if 0
static sl_dcalls_t sl_drv_ops =
{
	sl_pdu,				/* sl_pdu		*/
	sl_emergency,			/* sl_emerg		*/
	sl_emergency_ceases,		/* sl_normal		*/
	sl_start,			/* sl_start		*/
	sl_stop,			/* sl_stop		*/
	sl_retrieve_bsnt,		/* sl_bsnt		*/
	sl_retrieval_request_and_fsnc,	/* sl_fsnc		*/
	sl_resume,			/* sl_resume		*/
	sl_clear_buffers,		/* sl_clear_bufs	*/
	sl_clear_rtb,			/* sl_clear_rtb		*/
	sl_local_processor_outage,	/* sl_lpo		*/
	sl_congestion_discard,		/* sl_cg_accept		*/
	sl_congestion_accept,		/* sl_cg_discard	*/
	sl_no_congestion,		/* sl_no_cong		*/
	sl_power_on			/* sl_power_on		*/
};
#endif

/*
 *  =======================================================================
 *
 *  SL<-LK Serivce Primitives (M_CTL, M_PROTO, M_PCPROTO)
 *
 *  =======================================================================
 */

static void sl_pdu_req(sl_t *sl, mblk_t *mp)
{
	sl_pdu(sl, mp);
}
static void sl_emergency_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_emergency(sl);
}
static void sl_emergency_ceases_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_emergency_ceases(sl);
}
static void sl_start_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_start(sl);
}
static void sl_stop_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_stop(sl);
}
static void sl_retrieve_bsnt_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_retrieve_bsnt(sl);
}
static void sl_retrieval_request_and_fsnc_req(sl_t *sl, mblk_t *mp)
{
	int fsnc = ((sl_ulong *)mp->b_rptr)[1];
	freemsg(mp);
	sl_retrieval_request_and_fsnc(sl, fsnc);
}
static void sl_resume_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_resume(sl);
}
static void sl_clear_buffers_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_clear_buffers(sl);
}
static void sl_clear_rtb_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_clear_rtb(sl);
}
static void sl_local_processor_outage_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_local_processor_outage(sl);
}
static void sl_congestion_discard_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_congestion_discard(sl);
}
static void sl_congestion_accept_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_congestion_accept(sl);
}
static void sl_no_congestion_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_no_congestion(sl);
}
static void sl_power_on_req(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_power_on(sl);
}

static void (*sl_lk_ops[])(sl_t *, mblk_t *) =
{
	sl_pdu_req,				/* SL_PDU_REQ				*/
	sl_emergency_req,			/* SL_EMERGENCY_REQ			*/
	sl_emergency_ceases_req,		/* SL_EMERGENCY_CEASES_REQ		*/
	sl_start_req,				/* SL_START_REQ				*/
	sl_stop_req,				/* SL_STOP_REQ				*/
	sl_retrieve_bsnt_req,			/* SL_RETRIEVE_BSNT_REQ			*/
	sl_retrieval_request_and_fsnc_req,	/* SL_RETRIEVAL_REQUEST_AND_FSNC_REQ	*/
	sl_resume_req,				/* SL_RESUME_REQ			*/
	sl_clear_buffers_req,			/* SL_CLEAR_BUFFERS_REQ			*/
	sl_clear_rtb_req,			/* SL_CLEAR_RTB_REQ			*/
	sl_local_processor_outage_req,		/* SL_LOCAL_PROCESSOR_OUTAGE_REQ	*/
	sl_congestion_discard_req,		/* SL_CONGESTION_DISCARD_REQ		*/
	sl_congestion_accept_req,		/* SL_CONGESTION_ACCEPT_REQ		*/
	sl_no_congestion_req,			/* SL_NO_CONGESTION_REQ			*/
	sl_power_on_req				/* SL_POWER_ON_REQ			*/
};

/*
 *  =======================================================================
 *
 *  SL<-SDT Serivce Calls (Driver)  (WARNING: may be called at IRQ)
 *
 *  =======================================================================
 */

static void sdt_rc_signal_unit(sdt_t *sdt, mblk_t *mp)
{
	sl_rc_signal_unit(sdt->module, mp);
}
static void sdt_rc_congestion_accept(sdt_t *sdt)
{
	sl_rc_congestion_accept(sdt->module);
}
static void sdt_rc_congestion_discard(sdt_t *sdt)
{
	sl_rc_congestion_discard(sdt->module);
}
static void sdt_rc_no_congestion(sdt_t *sdt)
{
	sl_rc_no_congestion(sdt->module);
}
static void sdt_iac_correct_su(sdt_t *sdt)
{
	sl_iac_correct_su(sdt->module);
}
static void sdt_iac_abort_proving(sdt_t *sdt)
{
	sl_iac_abort_proving(sdt->module);
}
static void sdt_lsc_link_failure(sdt_t *sdt)
{
	sl_lsc_link_failure(sdt->module);
}
static sdt_ucalls_t sl_drv_ucalls =
{
	sdt_rc_signal_unit,		/* rc_signal_unit		*/
	sdt_rc_congestion_accept,	/* rc_congestion_accept		*/
	sdt_rc_congestion_discard,	/* rc_congestion_discard	*/
	sdt_rc_no_congestion,		/* rc_no_congestion		*/
	sdt_iac_correct_su,		/* iac_correct_su		*/
	sdt_iac_abort_proving,		/* iac_abort_proving		*/
	sdt_lsc_link_failure		/* lsc_link_failure		*/
};

/*
 *  =======================================================================
 *
 *  SL<-SDT Serivce Primitives (M_CTL, M_PROTO, M_PCPROTO)
 *
 *  =======================================================================
 */

static void sdt_rc_signal_unit_ind(sl_t *sl, mblk_t *mp)
{
	sl_rc_signal_unit(sl, mp);
}
static void sdt_rc_congestion_accept_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_rc_congestion_accept(sl);
}
static void sdt_rc_congestion_discard_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_rc_congestion_discard(sl);
}
static void sdt_rc_no_congestion_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_rc_no_congestion(sl);
}
static void sdt_iac_correct_su_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_iac_correct_su(sl);
}
static void sdt_iac_abort_proving_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_iac_abort_proving(sl);
}
static void sdt_lsc_link_failure_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_lsc_link_failure(sl);
}
static void sdt_txc_transmission_request_ind(sl_t *sl, mblk_t *mp)
{
	freemsg(mp);
	sl_txc_transmission_request(sl);
}

static void (*sl_sdt_ops[])(sl_t *, mblk_t *) =
{
	sdt_rc_signal_unit_ind,		/* SDT_RC_SIGNAL_UNIT_IND		*/
	sdt_rc_congestion_accept_ind,	/* SDT_RC_CONGESTION_ACCEPT_IND		*/
	sdt_rc_congestion_discard_ind,	/* SDT_RC_CONGESTION_DISCARD_IND	*/
	sdt_rc_no_congestion_ind,	/* SDT_RC_NO_CONGESTION_IND		*/
	sdt_iac_correct_su_ind,		/* SDT_IAC_CORRECT_SU_IND		*/
	sdt_iac_abort_proving_ind,	/* SDT_IAC_ABORT_PROVING_IND		*/
	sdt_lsc_link_failure_ind,	/* SDT_LSC_LINK_FAILURE_IND		*/
	sdt_txc_transmission_request_ind/* SDT_TXC_TRANSMISSION_REQUEST_IND	*/
};

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

static int
sl_do_ioctl(lmi_t *sl, int cmd, void *arg)
{
	lmi_driver_t *drv;
	int nr = _IOC_NR(cmd);
	if ( _IOC_TYPE(cmd) == SL_IOC_MAGIC )
		if ( SL_IOC_FIRST <= nr && nr <= SL_IOC_LAST )