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

#ifndef __SL_PROV_H__
#define __SL_PROV_H__

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

/*
 *  SL_INFO_ACK                       25 - Information acknowledgement
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_info_ack(uint version, uint state, uint max_sdu, uint
				  min_sdu, uint header_len, uint ppa_style, caddr_t ppa_ptr,
				  size_t ppa_len)
{
	mblk_t *mp;
	sl_info_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_info_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_INFO_ACK;
		p->sl_version = version;
		p->sl_state = state;
		p->sl_max_sdu = max_sdu;
		p->sl_min_sdu = min_sdu;
		p->sl_header_len = header_len;
		p->sl_ppa_style = ppa_style;
		mp->b_wptr += sizeof(*p);
		bcopy(ppa_ptr, mp->b_wptr, ppa_len);
		mp->b_wptr += ppa_len;
	}
	return (mp);
}

/*
 *  SL_OK_ACK                         26 - Success acknowledgement
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_ok_ack(uint prim)
{
	mblk_t *mp;
	sl_ok_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		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                      27 - Error acknowledgement
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_error_ack(int prim, int err)
{
	mblk_t *mp;
	sl_error_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_error_ack_t *) mp->b_wptr;
		p->sl_primitive = SL_ERROR_ACK;
		p->sl_error_primitive = prim;
		p->sl_errno = err > 0 ? err : SL_SYSERR;
		p->sl_unix_error = err < 0 ? -err : 0;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ENABLE_CON                     28 - Enable confirmation
 *  -------------------------------------------------------------------------
 */
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_PROTO;
		p = (sl_enable_con_t *) mp->b_wptr;
		p->sl_primitive = SL_ENABLE_CON;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_DISABLE_CON                    29 - Disable confirmation
 *  -------------------------------------------------------------------------
 */
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_PROTO;
		p = (sl_disable_con_t *) mp->b_wptr;
		p->sl_primitive = SL_DISABLE_CON;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_OPTMGMT_ACK                    30 - Options management reply
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_optmgmt_ack(uint flags, caddr_t opt_ptr, size_t opt_len)
{
	mblk_t *mp;
	sl_optmgmt_ack_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		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                     31 - Notification indications
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_notify_ind(void)
{
	mblk_t *mp;
	sl_notify_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_notify_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_NOTIFY_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_ERROR_IND                      32 - Error indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_error_ind(void)
{
	mblk_t *mp;
	sl_error_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_error_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_ERROR_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_STATS_IND                      33 - Statistics report
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_stats_ind(void)
{
	mblk_t *mp;
	sl_stats_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_stats_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_STATS_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_EVENT_IND                      34 - Event indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_event_ind(void)
{
	mblk_t *mp;
	sl_event_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_event_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_EVENT_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_PDU_IND                        35 - Received message indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_pdu_ind(mblk_t * dp)
{
	mblk_t *mp;
	sl_pdu_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_pdu_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_PDU_IND;
		mp->b_wptr += sizeof(*p);
		mp->b_cont = dp;
	}
	return (mp);
}

/*
 *  SL_LINK_CONGESTED_IND             36 - Link congested
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_link_congested_ind(uint cong_status, uint disc_status)
{
	mblk_t *mp;
	sl_link_congested_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_link_congested_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_LINK_CONGESTED_IND;
		p->sl_cong_status = cong_status;
		p->sl_disc_status = disc_status;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_LINK_CONGESTION_CEASED_IND     37 - Link cnogestion ceased
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_link_congestion_ceased_ind(uint cong_status, uint disc_status)
{
	mblk_t *mp;
	sl_link_congestion_ceased_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_link_congestion_ceased_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_LINK_CONGESTION_CEASED_IND;
		p->sl_cong_status = cong_status;
		p->sl_disc_status = disc_status;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RETRIEVED_MESSAGE_IND          38 - Retrieved message indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_retrieved_message_ind(mblk_t * dp)
{
	mblk_t *mp;
	sl_retrieved_message_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_retrieved_message_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_RETRIEVED_MESSAGE_IND;
		mp->b_wptr += sizeof(*p);
		mp->b_cont = dp;
	}
	return (mp);
}

/*
 *  SL_RETRIEVAL_COMPLETED_IND        39 - Retrieval confirmation
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_retrieval_completed_ind(mblk_t * dp)
{
	mblk_t *mp;
	sl_retrieval_completed_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_retrieval_completed_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_RETRIEVAL_COMPLETED_IND;
		mp->b_wptr += sizeof(*p);
		mp->b_cont = dp;
	}
	return (mp);
}

/*
 *  SL_RB_CLEARED_IND                 40 - Receive buffer cleared ind
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_rb_cleared_ind(void)
{
	mblk_t *mp;
	sl_rb_cleared_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_rb_cleared_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_RB_CLEARED_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_BSNT_IND                       41 - Retrieved BSNT indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_bsnt_ind(uint bsnt)
{
	mblk_t *mp;
	sl_bsnt_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_bsnt_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_BSNT_IND;
		p->sl_bsnt = bsnt;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_IN_SERVICE_IND                 42 - In service indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_in_service_ind(void)
{
	mblk_t *mp;
	sl_in_service_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_in_service_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_IN_SERVICE_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_OUT_OF_SERVICE_IND             43 - Out of service indication
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_out_of_service_ind(uint reason)
{
	mblk_t *mp;
	sl_out_of_service_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_out_of_service_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_OUT_OF_SERVICE_IND;
		p->sl_reason = reason;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_REMOTE_PROCESSOR_OUTAGE_IND    44 - Remote processor out
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_remote_processor_outage_ind(void)
{
	mblk_t *mp;
	sl_remote_processor_outage_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_remote_processor_outage_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_REMOTE_PROCESSOR_OUTAGE_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_REMOTE_PROCESSOR_RECOVERED_IND 45 - Remote processor recovered
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_remote_processor_recovered_ind(void)
{
	mblk_t *mp;
	sl_remote_processor_recovered_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_remote_processor_recovered_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_REMOTE_PROCESSOR_RECOVERED_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RTB_CLEARED_IND                46 - Retransmit buffer cleared ind
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_rtb_cleared_ind(void)
{
	mblk_t *mp;
	sl_rtb_cleared_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_rtb_cleared_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_RTB_CLEARED_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_RETRIEVAL_NOT_POSSIBLE_IND     47 - Retrieval not possible ind
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_retrieval_not_possible_ind(void)
{
	mblk_t *mp;
	sl_retrieval_not_possible_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_retrieval_not_possible_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_RETRIEVAL_NOT_POSSIBLE_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  SL_BSNT_NOT_RETRIEVABLE_IND       48 - BSNT not retrievable ind
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *sl_bsnt_not_retrievable_ind(void)
{
	mblk_t *mp;
	sl_bsnt_not_retrievable_ind_t *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (sl_bsnt_not_retrievable_ind_t *) mp->b_wptr;
		p->sl_primitive = SL_BSNT_NOT_RETRIEVABLE_IND;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

#endif				/* __SL_PROV_H__ */