File /code/strss7/drivers/m2ua/m2ua_sl.h

#ifndef __M2UA_SL_H__
#define __M2UA_SL_H__

/*
 *  =========================================================================
 *
 *  M2UA --> SLP
 *
 *  =========================================================================
 *
 *  M2UA (SGP) --> SLP Downstream Primitives
 *
 *  -------------------------------------------------------------------------
 */

/*
 *  SL_INFO_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_info_req(void)
{
	mblk_t *mp;
	sl_info_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_info_req_t *) mp->b_wptr;
		p->primitive = SL_INFO_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ATTACH_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_attach_req(ppa_ptr, ppa_len)
	const caddr_t ppa_ptr;
	const size_t ppa_len;
{
	mblk_t *mp;
	sl_attach_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_attach_req_t *) mp->b_wptr;
		p->primitive = SL_ATTACH_REQ;
		mp->b_wptr += sizeof(*p);
		bcopy(ppa_ptr, mp->b_wptr, ppa_len);
		mp->b_wptr += ppa_len;
	}
	return (mp);
}

/*
 *  SL_DETACH_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_detach_req(void)
{
	mblk_t *mp;
	sl_detach_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_detach_req_t *) mp->b_wptr;
		p->primitive = SL_DETACH_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ENABLE_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_enable_req(void)
{
	mblk_t *mp;
	sl_enable_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_enable_req_t *) mp->b_wptr;
		p->primitive = SL_ENABLE_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_DISABLE_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_disable_req(void)
{
	mblk_t *mp;
	sl_disable_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_disable_req_t *) mp->b_wptr;
		p->primitive = SL_DISABLE_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_OPTMGMT_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_optmgmt_req(opt_ptr, opt_len, flags)
	const caddr_t opt_ptr;
	const size_t opt_len;
	const uint flags;
{
	mblk_t *mp;
	sl_optmgmt_req_t *p;
	if ((mp = allocb(sizeof(*p) + opt_len, BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_optmgmt_req_t *) mp->b_wptr;
		p->primitive = SL_OPTMGMT_REQ;
		p->opt_length = opt_len;
		p->opt_offset = opt_len ? sizeof(*p) : 0;
		p->mgmt_flags = flags;
		mp->b_wptr += sizeof(*p);
		bcopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b_wptr += opt_len;
	}
	return (mp);
}

/*
 *  SL_NOTIFY_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_notify_req(not_ptr, not_len, flags)
{
	mblk_t *mp;
	sl_notify_req_t *p;
	if ((mp = allocb(sizeof(*p) + not_len, BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_notify_req_t *) mp->b_wptr;
		p->primitive = SL_NOTIFY_REQ;
		p->not_length = not_len;
		p->not_offset = not_len ? sizeof(*p) : 0;
		p->mgmt_flags = flags;
		mp->b_wptr += sizeof(*p);
		bcopy(not_ptr, mp->b_wptr, not_len);
		mp->b_wptr += not_len;
	}
	return (mp);
}

/*
 *  SL_PDU_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_pdu_req(db)
	mblk_t *db;
{
	mblk_t *mp;
	sl_pdu_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_pdu_req_t *) mp->b_wptr;
		p->primitive = SL_PDU_REQ;
		mp->b_wptr += sizeof(*p);
		mp->b_cont = db;
	}
	return (mp);
}

/*
 *  SL_EMERGENCY_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_emergency_req(void)
{
	mblk_t *mp;
	sl_emergency_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_emergency_req_t *) mp->b_wptr;
		p->primitive = SL_EMERGENCY_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_EMERGENCY_CEASES_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_emergency_ceases_req(void)
{
	mblk_t *mp;
	sl_emergency_ceases_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_emergency_ceases_t *) mp->b_wptr;
		p->primitive = SL_EMERGENCY_CEASES_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_START_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_start_req(void)
{
	mblk_t *mp;
	sl_start_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_start_req_t *) mp->b_wptr;
		p->primitive = SL_START_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_STOP_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_stop_req(void)
{
	mblk_t *mp;
	sl_stop_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_stop_req_t *) mp->b_wptr;
		p->primitive = SL_STOP_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RETRIEVE_BSNT_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_retrieve_bsnt_req(void)
{
	mblk_t *mp;
	sl_retrieve_bsnt_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_retrieve_bsnt_req_t *) mp->b_wptr;
		p->primitive = SL_RETRIEVE_BSNT_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RETRIEVAL_REQUEST_AND_FSNC_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_retrieval_request_and_fsnc_req(fsnc)
	const uint fsnc;
{
	mblk_t *mp;
	sl_retrieval_request_and_fsnc_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_retrieval_request_and_fsnc_req_t *) mp->b_wptr;
		p->primitive = SL_RETRIEVAL_REQUEST_AND_FSNC_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RESUME_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_resume_req(void)
{
	mblk_t *mp;
	sl_resume_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_resume_req_t *) mp->b_wptr;
		p->primitive = SL_RESUME_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_CLEAR_BUFFERS_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_clear_buffers_req(void)
{
	mblk_t *mp;
	sl_clear_buffers_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_clear_buffers_t *) mp->b_wptr;
		p->primitive = SL_CLEAR_BUFFERS_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_CLEAR_RTB_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_clear_rtb_req(void)
{
	mblk_t *mp;
	sl_clear_rtb_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_clear_rtb_req_t *) mp->b_wptr;
		p->primitive = SL_CLEAR_RTB_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_LOCAL_PROCESSOR_OUTAGE_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_local_processor_outage_req(void)
{
	mblk_t *mp;
	sl_local_processor_outage_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_local_processor_outage_req_t *) mp->b_wptr;
		p->primitive = SL_LOCAL_PROCESSOR_OUTAGE_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_CONGESTION_DISCARD_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_congestion_discard_req(void)
{
	mblk_t *mp;
	sl_congestion_discard_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_congestion_discard_req_t *) mp->b_wptr;
		p->primitive = SL_CONGESTION_DISCARD_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_CONGESTION_ACCEPT_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_congestion_accept_req(void)
{
	mblk_t *mp;
	sl_congestion_accept_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_congestion_accept_req_t *) mp->b_wptr;
		p->primitive = SL_CONGESTION_ACCEPT_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_NO_CONGESTION_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_no_congestion_req(void)
{
	mblk_t *mp;
	sl_no_congestion_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_no_congestion_req_t *) mp->b_wptr;
		p->primitive = SL_NO_CONGESTION_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_POWER_ON_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_power_on_req(void)
{
	mblk_t *mp;
	sl_power_on_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_power_on_req_t *) mp->b_wptr;
		p->primitive = SL_POWER_ON_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  -------------------------------------------------------------------------
 *
 *  M2UA (ASP) --> SLU Upstream Primitives (Not handled by translator)
 *
 *  -------------------------------------------------------------------------
 */
