2094 lines
61 KiB
C
2094 lines
61 KiB
C
#include "./include/inc.h"
|
|
#include "./include/var_ext.h"
|
|
#include "./include/biccif.h"
|
|
/**************CPCI*************************/
|
|
#define CPCI_IDLE 0
|
|
#define CPCI_WAIT_CONTINUITY 1
|
|
#define CPCI_WAIT_ACM 2
|
|
#define CPCI_WAIT_ANM 3
|
|
#define CPCI_ANSWERED 4
|
|
#define CPCI_SUSPENDED 5
|
|
#define CPCI_WAIT_RLC 6
|
|
#define CPCI_WAIT_REL_COMP 7
|
|
#define CPCI_WAIT_RESET 8
|
|
#define CPCI_WAIT_GROUP_RESET 9
|
|
|
|
/*************CPCO*************************/
|
|
#define CPCO_IDLE 0
|
|
#define CPCO_WAIT_CONTINUITY 1
|
|
#define CPCO_WAIT_ACM 2
|
|
#define CPCO_WAIT_ANM 3
|
|
#define CPCO_ANSWERED 4
|
|
#define CPCO_SUSPENDED 5
|
|
#define CPCO_WAIT_RLC 6
|
|
#define CPCO_WAIT_REL_COMP 7
|
|
#define CPCO_WAIT_RESET 8
|
|
#define CPCO_WAIT_GROUP_RESET 9
|
|
|
|
/********************************************/
|
|
#define MGBS_IDLE 0
|
|
#define MGBS_WAIT_CGBA 1
|
|
#define MGBS_WAIT_CGUA 2
|
|
/********************************************/
|
|
#define MGBR_IDLE 0
|
|
#define MGBR_WAIT_BLOCKING_RESP 1
|
|
#define MGBR_WAIT_UNBLOCKING_RESP 2
|
|
/********************************************/
|
|
#define CRS_IDLE 0
|
|
#define CRS_WAIT_REL 1
|
|
/*******************************************/
|
|
#define CRR_IDLE 0
|
|
#define CRR_WAIT_RESPONSE 1
|
|
#define CRR_RESET 2
|
|
#define CRR_RESET_COMP 3
|
|
/*******************************************/
|
|
#define CGRS_IDLE 0
|
|
#define CGRS_WAIT_GRA 1
|
|
/*******************************************/
|
|
#define CGRR_IDLE 0
|
|
#define CGRR_WAIT_GROUP_RESET_COMP 1
|
|
/********************************************/
|
|
#define BLR_IDLE 0
|
|
#define BLR_WAIT_BLOCKING_RESP 1
|
|
#define BLR_REMOTE_LOCKED 2
|
|
#define BLR_WAIT_UNBLOCKING_RESP 3
|
|
/********************************************/
|
|
#define BLS_IDLE 0
|
|
#define BLS_WAIT_BLA 1
|
|
#define BLS_LOCAL_LOCKED 2
|
|
#define BLS_WAIT_UBA 3
|
|
/*******************************************/
|
|
|
|
|
|
|
|
BiccData_struct Bicc_Data;
|
|
const BiccTimer_struct *TIMER_PTR = &Timer_Data;
|
|
|
|
|
|
extern BiccReadPrim_union readPrim_union[BICC_MAX_PORT];
|
|
extern BiccWritePrim_union writePrim_union[BICC_MAX_PORT];
|
|
//extern BICC_Resource_pond BiccResource;
|
|
extern BiccMsg_union msg_union[BICC_MAX_PORT];
|
|
extern u8 local_platid;
|
|
|
|
extern void bicc_send_apm(u32 pid);
|
|
extern void bicc_log_err(const char *fmt, ...);
|
|
extern void bicc_send_res(u32 pid);
|
|
extern void bicc_send_sus(u32 pid);
|
|
extern void bicc_send_sam(u32 pid);
|
|
extern void bicc_send_rsc(u32 pid);
|
|
extern void bicc_send_rlc(u32 pid);
|
|
extern void bicc_send_rel(u32 pid);
|
|
extern void bicc_send_iam(u32 pid);
|
|
extern void bicc_send_con(u32 pid);
|
|
extern void bicc_send_gra(u32 pid);
|
|
extern void bicc_send_grs(u32 pid);
|
|
extern void bicc_send_cgua(u32 pid);
|
|
extern void bicc_send_cgu(u32 pid);
|
|
extern void bicc_send_cgba(u32 pid);
|
|
extern void bicc_send_cgb(u32 pid);
|
|
extern void bicc_send_cpg(u32 pid);
|
|
extern void bicc_send_anm(u32 pid);
|
|
extern void bicc_send_acm(u32 pid);
|
|
extern BOOL check_crs_waiting(u32 pid);
|
|
extern int check_outbound_route(BYTE nw, long dpc, BYTE sls);
|
|
|
|
|
|
void bicc_cpc_clear(u32 pid)
|
|
{
|
|
memset(&Bicc_Data.port_data[pid], 0, sizeof(BICC_Port_struct));
|
|
}
|
|
|
|
|
|
BOOL bicc_cgrs_func(u32 start_pid, u8 range)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
Bicc_Data.port_data[pid].cic_state.call_state = BICC_RESET;
|
|
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_cgrsack_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
Bicc_Data.port_data[pid].cic_state.call_state = BICC_CIC_IDLE;
|
|
memset(&Bicc_Data.port_data[pid], 0, sizeof(BICC_Port_struct));
|
|
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
Bicc_Data.port_data[pid].cic_state.blo_state |= M_REMOTE_BLOCK;
|
|
else
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= 0x0d;
|
|
}
|
|
//BiccResource.circuit_pond[start_pid/BICC_CIRCUIT_CIC].active_flag = 1;
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_cgrr_func(u32 start_pid, u8 range, RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
rs_ptr->range = range;
|
|
memset(rs_ptr->status, 0, 4);
|
|
if(start_pid+range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= 0x0d;
|
|
if(Bicc_Data.port_data[pid].cic_state.blo_state & M_LOCAL_BLOCK)
|
|
{
|
|
if(Bicc_Data.port_data[pid].fsm_state.mgbs_state != MGBS_WAIT_CGUA)
|
|
rs_ptr->status[i>>3]|= 0x01 << (i&0x07);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
void bicc_set_cause(CauseInd_struct *cause_ptr, u8 val)
|
|
{
|
|
cause_ptr->pres = 1;
|
|
cause_ptr->codingStd = 0; //CCITT standardized coding
|
|
cause_ptr->location = 5; //private network serving the remote user
|
|
cause_ptr->causeVal = val;
|
|
}
|
|
|
|
void bicc_circuit_reset(u32 pid, const char *s)
|
|
{
|
|
#ifdef BICC_DEBUG
|
|
bicc_log_err("BICC circuit reset!, %s\n", s);
|
|
#endif
|
|
|
|
if(check_crs_waiting(pid))
|
|
return;
|
|
Bicc_Data.port_data[pid].primitive_cmd = BICC_RESET_REQ;
|
|
}
|
|
|
|
|
|
BOOL bicc_localblocking_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= M_LOCAL_BLOCK;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_remoteblocking_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= M_REMOTE_BLOCK;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_cpcoblocking_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
{
|
|
if(Bicc_Data.port_data[pid].cic_state.call_state == BICC_OUTGOING)
|
|
Bicc_Data.port_data[pid].internal_cmd = (BICC_CMD_BLO|BICC_SI_MGBR);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_localunblocking_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= 0x0e;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
BOOL bicc_remoteunblocking_func(u32 start_pid, const RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
u32 pid;
|
|
|
|
if(start_pid+rs_ptr->range >= BICC_MAX_PORT)
|
|
return 0;
|
|
for(i = 0; i <= rs_ptr->range; i++)
|
|
{
|
|
pid = start_pid + i;
|
|
if((rs_ptr->status[i>>3]>>(i&0x07)) & 0x01)
|
|
Bicc_Data.port_data[pid].cic_state.blo_state &= 0x0d;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
BOOL bicc_event_handle(u32 pid, BiccReadPrim_union *prm_ptr, u8 primitive, u8 eventType)
|
|
{
|
|
BICC_EventHandle_struct *eh_ptr = NULL;
|
|
Pst pst;
|
|
u32 cic;
|
|
int circuit_id, offset, ret = -1;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
const pal_cg_struct *pcg = NULL;
|
|
|
|
circuit_id = pid / BICC_CIRCUIT_CIC;
|
|
offset = pid % BICC_CIRCUIT_CIC;
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return BICC_CM_FAILED;
|
|
cic = pcircuit->attrib.head_cic + offset;
|
|
|
|
pst.cg_id = pcircuit->cg_id;
|
|
pcg = pal_cg_ptr(pst.cg_id);
|
|
if(pcg == NULL)
|
|
return BICC_CM_FAILED;
|
|
if(pcg->attrib.protocol != PROTO_BICC)
|
|
return BICC_CM_FAILED;
|
|
pst.tg_id = pcg->attrib.tg_id;
|
|
pst.sp_proc_id = pid;
|
|
pst.su_proc_id = Bicc_Data.port_data[pid].su_proc_id;
|
|
pst.cic = cic;
|
|
pst.trace_flag = 0;
|
|
|
|
eh_ptr = (BICC_EventHandle_struct *)pal_get_handler(pst.cg_id);
|
|
if(eh_ptr == NULL)
|
|
return BICC_CM_FAILED;
|
|
|
|
switch(primitive)
|
|
{
|
|
case BICC_SETUP_IND:
|
|
if(eh_ptr->h_bicc_setup_ind != NULL)
|
|
{
|
|
ret = eh_ptr->h_bicc_setup_ind(&pst, prm_ptr);
|
|
if(pst.trace_flag == 1)
|
|
{
|
|
//BiccResource.port_pond[pid].trace_flag = 1;
|
|
Bicc_Data.port_data[pid].trace_flag = 1;
|
|
monitor_bicc_msg(r_mtp_msg.msgList, r_mtp_msg.len, 0, cic, pid);
|
|
}
|
|
}
|
|
else
|
|
bicc_log_err("Setup indicate handle is not registered.\n");
|
|
if(ret != -1)
|
|
Bicc_Data.port_data[pid].su_proc_id = pst.su_proc_id;
|
|
break;
|
|
|
|
case BICC_SETUP_CNF:
|
|
if(eventType == EN_CON)
|
|
{
|
|
if(eh_ptr->h_bicc_setup_con_cnf != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_setup_con_cnf(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Setup confirm handle is not registered.\n");
|
|
break;
|
|
|
|
}
|
|
else
|
|
{
|
|
if(eh_ptr->h_bicc_setup_anm_cnf != NULL)
|
|
eh_ptr->h_bicc_setup_anm_cnf(&pst, prm_ptr);
|
|
else
|
|
bicc_log_err("Setup confirm handle is not registered.\n");
|
|
}
|
|
|
|
break;
|
|
|
|
case BICC_ALERT_IND:
|
|
if(eh_ptr->h_bicc_alert_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_alert_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Alert indication handle is not registered.\n");
|
|
break;
|
|
|
|
case BICC_RELEASE_IND:
|
|
if(eh_ptr->h_bicc_release_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_release_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Release indication is not registered.\n");
|
|
break;
|
|
|
|
case BICC_APM_IND:
|
|
if(eh_ptr->h_bicc_apm_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_apm_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("APM indication is not registered.\n");
|
|
break;
|
|
|
|
case BICC_RELEASE_CNF:
|
|
if(eh_ptr->h_bicc_release_cnf != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_release_cnf(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Release confirm is not registered.\n");
|
|
break;
|
|
|
|
case BICC_INFO_IND:
|
|
if(eh_ptr->h_bicc_info_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_info_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("info indication is not registered.\n");
|
|
break;
|
|
|
|
case BICC_SUSPEND_IND:
|
|
if(eh_ptr->h_bicc_suspend_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_suspend_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Suspend indication is not registered.\n");
|
|
break;
|
|
|
|
case BICC_RESUME_IND:
|
|
if(eh_ptr->h_bicc_resume_ind != NULL)
|
|
{
|
|
if(!eh_ptr->h_bicc_resume_ind(&pst, prm_ptr))
|
|
return 0;
|
|
}
|
|
else
|
|
bicc_log_err("Resume indication is not registered.\n");
|
|
break;
|
|
|
|
case BICC_PROG_IND:
|
|
if(eh_ptr->h_bicc_prog_ind != NULL)
|
|
eh_ptr->h_bicc_prog_ind(&pst, prm_ptr);
|
|
else
|
|
bicc_log_err("Call progress indication handle is not registered.\n");
|
|
break;
|
|
case BICC_RESET_IND:
|
|
if(eh_ptr->h_bicc_reset_ind != NULL)
|
|
eh_ptr->h_bicc_reset_ind(&pst, prm_ptr);
|
|
|
|
else
|
|
bicc_log_err("Reset indicate handle is not registered.\n");
|
|
break;
|
|
case BICC_RESET_CNF:
|
|
if(eh_ptr->h_bicc_reset_cnf != NULL)
|
|
{
|
|
if(eventType == EN_GROUP)
|
|
eh_ptr->h_bicc_reset_cnf(&pst, prm_ptr);
|
|
else
|
|
eh_ptr->h_bicc_reset_cnf(&pst, NULL);
|
|
}
|
|
else
|
|
bicc_log_err("Reset cnf handle is not registered.\n");
|
|
break;
|
|
case BICC_FAILURE_IND:
|
|
if(eh_ptr->h_bicc_failure_ind != NULL)
|
|
eh_ptr->h_bicc_failure_ind(&pst, prm_ptr);
|
|
else
|
|
bicc_log_err("Failure indicate handle is not registered.\n");
|
|
break;
|
|
case BICC_REATTEMPT_IND:
|
|
if(eh_ptr->h_bicc_reattempt_ind != NULL)
|
|
eh_ptr->h_bicc_reattempt_ind(&pst, prm_ptr);
|
|
else
|
|
bicc_log_err("Reattempt indicate handle is not registered.\n");
|
|
break;
|
|
case BICC_BLOCK_IND:
|
|
if(eh_ptr->h_bicc_block_ind != NULL)
|
|
{
|
|
if(eventType == EN_GROUP)
|
|
eh_ptr->h_bicc_block_ind(&pst, prm_ptr);
|
|
else
|
|
eh_ptr->h_bicc_block_ind(&pst, NULL);
|
|
}
|
|
else
|
|
bicc_log_err("Block indicate handle is not registered.\n");
|
|
break;
|
|
|
|
case BICC_BLOCK_CNF:
|
|
if(eh_ptr->h_bicc_block_cnf != NULL)
|
|
{
|
|
if(eventType == EN_GROUP)
|
|
eh_ptr->h_bicc_block_cnf(&pst, prm_ptr);
|
|
else
|
|
eh_ptr->h_bicc_block_cnf(&pst, NULL);
|
|
}
|
|
else
|
|
bicc_log_err("Block confirm handle is not registered.\n");
|
|
break;
|
|
case BICC_UNBLOCK_IND:
|
|
if(eh_ptr->h_bicc_unblock_ind != NULL)
|
|
{
|
|
if(eventType == EN_GROUP)
|
|
eh_ptr->h_bicc_unblock_ind(&pst, prm_ptr);
|
|
else
|
|
eh_ptr->h_bicc_unblock_ind(&pst, NULL);
|
|
}
|
|
else
|
|
bicc_log_err("Unblock indicate handle is not registered.\n");
|
|
break;
|
|
case BICC_UNBLOCK_CNF:
|
|
if(eh_ptr->h_bicc_unblock_cnf != NULL)
|
|
{
|
|
if(eventType == EN_GROUP)
|
|
eh_ptr->h_bicc_unblock_cnf(&pst, prm_ptr);
|
|
else
|
|
eh_ptr->h_bicc_unblock_cnf(&pst, NULL);
|
|
}
|
|
else
|
|
bicc_log_err("Unblock confirm handle is not registered.\n");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
void bicc_dualseizure_func(u32 pid)
|
|
{
|
|
int cg_id;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
const pal_cg_struct *pcg = NULL;
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
pcircuit = pal_circuit_ptr(pid / BICC_CIRCUIT_CIC);
|
|
if(pcircuit == NULL)
|
|
return;
|
|
cg_id = pcircuit->cg_id;
|
|
pcg = pal_cg_ptr(cg_id);
|
|
if(pcg == NULL)
|
|
return;
|
|
if(pcg->attrib.priority == 0)
|
|
return;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, NULL, BICC_REATTEMPT_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
Bicc_Data.port_data[pid].cic_state.call_state = BICC_INCOMING;
|
|
port_ptr->sprc_cmd = M_IAM;
|
|
}
|
|
|
|
|
|
void bicc_cpci_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
|
|
switch(port_ptr->fsm_state.cpc_state)
|
|
{
|
|
case CPCI_IDLE:
|
|
if(port_ptr->sprc_cmd == M_IAM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if(readPrim_union[pid].setup_ind.callingPtyCat.val != 0x0d) //test call?
|
|
{
|
|
if(port_ptr->cic_state.blo_state & M_REMOTE_BLOCK)
|
|
port_ptr->cic_state.blo_state &= 0x01; //set remote unblocked
|
|
if(port_ptr->cic_state.blo_state & M_LOCAL_BLOCK)
|
|
{
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
|
|
}
|
|
if(bicc_event_handle(pid, &readPrim_union[pid], BICC_SETUP_IND, EN_NONE))
|
|
{
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_ACM;
|
|
|
|
}
|
|
else
|
|
{
|
|
bicc_circuit_reset(pid, "setup ind rejected");
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
writePrim_union[pid].rel_rsp.cause.pres = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
bicc_send_rlc(pid);
|
|
bicc_cpc_clear(pid);
|
|
return ;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return ;
|
|
}
|
|
else if(port_ptr->sprc_cmd !=0 )
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CPCI);
|
|
bicc_circuit_reset(pid, "unexpected message");
|
|
bicc_cpc_clear(pid);
|
|
return ;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CRR);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CGRR);
|
|
bicc_cpc_clear(pid);
|
|
return ;
|
|
}
|
|
|
|
break;
|
|
case CPCI_WAIT_CONTINUITY:
|
|
break;
|
|
case CPCI_WAIT_ACM:
|
|
if(port_ptr->primitive_cmd == BICC_ALERT_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_acm(pid);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_ANM;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_SETUP_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_con(pid);
|
|
port_ptr->fsm_state.cpc_state = CPCI_ANSWERED;
|
|
tempTimer->t9 = TIMER_PTR->t9;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr ->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
/* else if(port_ptr->sprc_cmd == M_SAM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_INFO_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_ACM;
|
|
}
|
|
*/
|
|
else if(port_ptr->sprc_cmd != 0)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CPCI);
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_circuit_reset(pid, "unexpected message cpci wait acm");
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_BLO|BICC_SI_MGBS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case CPCI_WAIT_ANM:
|
|
if(port_ptr->primitive_cmd == BICC_SETUP_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_anm(pid);
|
|
port_ptr->fsm_state.cpc_state = CPCI_ANSWERED;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_PROG_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_cpg(pid);
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
#ifdef BICC_TOLERANT
|
|
// To avoid both side backoff //
|
|
else if(port_ptr->sprc_cmd != 0)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_circuit_reset(pid, "unexpected message cpci wait anm");
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
#endif
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
// break;
|
|
else if(tempTimer->t9-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x13);
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
break;
|
|
|
|
case CPCI_ANSWERED:
|
|
if(port_ptr->primitive_cmd == BICC_SUSPEND_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_sus(pid);
|
|
port_ptr->cic_state.sus_state = BICC_TERM_SUSPEND;
|
|
port_ptr->fsm_state.cpc_state = CPCI_SUSPENDED;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_SUS)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SUSPEND_IND, EN_NONE);
|
|
port_ptr->cic_state.sus_state = BICC_ORIG_SUSPEND;
|
|
port_ptr->fsm_state.cpc_state = CPCI_SUSPENDED;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCI_SUSPENDED:
|
|
if(port_ptr->primitive_cmd == BICC_RESUME_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_res(pid);
|
|
if(port_ptr->cic_state.sus_state == BICC_TERM_SUSPEND)
|
|
port_ptr->fsm_state.cpc_state = CPCI_ANSWERED;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_SUSPEND_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_sus(pid);
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state= CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RES)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESUME_IND, EN_NONE);
|
|
if(port_ptr->cic_state.sus_state == BICC_ORIG_SUSPEND)
|
|
port_ptr->fsm_state.cpc_state = CPCI_ANSWERED;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_SUS)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SUSPEND_IND, EN_NONE);
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCI_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case CPCI_WAIT_RLC:
|
|
if(port_ptr->sprc_cmd== M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
writePrim_union[pid].rel_rsp.cause.pres = 0;
|
|
bicc_send_rlc(pid);
|
|
|
|
}
|
|
else if(tempTimer->t1-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_rel(pid);
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
|
|
}
|
|
else if(tempTimer->t5-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_circuit_reset(pid, "t5 expired cpci wait rlc");
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
//if(cpc_ptr->crr_cmd == BICC_RESET_IND)
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_RESET_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCI);
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid,&readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCI_WAIT_REL_COMP:
|
|
if(port_ptr->primitive_cmd == BICC_RELEASE_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rlc(pid);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_RESET_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCI);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
#ifdef BICC_TOLERANT
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
}
|
|
|
|
#endif
|
|
break;
|
|
case CPCI_WAIT_RESET:
|
|
if(port_ptr->primitive_cmd == BICC_RESET_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_RESET_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCI);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCI_WAIT_GROUP_RESET:
|
|
if(port_ptr->primitive_cmd == BICC_RESET_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
inline void bicc_cpco_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
|
|
switch(port_ptr->fsm_state.cpc_state)
|
|
{
|
|
case CPCO_IDLE:
|
|
if(port_ptr->primitive_cmd== BICC_SETUP_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_iam(pid);
|
|
tempTimer->t7 = TIMER_PTR->t7;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_ACM;
|
|
}
|
|
else
|
|
bicc_cpc_clear(pid);
|
|
break;
|
|
case CPCO_WAIT_CONTINUITY:
|
|
break;
|
|
case CPCO_WAIT_ACM:
|
|
if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_INFO_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_sam(pid);
|
|
tempTimer->t7 = TIMER_PTR->t7;
|
|
port_ptr->w_time = 0;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_ACM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
tempTimer->t9 = TIMER_PTR->t9;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_ALERT_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_ANM;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_CON)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SETUP_CNF, EN_CON);
|
|
port_ptr->fsm_state.cpc_state = CPCO_ANSWERED;
|
|
}
|
|
/* else if(port_ptr->sprc_cmd == M_ANM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SETUP_CNF, EN_ANM);
|
|
port_ptr->fsm_state.cpc_state = CPCO_ANSWERED;
|
|
}
|
|
*/
|
|
else if(port_ptr->sprc_cmd == M_CPG)
|
|
{
|
|
port_ptr->sprc_cmd = 0; //discard...
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
// fsm_ptr->timer_data.t7 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
#ifdef BICC_REATTEMPT
|
|
else if(port_ptr->sprc_cmd == M_IAM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_dualseizure_func(pid);
|
|
}
|
|
#endif
|
|
else if(port_ptr->sprc_cmd != 0)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_circuit_reset(pid, "unexpected message cpco wait acm");
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(tempTimer->t7-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x12); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_BLO|BICC_SI_MGBR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RESET;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t7 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCO_WAIT_ANM:
|
|
if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_ANM)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SETUP_CNF, EN_ANM);
|
|
port_ptr->fsm_state.cpc_state = CPCO_ANSWERED;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_CPG)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_PROG_IND, EN_NONE);
|
|
}
|
|
#ifdef BICC_TOLERANT
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
port_ptr->w_time = 0;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->w_time = 0;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
#endif
|
|
#ifdef BICC_TOLERANT
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RESET;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
}
|
|
#endif
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t9 = BICC_TIMER_STOP;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(tempTimer->t9-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10);
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
break;
|
|
case CPCO_ANSWERED:
|
|
if(port_ptr->primitive_cmd == BICC_SUSPEND_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_sus(pid);
|
|
port_ptr->cic_state.sus_state = BICC_ORIG_SUSPEND;
|
|
port_ptr->fsm_state.cpc_state = CPCO_SUSPENDED;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_SUS)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid,&readPrim_union[pid], BICC_SUSPEND_IND, EN_NONE);
|
|
port_ptr->cic_state.sus_state = BICC_TERM_SUSPEND;
|
|
port_ptr->fsm_state.cpc_state = CPCO_SUSPENDED;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RESET;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCO_SUSPENDED:
|
|
if(port_ptr->primitive_cmd== BICC_RESUME_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_res(pid);
|
|
if(port_ptr->cic_state.sus_state == BICC_ORIG_SUSPEND)
|
|
port_ptr->fsm_state.cpc_state = CPCO_ANSWERED;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_SUSPEND_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_sus(pid);
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_RELEASE_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RES)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESUME_IND, EN_NONE);
|
|
if(port_ptr->cic_state.sus_state == BICC_TERM_SUSPEND)
|
|
port_ptr->fsm_state.cpc_state = CPCO_ANSWERED;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_SUS)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_SUSPEND_IND, EN_NONE);
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_REL_COMP;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_FAILURE_IND, EN_NONE);
|
|
bicc_set_cause(&writePrim_union[pid].rel_req.cause, 0x10); //Normal call clearing
|
|
bicc_send_rel(pid);
|
|
tempTimer->t5 = TIMER_PTR->t5;
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RLC;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_RESET;
|
|
tempTimer->user_t10 = TIMER_PTR->user_t10;
|
|
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
port_ptr->fsm_state.cpc_state = CPCO_WAIT_GROUP_RESET;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCO_WAIT_RLC:
|
|
if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_REL)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
writePrim_union[pid].rel_rsp.cause.pres = 0;
|
|
// bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_IND, EN_NONE);
|
|
bicc_send_rlc(pid);
|
|
}
|
|
else if(tempTimer->t1-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_rel(pid);
|
|
tempTimer->t1 = TIMER_PTR->t1;
|
|
}
|
|
else if(tempTimer->t5-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
bicc_circuit_reset(pid, "t5 expired cpco wait rlc");
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_SETUP_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCO);
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd= 0;
|
|
tempTimer->t5 = BICC_TIMER_STOP;
|
|
tempTimer->t1 = BICC_TIMER_STOP;
|
|
//The Ind must sent to CC because this Req is not by CC but BICC locally
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_IND, EN_NONE);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCO_WAIT_REL_COMP:
|
|
if(port_ptr->primitive_cmd == BICC_RELEASE_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
tempTimer->user_t10 = 0;
|
|
|
|
bicc_send_rlc(pid);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_RESET_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCO);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(tempTimer->user_t10-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
tempTimer->user_t10 = BICC_TIMER_STOP;
|
|
bicc_circuit_reset(pid, "user t10 expired cpco wait release complete");
|
|
//bicc_event_handle(pid, &readPrim_union[pid], BICC_RELEASE_CNF, EN_NONE);
|
|
bicc_send_rlc(pid);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
|
|
break;
|
|
case CPCO_WAIT_RESET:
|
|
if(port_ptr->primitive_cmd == BICC_RESET_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
//port_ptr->fsm_state.cpc_state = BICC_RESET_RSP;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET_COMP|BICC_SI_CPCO);
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
else if(tempTimer->user_t10-- == BICC_TIMER_EXPIRED)
|
|
{
|
|
tempTimer->user_t10 = BICC_TIMER_STOP;
|
|
bicc_circuit_reset(pid, "user t10 expired cpco wait release complete");
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
case CPCO_WAIT_GROUP_RESET:
|
|
if(port_ptr->primitive_cmd == BICC_RESET_RSP)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_cpc_clear(pid);
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/********************************************************************/
|
|
/* Maintenance Oriented Circuit Group Blocking/Unbolcking Sending */
|
|
/********************************************************************/
|
|
inline void bicc_mgbs_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
|
|
u32 circuit_id;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
|
|
circuit_id = pid / BICC_CIRCUIT_CIC;
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return;
|
|
if(pcircuit->attrib.plat_id != local_platid )
|
|
if(Bicc_Data.dmp_data.active == 1)
|
|
{
|
|
if(port_ptr->fsm_state.mgbs_state != MGBS_IDLE)
|
|
{
|
|
port_ptr->fsm_state.mgbs_state = MGBS_IDLE;
|
|
tempTimer->t18 = 0;
|
|
tempTimer->t19 = 0;
|
|
}
|
|
return ;
|
|
}
|
|
switch(port_ptr->fsm_state.mgbs_state)
|
|
{
|
|
case MGBS_IDLE:
|
|
if(port_ptr->primitive_cmd == BICC_BLOCK_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_localblocking_func(pid, &writePrim_union[pid].cgb_req.rangeStatus);
|
|
bicc_send_cgb(pid);
|
|
tempTimer->t18 = TIMER_PTR->t18;
|
|
tempTimer->t19 = TIMER_PTR->t19;
|
|
port_ptr->fsm_state.mgbs_state = MGBS_WAIT_CGBA;
|
|
}
|
|
else if(port_ptr->primitive_cmd == BICC_UNBLOCK_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
bicc_send_cgu(pid);
|
|
tempTimer->t20 = TIMER_PTR->t20;
|
|
tempTimer->t21 = TIMER_PTR->t21;
|
|
port_ptr->fsm_state.mgbs_state = MGBS_WAIT_CGUA;
|
|
}
|
|
if(port_ptr->sprc_cmd == M_CGBA)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
//discard
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_CGUA)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
//discard
|
|
}
|
|
break;
|
|
case MGBS_WAIT_CGBA:
|
|
if(port_ptr->sprc_cmd == M_CGBA)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if(readPrim_union[pid].cgb_cnf.rangeStatus.range >= 32)
|
|
return;
|
|
tempTimer->t18 = BICC_TIMER_STOP;
|
|
tempTimer->t19 = BICC_TIMER_STOP;
|
|
port_ptr->fsm_state.mgbs_state = MGBS_IDLE;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_BLOCK_CNF, EN_GROUP);
|
|
}
|
|
|
|
if(tempTimer->t18 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_cgb(pid);
|
|
tempTimer->t18 = TIMER_PTR->t18;
|
|
}
|
|
if(tempTimer->t19 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_cgb(pid);
|
|
tempTimer->t19 = TIMER_PTR->t19; //ignore first T19 expired
|
|
}
|
|
if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t18 = BICC_TIMER_STOP;
|
|
tempTimer->t19 = BICC_TIMER_STOP;
|
|
port_ptr->fsm_state.mgbs_state = MGBS_IDLE;
|
|
|
|
}
|
|
break;
|
|
case MGBS_WAIT_CGUA:
|
|
if(port_ptr->sprc_cmd == M_CGUA)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if(readPrim_union[pid].cgu_cnf.rangeStatus.range >= 32)
|
|
return;
|
|
tempTimer->t20 = BICC_TIMER_STOP;
|
|
tempTimer->t21 = BICC_TIMER_STOP;
|
|
bicc_localunblocking_func(pid, &readPrim_union[pid].cgu_cnf.rangeStatus);
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_UNBLOCK_CNF, EN_GROUP);
|
|
port_ptr->fsm_state.mgbs_state = MGBS_IDLE;
|
|
}
|
|
|
|
if(tempTimer->t20 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_cgu(pid);
|
|
tempTimer->t20 = TIMER_PTR->t20;
|
|
}
|
|
if(tempTimer->t21 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_cgb(pid);
|
|
tempTimer->t21 = TIMER_PTR->t21; //ignore first T21 expired
|
|
}
|
|
if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRS))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
tempTimer->t20 = BICC_TIMER_STOP;
|
|
tempTimer->t21 = BICC_TIMER_STOP;
|
|
port_ptr->fsm_state.mgbs_state = MGBS_IDLE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* Maintenance Oriented Circuit Group Blocking/Unbolcking Reception */
|
|
/************************************************************************/
|
|
inline void bicc_mgbr_proc(u32 pid)
|
|
{
|
|
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
//BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
switch(port_ptr->fsm_state.mgbr_state)
|
|
{
|
|
case MGBR_IDLE:
|
|
if(port_ptr->sprc_cmd == M_CGB)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if(readPrim_union[pid].cgb_ind.rangeStatus.range >= 32)
|
|
return;
|
|
bicc_cpcoblocking_func(pid, &readPrim_union[pid].cgb_ind.rangeStatus);
|
|
port_ptr->fsm_state.mgbr_state = MGBR_WAIT_BLOCKING_RESP;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_BLOCK_IND, EN_GROUP);
|
|
}
|
|
else if(port_ptr->sprc_cmd == M_CGU)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if(readPrim_union[pid].cgu_ind.rangeStatus.range >= 32)
|
|
return;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_UNBLOCK_IND, EN_GROUP);
|
|
port_ptr->fsm_state.mgbr_state = MGBR_WAIT_UNBLOCKING_RESP;
|
|
}
|
|
break;
|
|
case MGBR_WAIT_BLOCKING_RESP:
|
|
if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
port_ptr->fsm_state.mgbr_state = MGBR_IDLE;
|
|
}
|
|
else
|
|
{
|
|
bicc_remoteblocking_func(pid, &readPrim_union[pid].cgb_ind.rangeStatus);
|
|
memcpy(&writePrim_union[pid].cgb_rsp, &readPrim_union[pid].cgb_ind, sizeof(BiccCgb_Ind));
|
|
bicc_send_cgba(pid);
|
|
port_ptr->fsm_state.mgbr_state = MGBR_IDLE;
|
|
}
|
|
break;
|
|
case MGBR_WAIT_UNBLOCKING_RESP:
|
|
if(port_ptr->internal_cmd == (BICC_CMD_RESET|BICC_SI_CGRR))
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
port_ptr->fsm_state.mgbr_state = MGBR_IDLE;
|
|
}
|
|
else
|
|
{
|
|
bicc_remoteunblocking_func(pid, &readPrim_union[pid].cgu_ind.rangeStatus);
|
|
memcpy(&writePrim_union[pid].cgu_rsp, &readPrim_union[pid].cgu_ind, sizeof(BiccCgu_Ind));
|
|
bicc_send_cgua(pid);
|
|
port_ptr->fsm_state.mgbr_state = MGBR_IDLE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/********************************************/
|
|
/* Circuit Reset Sending */
|
|
/********************************************/
|
|
BOOL check_crs_waiting(u32 pid)
|
|
{
|
|
if(Bicc_Data.port_data[pid].fsm_state.crs_state == CRS_WAIT_REL)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
inline void bicc_crs_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
|
|
u32 circuit_id;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
|
|
circuit_id = pid / BICC_CIRCUIT_CIC;
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return ;
|
|
if(pcircuit->attrib.plat_id != local_platid )
|
|
if(Bicc_Data.dmp_data.active == 1)
|
|
{
|
|
if(port_ptr->fsm_state.crs_state != CRS_IDLE)
|
|
{
|
|
port_ptr->fsm_state.crs_state = CRS_IDLE;
|
|
|
|
tempTimer->t16 = 0;
|
|
}
|
|
return ;
|
|
}
|
|
switch(port_ptr->fsm_state.crs_state)
|
|
{
|
|
case CRS_IDLE:
|
|
if(port_ptr->primitive_cmd == BICC_RESET_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
port_ptr->cic_state.blo_state &= 0x0e;
|
|
port_ptr->cic_state.blo_state &= 0x0d;
|
|
bicc_send_rsc(pid);
|
|
tempTimer->t16 = TIMER_PTR->t16;
|
|
|
|
port_ptr->fsm_state.crs_state = CRS_WAIT_REL;
|
|
}
|
|
break;
|
|
case CRS_WAIT_REL:
|
|
if(port_ptr->sprc_cmd == M_RLC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t16 = BICC_TIMER_STOP;
|
|
port_ptr->fsm_state.crs_state = CRS_IDLE;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_CNF, EN_NONE);
|
|
|
|
}
|
|
|
|
if(tempTimer->t16 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_rsc(pid);
|
|
tempTimer->t16 = TIMER_PTR->t16;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/********************************************/
|
|
/* Circuit Reset Reception */
|
|
/********************************************/
|
|
inline void bicc_crr_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
|
|
|
|
switch(port_ptr->fsm_state.crr_state)
|
|
{
|
|
case CRR_IDLE:
|
|
if(port_ptr->sprc_cmd == M_RSC)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
|
|
if(port_ptr->cic_state.call_state == BICC_CIC_IDLE)
|
|
port_ptr->cic_state.call_state = BICC_INCOMING;
|
|
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CRR);
|
|
|
|
if(port_ptr->cic_state.blo_state & M_LOCAL_BLOCK)
|
|
port_ptr->cic_state.blo_state &= 0x0e;
|
|
port_ptr->cic_state.blo_state &= 0x0d;
|
|
port_ptr->fsm_state.crr_state = CRR_WAIT_RESPONSE;
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CRR);
|
|
|
|
}
|
|
break;
|
|
case CRR_WAIT_RESPONSE:
|
|
//if((port_ptr->internal_cmd & 0x0F) == CMD_RESET_COMP)
|
|
// if(port_ptr->primitive_cmd == BICC_RESET_RSP)
|
|
{
|
|
port_ptr->internal_cmd = 0;
|
|
writePrim_union[pid].rel_rsp.cause.pres = 0;
|
|
bicc_send_rlc(pid);
|
|
port_ptr->fsm_state.crr_state = CRR_IDLE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
/* Circuit Group Reset Sending */
|
|
/************************************************/
|
|
inline void bicc_cgrs_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
BiccTimer_struct *tempTimer = &Bicc_Data.timer_data[pid];
|
|
u32 circuit_id;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
|
|
circuit_id = pid / BICC_CIRCUIT_CIC;
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return ;
|
|
if(pcircuit->attrib.plat_id != local_platid )
|
|
if(Bicc_Data.dmp_data.active == 1)
|
|
{
|
|
if(port_ptr->fsm_state.cgrs_state != CGRS_IDLE)
|
|
{
|
|
port_ptr->fsm_state.cgrs_state = CGRS_IDLE;
|
|
|
|
tempTimer->t22 = 0;
|
|
}
|
|
return ;
|
|
}
|
|
switch(port_ptr->fsm_state.cgrs_state)
|
|
{
|
|
case CGRS_IDLE:
|
|
if(port_ptr->primitive_cmd == BICC_GROUP_RESET_REQ)
|
|
{
|
|
port_ptr->primitive_cmd = 0;
|
|
if(port_ptr->fsm_state.mgbs_state != MGBS_IDLE)
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CGRS);
|
|
bicc_cgrs_func(pid, writePrim_union[pid].grs_req.rangeStatus.range);
|
|
bicc_send_grs(pid);
|
|
tempTimer->t22 = TIMER_PTR->t22;
|
|
port_ptr->fsm_state.cgrs_state = CGRS_WAIT_GRA;
|
|
}
|
|
break;
|
|
case CGRS_WAIT_GRA:
|
|
if(port_ptr->sprc_cmd == M_GRA)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
tempTimer->t22 = BICC_TIMER_STOP;
|
|
port_ptr->fsm_state.cgrs_state = CGRS_IDLE;
|
|
bicc_event_handle(pid, &readPrim_union[pid], BICC_RESET_CNF, EN_GROUP);
|
|
bicc_cgrsack_func(pid, &readPrim_union[pid].grs_cnf.rangeStatus);
|
|
}
|
|
|
|
if(tempTimer->t22 -- == BICC_TIMER_EXPIRED)
|
|
{
|
|
bicc_send_grs(pid);
|
|
tempTimer->t22 = TIMER_PTR->t22;
|
|
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/****************************************************/
|
|
/* Circuit Group Reset Reception */
|
|
/****************************************************/
|
|
inline void bicc_cgrr_proc(u32 pid)
|
|
{
|
|
BICC_Port_struct *port_ptr = &Bicc_Data.port_data[pid];
|
|
|
|
switch(port_ptr->fsm_state.cgrr_state)
|
|
{
|
|
case CGRR_IDLE:
|
|
if(port_ptr->sprc_cmd == M_GRS)
|
|
{
|
|
port_ptr->sprc_cmd = 0;
|
|
if((readPrim_union[pid].grs_ind.rangeStatus.range >= 32)|| (readPrim_union[pid].grs_ind.rangeStatus.range == 0))
|
|
return;
|
|
if(port_ptr->fsm_state.mgbr_state != MGBR_IDLE)
|
|
port_ptr->internal_cmd = (BICC_CMD_RESET|BICC_SI_CGRR);
|
|
bicc_cgrr_func(pid, readPrim_union[pid].grs_ind.rangeStatus.range, &msg_union[pid].gra.rangeStatus);
|
|
port_ptr->fsm_state.cgrr_state = CGRR_WAIT_GROUP_RESET_COMP;
|
|
}
|
|
break;
|
|
case CGRR_WAIT_GROUP_RESET_COMP:
|
|
memcpy(&writePrim_union[pid].grs_rsp.rangeStatus, &msg_union[pid].gra.rangeStatus, sizeof(RangeStatus_struct));
|
|
bicc_send_gra(pid);
|
|
port_ptr->internal_cmd = 0;
|
|
port_ptr->fsm_state.cgrr_state = CGRR_IDLE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
BOOL bicc_check_blocking(u32 circuit_id, RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
BOOL ret = 0;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return ret;
|
|
memset(rs_ptr, 0, sizeof(RangeStatus_struct));
|
|
rs_ptr->range = BICC_CIRCUIT_CIC- 1;
|
|
for(i = pcircuit->attrib.head_cic; i < (pcircuit->attrib.head_cic + pcircuit->attrib.cic_range); i++)
|
|
{
|
|
if((Bicc_Data.port_data[i].cic_state.blo_state == 0) && (pcircuit->enable== 1))
|
|
{
|
|
rs_ptr->status[i>>3]|= 0x01 << (i&0x07);
|
|
ret = 1;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
BOOL bicc_check_unblocking(u32 circuit_id, RangeStatus_struct *rs_ptr)
|
|
{
|
|
int i;
|
|
BOOL ret = 0;
|
|
const pal_circuit_struct *pcircuit = NULL;
|
|
|
|
pcircuit = pal_circuit_ptr(circuit_id);
|
|
if(pcircuit == NULL)
|
|
return ret;
|
|
memset(rs_ptr, 0, sizeof(RangeStatus_struct));
|
|
rs_ptr->range = BICC_CIRCUIT_CIC - 1;
|
|
for(i = pcircuit->attrib.head_cic; i < (pcircuit->attrib.head_cic + pcircuit->attrib.cic_range); i++)
|
|
{
|
|
if((pcircuit->enable== 1) && (Bicc_Data.port_data[i].cic_state.blo_state == 1))
|
|
{
|
|
rs_ptr->status[i>>3]|= 0x01 << (i&0x07);
|
|
ret = 1;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
BOOL bicc_trunk_reachable(u32 cg_id)
|
|
{
|
|
const pal_cg_struct *pcg;
|
|
pcg = pal_cg_ptr(cg_id);
|
|
if(pcg==NULL)
|
|
return 0;
|
|
if(check_outbound_route(pcg->attrib.network_id, (long)pcg->attrib.dpc, 0) >= 0)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|