File /code/strss7/drivers/sl/sl_user.h

#ifndef __SL_USER_H__
#define __SL_USER_H__

#ident "@(#) $RCSfile: sl_user.h,v $ $Name:  $($Revision: 0.8.2.1 $) $Date: 2002/10/18 02:43:03 $"

/*
 *  =========================================================================
 *
 *  MTP-Provider --> SL-Provider Downstream Primitives sent Downstream
 *
 *  =========================================================================
 */
#include "../../include/ss7/sl.h"

/*
 *  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->sl_primitive = SL_INFO_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ATTACH_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_attach_req(caddr_t ppa_ptr, 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->sl_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->sl_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->sl_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->sl_primitive = SL_DISABLE_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_OPTMGMT_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_optmgmt_req(uint flags, caddr_t opt_ptr, size_t opt_len)
{
	mblk_t *mp;
	sl_optmgmt_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_optmgmt_req_t *) mp->b_wptr;
		p->sl_primitive = SL_OPTMGMT_REQ;
		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);
	}
	return (mp);
}

/*
 *  SL_NOTIFY_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_notify_req(void)
{
	mblk_t *mp;
	sl_notify_req_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (sl_notify_req_t *) mp->b_wptr;
		/* FIXME: more */
		p->sl_primitive = SL_NOTIFY_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_PDU_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_pdu_req(mblk_t * dp)
{
	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->sl_primitive = SL_PDU_REQ;
		mp->b_wptr += sizeof(*p);
		mp->b_cont = dp;
	}
	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->sl_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_req_t *) mp->b_wptr;
		p->sl_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->sl_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->sl_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->sl_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(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->sl_primitive = SL_RETRIEVAL_REQUEST_AND_FSNC_REQ;
		p->sl_fsnc = fsnc;
		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->sl_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_req_t *) mp->b_wptr;
		p->sl_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->sl_primitive = SL_CLEAR_RTB_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_LOCAL_PROCESSOR_OUTAGE_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_local_proc_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->sl_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->sl_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->sl_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->sl_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->sl_primitive = SL_POWER_ON_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

#endif				/* __SL_USER_H__ */