/*
 *  SL_INFO_ACK
 *  -------------------------------------------------------------------------
 *  Put together information about the signalling link stream.
 */
static __inline__ mblk_t *sl_info_ack(q)
	const queue_t *q;
{
	mblk_t *mp;
	slu_t *sl = ((sl_t *) q->q_ptr)->iid;
	sl_info_ack_t *p;
	if ((mp = allocb(sizeof(*p) + sl->ppa_len, BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_info_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_INFO_ACK;
		p->sl_version = sl->version;
		p->sl_state = sl->state;
		p->sl_max_sdu = sl->max_sdu;
		p->sl_min_pdu = sl->min_sdu;
		p->sl_header_len = sl->header_len;
		p->sl_ppa_style = sl->ppa_style;
		mp->b_wptr += sizeof(*p);
		bcopy(sl->ppa, mp->b_rptr, sl->ppa_len);
		mp->b_wptr += sl->ppa_len;
	}
	return (mp);
}

/*
 *  SL_OK_ACK
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_ok_ack(prim)
	unsigned long prim;
{
	mblk_t *mp;
	sl_ok_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_ok_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_OK_ACK;
		p->sl_correct_primitive = prim;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ERROR_ACK
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_error_ack(ulong prim, long err)
{
	mblk_t *mp;
	sl_error_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_error_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_ERROR_ACK;
		p->sl_errno = err > 0 ? err : SL_SYSERR;
		p->sl_reason = err < 0 ? -err : 0;
		p->sl_error_primitive = prim;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ENABLE_CON
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_enable_con(void)
{
	mblk_t *mp;
	sl_enable_con_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_enable_con_t *) mp->b_wptr;
		p->sl_primitive = SL_ENABLE_CON;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_DISABLE_CON
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_disable_con(void)
{
	mblk_t *mp;
	sl_disable_con_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_disable_con_t *) mp->b_wptr;
		p->sl_primitive = SL_DISABLE_CON;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_OPTMGMT_ACK
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *sl_optmgmt_ack(opt_ptr, opt_len, flags)
	const caddr_t *opt_ptr;
	const size_t *opt_len;
	const uint flags;
{
	mblk_t *mp;
	sl_opmgmt_ack_t *p;
	if ((mp = allocb(sizeof(*p) + opt_len, BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_optmgmt_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_OPTMGMT_ACK;
		p->sl_opt_length = opt_len;
		p->sl_opt_offset = opt_len ? sizeof(*p) : 0;
		p->sl_mgmt_flags = flags;
		mp->b_wptr += sizeof(*p);
		bcopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b_wptr += opt_len;
	}
	return (mp);
}

/*
 *  SL_NOTIFY_IND
 */

#endif				/* __M2UA_SL_H__ */