//---------------------------------------------------------------------------
void nasmt_COMMON_QOS_receive(struct cx_entity *cx){
//---------------------------------------------------------------------------
u8 sapi;
struct pdcp_data_ind pdcph;
// Start debug information
#ifdef GRAAL_DEBUG_RECEIVE
printk("nasmt_COMMON_QOS_receive - begin \n");
#endif
if (!cx){
printk("nasmt_COMMON_QOS_receive - input parameter cx is NULL \n");
return;
}
// End debug information
// LG force the use of only 1 rt fifo
sapi = GRAAL_CO_OUTPUT_SAPI;
// LG for (sapi = GRAAL_CO_OUTPUT_SAPI; sapi <= GRAAL_BA_OUTPUT_SAPI; ++sapi)
{
bytes_read = rtf_get(gpriv->sap[sapi], &pdcph, NAS_PDCPH_SIZE);
while (bytes_read>0)
{
if (bytes_read != NAS_PDCPH_SIZE)
{
printk("nasmt_COMMON_QOS_receive: problem while reading PDCP header\n");
return;
}
nasmt_COMMON_receive(NAS_PDCPH_SIZE, pdcph.data_size, gpriv->sap[sapi]);
bytes_read = rtf_get(gpriv->sap[sapi], &pdcph, NAS_PDCPH_SIZE);
}
}
#ifdef GRAAL_DEBUG_RECEIVE
printk("nasmt_COMMON_QOS_receive - end \n");
#endif
}
//---------------------------------------------------------------------------
void nas_COMMON_QOS_receive()
{
//---------------------------------------------------------------------------
uint8_t sapi;
struct pdcp_data_ind_header_s pdcph;
unsigned char data_buffer[2048];
struct classifier_entity *rclass;
struct nas_priv *priv;
int bytes_read;
// Start debug information
#ifdef NAS_DEBUG_RECEIVE
printk("NAS_COMMON_QOS_RECEIVE - begin \n");
#endif
// End debug information
bytes_read = rtf_get(PDCP2PDCP_USE_RT_FIFO,&pdcph, NAS_PDCPH_SIZE);
while (bytes_read>0) {
if (bytes_read != NAS_PDCPH_SIZE) {
printk("NAS_COMMON_QOS_RECEIVE: problem while reading PDCP header\n");
return;
}
priv=netdev_priv(nasdev[pdcph.inst]);
rclass = nas_COMMON_search_class_for_rb(pdcph.rb_id,priv);
bytes_read+= rtf_get(PDCP2PDCP_USE_RT_FIFO,
data_buffer,
pdcph.data_size);
#ifdef NAS_DEBUG_RECEIVE
printk("NAS_COMMON_QOS_RECEIVE - Got header for RB %d, Inst %d \n",
pdcph.rb_id,
pdcph.inst);
#endif
if (rclass) {
#ifdef NAS_DEBUG_RECEIVE
printk("[NAS][COMMON] Found corresponding connection in classifier for RAB\n");
#endif //NAS_DEBUG_RECEIVE
nas_COMMON_receive(pdcph.data_size,
(void *)data_buffer,
pdcph.inst,
rclass,
pdcph.rb_id);
}
bytes_read = rtf_get(PDCP2PDCP_USE_RT_FIFO, &pdcph, NAS_PDCPH_SIZE);
}
#ifdef NAS_DEBUG_RECEIVE
printk("NAS_COMMON_QOS_RECEIVE - end \n");
#endif
}
static void ClockChrono_Read(long t)
{
char ch;
unsigned int run = 0;
while(1) {
cpu_used[hard_cpu_id()]++;
rt_sem_wait(&keybrd_sem);
rtf_get(Keyboard, &ch, 1);
ch = toupper(ch);
switch(ch) {
case 'T': case 'R': case 'H': case 'M': case 'S':
CommandClock_Put(ch);
break;
case 'C': case 'I': case 'E':
CommandChrono_Put(ch);
break;
case 'N':
hide = ~hide;
break;
case 'P':
pause = TRUE;
rt_fractionated_sleep(nano2count(FIVE_SECONDS));
pause = FALSE;
break;
case 'K': case 'D':
run += ch;
if (run == ('K' + 'D')) {
rt_send(&clock, run);
rt_send(&chrono, run);
}
break;
}
}
}
//-----------------------------------------------------------------------------
int
pdcp_fifo_read_input_sdus ()
{
//-----------------------------------------------------------------------------
int cont;
int bytes_read;
// if remaining bytes to read
if (pdcp_fifo_read_input_sdus_remaining_bytes () > 0) {
// all bytes that had to be read for a SDU were read
// if not overflow of list, try to get new sdus from rt fifo
cont = 1;
while (cont > 0) {
bytes_read = rtf_get (NAS2PDCP_FIFO,
&(((u8 *) & pdcp_input_header)[pdcp_input_index_header]),
sizeof (pdcp_data_req_header_t) - pdcp_input_index_header);
if (bytes_read > 0) {
#ifdef PDCP_DEBUG
msg("[PDCP_FIFOS] TTI %d Read %d Bytes of data (header %d) from Nas_mesh\n",
Mac_rlc_xface->frame,
bytes_read,
sizeof(pdcp_data_req_header_t));
#endif // PDCP_DEBUG
pdcp_input_index_header += bytes_read;
if (pdcp_input_index_header == sizeof (pdcp_data_req_header_t)) {
#ifdef PDCP_DEBUG
msg("[PDCP] TTI %d IP->RADIO READ HEADER sdu size %d\n",
Mac_rlc_xface->frame,
pdcp_input_header.data_size);
#endif //PDCP_DEBUG
pdcp_input_index_header = 0;
if(pdcp_input_header.data_size<0){
msg("[PDCP][FATAL ERROR] READ_FIFO: DATA_SIZE %d < 0\n",pdcp_input_header.data_size);
mac_xface->macphy_exit("");
return 0;
}
pdcp_input_sdu_remaining_size_to_read = pdcp_input_header.data_size;
pdcp_input_sdu_size_read = 0;
// we know the size of the sdu, so read the sdu;
cont = pdcp_fifo_read_input_sdus_remaining_bytes ();
} else {
cont = 0;
}
// error while reading rt fifo
} else {
cont = 0;
}
}
}
return 0;
}
//-----------------------------------------------------------------------------
int rrc_rg_read_NT_FIFO (u8 *buffer, int count){
//-----------------------------------------------------------------------------
int data_length;
int Message_Id;
int UE_Id;
struct nas_rg_nt_element *p;
int prim_length;
int prim_type;
if (count > 0) {
#ifdef DEBUG_RRC_STATE
msg ("[RRC_RG] Message Received from NAS - NT SAP: -%hx- \n", buffer[0]);
#endif
p = (struct nas_rg_nt_element *) buffer;
prim_length = (int) (p->length);
prim_type = (int) (p->type);
#ifdef DEBUG_RRC_STATE
msg ("[RRC_RG] Primitive Type %d,\t Primitive length %d \n", prim_type, prim_length);
#endif
//rrc_print_buffer ((char *)rcve_buffer, 100);
switch (prim_type) {
case PAGING_REQ:
data_length = (u16) p->nasRGNTPrimitive.paging_req.nasDataLength;
UE_Id = p->nasRGNTPrimitive.paging_req.UeId;
protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr = get_free_mem_block (data_length);
protocol_bs->rrc.Mobile_List[UE_Id].paging_message_lgth = data_length;
//get the associated data
#ifndef RRC_NETLINK
count += rtf_get (protocol_bs->rrc.rrc_rg_NT_fifo, (protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr)->data, data_length);
#else
count += rrc_rg_read_data_from_nlh ((char *)(protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr)->data, data_length, (int) (p->length));
#endif
// memcpy((protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr)->data, &(rcve_buffer[p->length]),data_length);
#ifdef DEBUG_RRC_STATE
//rrc_print_buffer ((char *)rcve_buffer, 100);
msg ("[RRC_RG] PAGING_REQ primitive length: %d\n", (int) (p->length));
msg ("[RRC_RG] UE Id: %d\n", p->nasRGNTPrimitive.paging_req.UeId);
msg ("[RRC_RG] Data length: %d\n", data_length);
msg ("[RRC_RG] Data %s\n", (protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr)->data);
rrc_print_buffer ((char *) (protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr)->data, data_length);
#endif
// Send paging to MS
rrc_rg_msg_pagingt2 (UE_Id, &Message_Id);
RRC_RG_O_O_SEND_DCCH_AM (UE_Id);
free_mem_block (protocol_bs->rrc.Mobile_List[UE_Id].paging_message_ptr);
break;
default:
msg ("[RRC_RG] Invalid message received on NT SAP\n");
rrc_print_buffer ((char *)buffer, count);
count = -1;
break;
}
}
return count;
}
//---------------------------------------------------------------------------
void nasmt_COMMON_QOS_receive(struct cx_entity *cx)
{
//---------------------------------------------------------------------------
uint8_t sapi;
//struct pdcp_data_ind pdcph;
struct pdcp_data_ind_header_t pdcph;
int bytes_read = 0;
// Start debug information
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_QOS_receive - begin \n");
#endif
if (!cx) {
printk("nasmt_COMMON_QOS_receive - input parameter cx is NULL \n");
return;
}
// End debug information
// LG force the use of only 1 rt fifo
sapi = NAS_DRB_OUTPUT_SAPI;
bytes_read = rtf_get(gpriv->sap[sapi], &pdcph, NAS_PDCPH_SIZE);
while (bytes_read>0) {
if (bytes_read != NAS_PDCPH_SIZE) {
printk("nasmt_COMMON_QOS_receive: problem while reading PDCP header\n");
return;
}
//void nasmt_COMMON_receive(uint16_t bytes_read, uint16_t payload_length, void *data_buffer, int rb_id, int sap);
// data_buffer is NULL because FIFO should be read directly in the skbuff (LITE has an intermediary buffer)
nasmt_COMMON_receive(NAS_PDCPH_SIZE, pdcph.data_size, NULL, pdcph->rb_id, gpriv->sap[sapi]);
// check if another frame is in the FIFO, otherwise return
bytes_read = rtf_get(gpriv->sap[sapi], &pdcph, NAS_PDCPH_SIZE);
}
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_QOS_receive - end \n");
#endif
}
//---------------------------------------------------------------------------
// Receive data from FIFO (QOS or DC)
void nasmt_COMMON_receive(u16 hlen, u16 dlen, int sap){
//---------------------------------------------------------------------------
struct sk_buff *skb;
struct ipversion *ipv;
#ifdef GRAAL_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: begin\n");
#endif
skb = dev_alloc_skb( dlen + 2 );
if(!skb)
{
printk("nasmt_COMMON_receive: low on memory\n");
++gpriv->stats.rx_dropped;
return;
}
skb_reserve(skb,2);
bytes_read += rtf_get(sap, skb_put(skb, dlen), dlen);
if (bytes_read != hlen+dlen)
{
printk("nasmt_COMMON_receive: problem while reading DC sap\n");
kfree(skb->data);
dev_kfree_skb(skb);
return;
}
skb->dev = gdev;
skb->mac.raw = skb->data;
skb->pkt_type = PACKET_HOST;
skb->ip_summed = CHECKSUM_UNNECESSARY;
ipv = (struct ipversion *)skb->data;
switch (ipv->version)
{
case 6:
#ifdef GRAAL_DEBUG_RECEIVE_BASIC
printk("nasmt_COMMON_receive: receive IPv6 message\n");
#endif
skb->nh.ipv6h = (struct ipv6hdr *)skb->data;
skb->protocol = htons(ETH_P_IPV6);
break;
case 4:
#ifdef GRAAL_DEBUG_RECEIVE_BASIC
printk("nasmt_COMMON_receive: receive IPv4 message\n");
#endif
skb->nh.iph = (struct iphdr *)skb->data;
skb->protocol = htons(ETH_P_IP);
break;
default:
printk("nasmt_COMMON_receive: receive unknown message\n");
}
++gpriv->stats.rx_packets;
gpriv->stats.rx_bytes += bytes_read;
netif_rx(skb);
#ifdef GRAAL_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: end\n");
#endif
}
/*
* returns a positive value if whole bytes that had to be read were read
* returns zero value if whole bytes that had to be read were not read at all
* returns a negative value if an error was encountered while reading the rt fifo
*/
int
pdcp_fifo_read_input_sdus_remaining_bytes ()
{
//-----------------------------------------------------------------------------
sdu_size_t bytes_read=0;
// if remaining bytes to read
if (pdcp_input_sdu_remaining_size_to_read > 0) {
// printk("[PDCP][INFO] read_input_sdus pdcp_input_sdu_remaining_size_to_read = %d \n", pdcp_input_sdu_remaining_size_to_read);
bytes_read = rtf_get (NAS2PDCP_FIFO,
&(pdcp_input_sdu_buffer[pdcp_input_sdu_size_read]),
pdcp_input_sdu_remaining_size_to_read);
//printk("[PDCP][INFO] read fifo returned %d \n", bytes_read);
if (bytes_read > 0) {
//msg("[PDCP_FIFOS] Read %d remaining Bytes of data from Nas_mesh\n",bytes_read);
pdcp_input_sdu_remaining_size_to_read = pdcp_input_sdu_remaining_size_to_read - bytes_read;
pdcp_input_sdu_size_read = pdcp_input_sdu_size_read + bytes_read;
if (pdcp_input_sdu_remaining_size_to_read != 0) {
return 0;
} else {
#ifdef PDCP_DEBUG
msg("[PDCP][INFO] TTI %d: IP->RADIO RECEIVED COMPLETE SDU size %d inst %d rb %d\n",
Mac_rlc_xface->frame,
pdcp_input_sdu_size_read,
pdcp_input_header.inst,
pdcp_input_header.rb_id);
#endif //PDCP_DEBUG
pdcp_input_sdu_size_read = 0;
#ifdef IDROMEL_NEMO
pdcp_read_header.inst = 0;
#endif
pdcp_data_req (pdcp_input_header.inst,
pdcp_input_header.rb_id,
pdcp_input_header.data_size,
pdcp_input_sdu_buffer);
// not necessary
//memset(pdcp_input_sdu_buffer, 0, MAX_IP_PACKET_SIZE);
return 1;
}
} else {
return bytes_read;
}
}
return 1;
}
//---------------------------------------------------------------------------
// Decode DATA_TRANSFER_IND message from RRC
void nasrg_ASCTL_DC_decode_data_transfer_ind(struct cx_entity *cx, struct nas_rg_dc_element *p){
//---------------------------------------------------------------------------
// u8 graal_data[10];
unsigned int graal_length;
char data_type;
// Start debug information
#ifdef GRAAL_DEBUG_DC
printk("nasrg_ASCTL_DC_decode_data_transfer - begin \n");
#endif
if (!cx || !p){
printk("nasrg_ASCTL_DC_decode_data_transfer - input parameter is NULL \n");
return;
}
// End debug information
// Get first character
graal_length = (p->nasRGDCPrimitive.data_transfer_ind.nasDataLength) -1;
bytes_read += rtf_get(cx->sap[GRAAL_DC_OUTPUT_SAPI], &data_type, 1);
//check if peer message
if (data_type =='A'){
// receive in a skbuff
nasrg_COMMON_receive((p->length) + 1, graal_length, cx->sap[GRAAL_DC_OUTPUT_SAPI]);
}else{
// empty remaining data
bytes_read += rtf_get(cx->sap[GRAAL_DC_OUTPUT_SAPI], (gpriv->rbuffer)+ (p->length), graal_length);
if (data_type=='Z'){
// open radio bearer
printk("nasrg_ASCTL_DC_decode_data_transfer: Opening Default Radio Bearer\n");
nasrg_ASCTL_start_default_rb(cx);
}else
printk("nasrg_ASCTL_DC_decode_data_transfer: Error during reception of the message - Dropped\n");
}
#ifdef GRAAL_DEBUG_DC
printk("nasrg_ASCTL_DC_decode_data_transfer: DATA_TRANSFER_IND reception\n");
printk(" Primitive length %u\n", p->length);
printk(" Local Connection reference %u\n",p->nasRGDCPrimitive.data_transfer_ind.localConnectionRef);
printk(" Data Length %u\n", p->nasRGDCPrimitive.data_transfer_ind.nasDataLength);
nasrg_TOOL_print_state(cx->state);
#endif
}
int handler(unsigned int fifo)
{
int r, w;
static char buffer[BUFSIZE];
if( (r = rtf_get(TO_KERN, buffer, BUFSIZE - 1 )) < 0 ) {
printk("Error: woken up by fifo %d, rtf_get returns %d\n", fifo, r);
return(r);
}
buffer[r] = 0;
if( (w = rtf_put(FROM_KERN , buffer, r )) != r ) {
printk("rtf_put(%d) != %d for: \"%s\"\n", w, r, buffer);
return(w);
}
return 0;
}
void fn_rrc (void){
/******************************************************************************/
msg_head_t *Header ;
#ifdef USER_MODE
char *Data;
#else
int bytes_read;
#endif
L2_ID Mac_id;
while(1){
#ifdef USER_MODE
Header = (msg_head_t *) recv_msg(&S_rrc) ;
if(Header==NULL) break;
Data_to_read=Header->size;
#else
if(Header_read_idx < Header_size){
bytes_read = rtf_get (RRM2RRC_FIFO,&Header_buf[Header_read_idx],Header_size-Header_read_idx);
if(bytes_read >0)
msg("RRC: GET FIFOS RETURNS %d bytes, header %d\n",bytes_read,Header_read_idx);
Header_read_idx+=bytes_read;
if(Header_read_idx == Header_size){
Header = (msg_head_t *) Header_buf;
Data_to_read=Header->size;
msg("RRC: Header read completed, data size %d\n",Data_to_read);
}
//msg("[fn_rrc]TTI %d: rcv_msg return Null\n",Rrc_xface->Frame_index);
else
break;
}
#endif
if (Data_to_read > 0 ){
#ifdef USER_MODE
Data = (char *) (Header +1) ;
#else
bytes_read = rtf_get (RRM2RRC_FIFO,&Data[Data_read_idx],Data_to_read);
if(bytes_read >0)
msg("RRC: GET FIFOS RETURNS %d bytes, Data_to_read %d\n",bytes_read,Data_to_read);
Data_to_read-=bytes_read;
Data_read_idx+=bytes_read;
if(Data_to_read > 0 ) break;
msg("RRC: DATA read completed, data size %d\n",Data_to_read);
Header_read_idx=0;
Data_read_idx=0;
Data_to_read=0;
#endif
}
msg("Got MSG of Type %d on Inst %d\n",Header->msg_type,Header->inst);
switch ( Header->msg_type )
{
case RRM_INIT_CH_REQ:{
rrm_init_ch_req_t *p = (rrm_init_ch_req_t *) Data;
msg( "[RRM]>[RRC][Inst %d]:RRM_INIT_CH_REQ\n",Header->inst);
rrc_init_ch_req(Header->inst,p);
break;
}
case RRCI_INIT_MR_REQ:{
rrci_init_mr_req_t *p = (rrci_init_mr_req_t *) Data;
msg( "[RRM]>[RRC][Inst %d]:RRCI_INIT_MR_REQ\n",Header->inst);
rrc_init_mr_req(Header->inst,p);
break;
}
case RRM_RB_ESTABLISH_REQ:{
send_msg((void *)&S_rrc,msg_rrc_rb_establish_resp(Header->inst,Header->Trans_id));
msg( "[RRM]>[RRC][Inst %d]:RRM_RB_ESTABLISH_REQ, size %d\n",Header->inst,sizeof(rrm_rb_establish_req_t));
rrc_config_req(Header->inst,(void*)Data,Header->msg_type,Header->Trans_id);
break ;
}
case RRM_RB_MODIFY_REQ:{
send_msg((void *)&S_rrc,msg_rrc_rb_modify_resp(Header->inst,Header->Trans_id));
msg( "[RRM]>[RRC][Inst %d]:RRM_RB_MODIFY_REQ\n",Header->inst);
rrc_config_req(Header->inst,Data,Header->msg_type,Header->Trans_id);
}
case RRM_RB_RELEASE_REQ:{
send_msg((void *)&S_rrc,msg_rrc_rb_release_resp(Header->inst,Header->Trans_id));
msg( "[RRM]>[RRC][Inst %d]:RRM_RB_RELEASE_REQ\n",Header->inst);
rrc_config_req(Header->inst,Data,Header->msg_type,Header->Trans_id);
}
case RRCI_CX_ESTABLISH_RESP:
{
rrci_cx_establish_resp_t *p = (rrci_cx_establish_resp_t *) Data;
unsigned char CH_index,i;
msg( "[RRCI]>[RRC][Inst %d]:RRCI_CX_ESTABLISH_RESP\n",Header->inst);
for(i=0;i<NB_SIG_CNX_UE;i++)
if(!bcmp(&UE_rrc_inst[Header->inst-NB_CH_INST].Info[i].CH_mac_id,&p->L2_id,sizeof(L2_ID))){
CH_index=i;
break;
}
if(i==NB_SIG_CNX_UE){
msg("[RRC] FATAL: CH_INDEX NOT FOUND\n");
return;
}
UE_rrc_inst[Header->inst-NB_CH_INST].Srb2[CH_index].Srb_info.IP_addr_type=p->L3_info_t;
if(p->L3_info_t == IPv4_ADDR)
memcpy(&UE_rrc_inst[Header->inst-NB_CH_INST].Srb2[CH_index].Srb_info.IP_addr,p->L3_info,4);
else
memcpy(&UE_rrc_inst[Header->inst-NB_CH_INST].Srb2[CH_index].Srb_info.IP_addr,p->L3_info,16);
}
break ;
case RRM_SENSING_MEAS_REQ:
{
// rrm_sensing_meas_req_t *p = (rrm_sensing_meas_req_t *) sock_msg ;
send_msg((void *)&S_rrc,msg_rrc_sensing_meas_resp(Header->inst,Header->Trans_id));
msg( "[RRM]>[RRC][Inst %d]:RRM_SENSING_MEAS_REQ\n",Header->inst);
// rrc_meas_req(header->inst,p,RRC_MEAS_ADD);
}
break ;
case RRM_SENSING_MEAS_RESP:
{
msg( "[RRM]>[RRC][Inst %d]:RRM_SENSING_MEAS_RESP\n",Header->inst);
//rrm_rrc_meas_resp(header->inst,header->Trans_id);
}
break ;
case RRM_SCAN_ORD:
msg( "[RRM]>[RRC][Inst %d]:RRM_SCAN_ORD\n",Header->inst);
//memcpy(&CH_rrc_inst[0].Rrm_init_scan_req,(rrm_init_scan_req_t *) Data,sizeof(rrm_init_scan_req_t));
//CH_rrc_inst[0].Last_scan_req=Rrc_xface->Frame_index;
///send over air
break;
case RRM_INIT_SCAN_REQ:
msg( "[RRM]>[RRC][Inst %d]:RRM_INIT_SCAN_REQ\n",Header->inst);
memcpy(&CH_rrc_inst[0].Rrm_init_scan_req,(rrm_init_scan_req_t *) Data,sizeof(rrm_init_scan_req_t));
CH_rrc_inst[0].Last_scan_req=Rrc_xface->Frame_index;
///send over air
break;
case RRM_END_SCAN_REQ:
msg( "[RRM]>[RRC][Inst %d]:RRM_END_SCAN_REQ\n",Header->inst);
memcpy(&Mac_id.L2_id[0],Data,sizeof(L2_ID));
unsigned char UE_index=Mac_id.L2_id[0]-NB_CH_MAX+1;
UE_rrc_inst[0].Srb2[UE_index].Srb_info.Tx_buffer.Payload[0]=100;
msg("SRB_ID %d\n",CH_rrc_inst[0].Srb2[UE_index].Srb_info.Srb_id);
Mac_rlc_xface->rrc_rlc_data_req(0,CH_rrc_inst[0].Srb2[UE_index].Srb_info.Srb_id,0,0,1,CH_rrc_inst[0].Srb2[UE_index].Srb_info.Tx_buffer.Payload);
//CH_rrc_inst[0].Last_scan_req=Rrc_xface->Frame_index;
///send over air
break;
default :
msg("[L3_xface]WARNING: msg unknown %d\n",Header->msg_type) ;
}
}
}
static void *intr_handler(void *args)
{
RT_TASK *mytask;
RTIME period;
int playfifo, cntrfifo;
char data;
#ifdef U_LAW
int go=1;
int divisor = DIVISOR;
#else
char temp;
#endif
rt_allow_nonroot_hrt();
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
#ifdef U_LAW
if (iopl(3)) {
printf("iopl() failed/n");
exit(1);
}
outb_p(0x92, 0x43); /* binary, mode1, LSB only, ch 2 */
/* You can make this bigger, but then you start to get
* clipping, which sounds bad. 29 is good */
/* VOLUME SETTING */
pcsp_calc_vol(70);
port61 = inb(0x61) | 0x3;
#else
ioperm(PORT_ADR, 1, 1);
#endif
if (!(mytask = rt_task_init_schmod(nam2num("SOUND"), 1, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT SOUND TASK\n");
exit(1);
}
playfifo = 0;
cntrfifo = 1;
rtf_create(playfifo, 8192); /* 1s buffer */
rtf_reset(playfifo);
rtf_create(cntrfifo, 1000);
rtf_reset(cntrfifo);
rt_set_oneshot_mode();
start_rt_timer(0);
period = nano2count(PERIOD);
printf("\nINIT SOUND TASK\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
#ifdef HARDREALTIME
rt_make_hard_real_time();
#endif
rt_task_make_periodic(mytask, rt_get_time() + 5*period, period);
rtf_put(cntrfifo, &data, 1);
rt_sleep(nano2count(100000000));
while(1) {
#ifdef U_LAW
if (!(--divisor)) {
divisor = DIVISOR;
//cpu_used[hard_cpu_id()]++;
if (!(rtf_get(playfifo, &data, 1) > 0)) {
go=0;
}else{
go=1;
}
}
if(go){
outb(port61,0x61);
outb(port61^1,0x61);
outb(vl_tab[((unsigned int)data)&0xff], 0x42);
}
#else
if (rtf_get(playfifo, &data, 1) > 0) {
go=1;
data = filter(data);
temp = inb(PORT_ADR);
temp &= 0xfd;
temp |= (data & 1) << 1;
outb(temp, PORT_ADR);
} else {
go=0;
}
#endif
rt_task_wait_period();
if (go==0) {
if (rtf_get(cntrfifo, &data, 1) > 0) {
break;
}
}
}
stop_rt_timer();
rt_make_soft_real_time();
rtf_destroy(playfifo);
rtf_destroy(cntrfifo);
rt_task_delete(mytask);
printf("\nEND SOUND TASK\n");
return 0;
}
//---------------------------------------------------------------------------
// Check if anything in DC FIFO and process it (RG Finite State Machine)
int nasrg_ASCTL_DC_receive(struct cx_entity *cx){
//---------------------------------------------------------------------------
// Start debug information
#ifdef GRAAL_DEBUG_DC_DETAIL
printk("nasrg_ASCTL_DC_receive - begin \n");
#endif
if (!cx){
printk("nasrg_ASCTL_DC_receive - input parameter cx is NULL \n");
return 0;
}
// End debug information
bytes_read = rtf_get(cx->sap[GRAAL_DC_OUTPUT_SAPI], gpriv->rbuffer, NAS_TL_SIZE);
if (bytes_read>0){
struct nas_rg_dc_element *p;
p= (struct nas_rg_dc_element *)(gpriv->rbuffer);
//get the rest of the primitive
bytes_read += rtf_get(cx->sap[GRAAL_DC_OUTPUT_SAPI], (u8 *)p+NAS_TL_SIZE, p->length-NAS_TL_SIZE);
if (bytes_read!=p->length){
printk("nasrg_ASCTL_DC_receive: Problem while reading primitive's header\n");
return bytes_read;
}
switch (p->type){
case CONN_ESTABLISH_IND :
if (p->nasRGDCPrimitive.conn_establish_ind.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: CONN_ESTABLISH_IND reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.conn_establish_ind.localConnectionRef);
else {
switch(cx->state){
case GRAAL_IDLE:
nasrg_ASCTL_DC_decode_cx_establish_ind(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: CONN_ESTABLISH_IND reception, invalid state %u\n", cx->state);
}
}
break;
case CONN_RELEASE_IND :
if (p->nasRGDCPrimitive.conn_release_ind.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: CONN_RELEASE_IND reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.conn_release_ind.localConnectionRef);
else{
switch(cx->state){
case GRAAL_CX_DCH:
nasrg_ASCTL_DC_decode_cx_release_ind(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: CONN_RELEASE_IND reception, invalid state %u\n", cx->state);
}
}
break;
case CONN_LOSS_IND:
if (p->nasRGDCPrimitive.conn_loss_ind.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: CONN_LOSS_IND reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.conn_loss_ind.localConnectionRef);
else{
switch(cx->state){
case GRAAL_CX_DCH:
nasrg_ASCTL_DC_decode_cx_loss_ind(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: CONN_LOSS_IND reception, invalid state %u\n", cx->state);
}
}
break;
case RB_ESTABLISH_CNF:
if (p->nasRGDCPrimitive.rb_establish_conf.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: RB_ESTABLISH_CNF reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.rb_establish_conf.localConnectionRef);
else{
switch(cx->state){
case GRAAL_CX_DCH:
nasrg_ASCTL_DC_decode_rb_establish_cnf(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: RB_ESTABLISH_CNF reception, invalid state %u\n", cx->state);
}
}
break;
case DATA_TRANSFER_IND:
if (p->nasRGDCPrimitive.data_transfer_ind.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: DATA_TRANSFER_IND reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.rb_establish_conf.localConnectionRef);
else{
switch(cx->state){
case GRAAL_CX_DCH:
nasrg_ASCTL_DC_decode_data_transfer_ind(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: DATA_TRANSFER_IND reception, invalid state %u\n", cx->state);
}
}
break;
// Temp - Should be in uplink GC-SAP
case MBMS_BEARER_ESTABLISH_CNF:
// if (p->nasRGDCPrimitive.mbms_ue_notify_cnf.localConnectionRef!=cx->lcr)
// printk("nasrg_ASCTL_DC_receive: MBMS_BEARER_ESTABLISH_CNF reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.rb_establish_conf.localConnectionRef);
// else
nasrg_ASCTL_DC_decode_mbms_bearer_establish_cnf(p);
break;
case MBMS_UE_NOTIFY_CNF:
if (p->nasRGDCPrimitive.mbms_ue_notify_cnf.localConnectionRef!=cx->lcr)
printk("nasrg_ASCTL_DC_receive: MBMS_UE_NOTIFY_CNF reception, Local connection reference not correct %u\n", p->nasRGDCPrimitive.rb_establish_conf.localConnectionRef);
else{
switch(cx->state){
case GRAAL_CX_DCH:
nasrg_ASCTL_DC_decode_mbms_ue_notify_cnf(cx,p);
break;
default:
printk("nasrg_ASCTL_DC_receive: MBMS_UE_NOTIFY_CNF reception, invalid state %u\n", cx->state);
}
}
break;
default :
printk("nasrg_ASCTL_DC_receive: Invalid message received\n");
}
}
return bytes_read;
}
//-----------------------------------------------------------------------------
int rrc_rg_read_GC_FIFO (u8 *buffer, int count){
//-----------------------------------------------------------------------------
int data_length, category, new_period;
int remaining_data = 0;
//u8 rcve_buffer[maxlen];
struct nas_rg_gc_element *p;
int prim_length;
int prim_type;
if (count > 0) {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_RG] Message Received from NAS - GC SAP: -%hx- \n", buffer[0]);
#endif
#ifdef DEBUG_RRC_BROADCAST_DETAILS
rrc_print_buffer ((char *)buffer, count);
#endif
p = (struct nas_rg_gc_element *) buffer;
prim_length = (int) (p->length);
prim_type = (int) (p->type);
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_RG] Primitive Type %d,\t Primitive length %d \n", prim_type, prim_length);
#endif
//get the rest of the primitive
//count += rtf_get (protocol_bs->rrc.rrc_rg_GC_fifo, &(rcve_buffer[NAS_TL_SIZE]), prim_length - NAS_TL_SIZE);
switch (prim_type) {
case INFO_BROADCAST_REQ:
data_length = (u16) p->nasRGGCPrimitive.broadcast_req.nasDataLength;
category = p->nasRGGCPrimitive.broadcast_req.category;
new_period = p->nasRGGCPrimitive.broadcast_req.period;
switch (category) {
case NAS_SIB1:
// size is limited - truncate if too large
if (data_length > maxSIB1NAS) {
remaining_data = data_length - maxSIB1NAS;
data_length = maxSIB1NAS;
}
protocol_bs->rrc.rg_bch_blocks.currSIB1.subnet_NAS_SysInfo.numocts = data_length;
//get the associated data
#ifndef RRC_NETLINK
count += rtf_get (protocol_bs->rrc.rrc_rg_GC_fifo, protocol_bs->rrc.rg_bch_blocks.currSIB1.subnet_NAS_SysInfo.data, data_length);
#else
count += rrc_rg_read_data_from_nlh ((char *)(protocol_bs->rrc.rg_bch_blocks.currSIB1.subnet_NAS_SysInfo.data), data_length, (int) (p->length));
#endif
if (new_period == 0)
new_period = 100; //Temp, block one-time shot
#ifndef USER_MODE
rrc_update_SIB1_period (new_period);
#endif
rrc_init_sib1 ();
break;
case NAS_SIB18:
// size is limited - truncate if too large
if (data_length > maxSIBNAS) {
remaining_data = data_length - maxSIBNAS;
data_length = maxSIBNAS;
}
protocol_bs->rrc.rg_bch_blocks.currSIB18.cellIdentities.numocts = data_length;
//get the associated data
#ifndef RRC_NETLINK
count += rtf_get (protocol_bs->rrc.rrc_rg_GC_fifo, protocol_bs->rrc.rg_bch_blocks.currSIB18.cellIdentities.data, data_length);
#else
count += rrc_rg_read_data_from_nlh ((char *)(protocol_bs->rrc.rg_bch_blocks.currSIB18.cellIdentities.data), data_length, (int) (p->length));
#endif
if (new_period == 0)
new_period = 500; //Temp, block one-time shot
rrc_process_sib18 ();
#ifndef USER_MODE
rrc_update_SIB18_period (new_period);
#endif
rrc_init_sib18 ();
break;
default:
msg ("[RRC_RG] Invalid categogy received from NAS in Broadcast_req: %d \n", category);
}
#ifdef DEBUG_RRC_BROADCAST_DETAILS
msg ("[RRC_RG] INFO_BROADCAST_REQ primitive length: %d\n", (int) (p->length));
// rrc_print_buffer(rcve_buffer,100);
msg ("[RRC_RG] Period: %d\t", new_period);
msg (" Category: %d\t", category);
msg (" Data length: %d\n", data_length);
switch (category) {
case NAS_SIB1:
msg ("[RRC_RG] Data SIB1 : %s\n", (char *) protocol_bs->rrc.rg_bch_blocks.currSIB1.subnet_NAS_SysInfo.data);
rrc_print_buffer ((char *) protocol_bs->rrc.rg_bch_blocks.currSIB1.subnet_NAS_SysInfo.data, data_length);
break;
case NAS_SIB18:
msg ("[RRC_RG] Data SIB18 : %s\n", (char *) protocol_bs->rrc.rg_bch_blocks.currSIB18.cellIdentities.data);
rrc_print_buffer ((char *) protocol_bs->rrc.rg_bch_blocks.currSIB18.cellIdentities.data, data_length);
break;
default:
msg ("[RRC_RG] Unknown category for data in INFO_BROADCAST_REQ primitive %d\n", category);
break;
}
#endif
//read remaining data if any
#ifndef RRC_NETLINK
if (remaining_data > 0 && remaining_data < NAS_MAX_LENGTH) {
rtf_get (protocol_bs->rrc.rrc_rg_GC_fifo, &(buffer[0]), remaining_data);
}
#endif
break;
//
#ifdef ALLOW_MBMS_PROTOCOL
case MBMS_BEARER_ESTABLISH_REQ:
// Temp : Only one service and one bearer at a time
#ifdef DEBUG_RRC_STATE
rrc_print_buffer((char *)buffer,100);
msg("[RRC_RG][MBMS] MBMS_BEARER_ESTABLISH_REQ primitive length: %d\n",(int)(p->length));
msg("[RRC_RG][MBMS] Service Id: %d\n", p->nasRGGCPrimitive.mbms_establish_req.mbms_serviceId);
msg("[RRC_RG][MBMS] Session Id: %d \n",p->nasRGGCPrimitive.mbms_establish_req.mbms_sessionId);
msg("[RRC_RG][MBMS] RB Id: %d \n",p->nasRGGCPrimitive.mbms_establish_req.mbms_rbId);
msg("[RRC_RG][MBMS] QoS Class: %d\n",p->nasRGGCPrimitive.mbms_establish_req.mbms_QoSclass);
msg("[RRC_RG][MBMS] Sap Id: %d\n",p->nasRGGCPrimitive.mbms_establish_req.mbms_sapId);
msg("[RRC_RG][MBMS] Duration: %d\n",p->nasRGGCPrimitive.mbms_establish_req.mbms_duration);
#endif
if (p_rg_mbms->mbms_num_active_service == 0){
//Copy all received information into the control block.
p_rg_mbms->nas_serviceId = p->nasRGGCPrimitive.mbms_establish_req.mbms_serviceId;
p_rg_mbms->nas_sessionId = p->nasRGGCPrimitive.mbms_establish_req.mbms_sessionId;
p_rg_mbms->nas_rbId = p->nasRGGCPrimitive.mbms_establish_req.mbms_rbId;
p_rg_mbms->nas_QoSclass = p->nasRGGCPrimitive.mbms_establish_req.mbms_QoSclass;
p_rg_mbms->nas_sapId = p->nasRGGCPrimitive.mbms_establish_req.mbms_sapId;
p_rg_mbms->nas_duration = p->nasRGGCPrimitive.mbms_establish_req.mbms_duration;
// rrc_rg_mbms_NAS_ServStart_rx((MBMS_ServiceIdentity*) &p->nasRGGCPrimitive.mbms_establish_req.mbms_serviceId);
rrc_rg_mbms_NAS_ServStart_rx();
}else{
// No specific action is planned - Only log an error message
msg("\n[RRC_RG][MBMS] ERROR - Service Id: %d cannot be activated. Already one Service active.\n\n", p->nasRGGCPrimitive.mbms_establish_req.mbms_serviceId);
p_rg_mbms->nas_status = FAILURE;
RRC_RG_O_O_NAS_MBMS_RB_ESTAB_CNF ();
}
break;
case MBMS_BEARER_RELEASE_REQ:
//Copy all other information into the control block.
p_rg_mbms->nas_serviceId = p->nasRGGCPrimitive.mbms_release_req.mbms_serviceId;
p_rg_mbms->nas_sessionId = p->nasRGGCPrimitive.mbms_release_req.mbms_sessionId;
p_rg_mbms->nas_rbId = p->nasRGGCPrimitive.mbms_release_req.mbms_rbId;
#ifdef DEBUG_RRC_STATE
rrc_print_buffer((char *)buffer,100);
msg("[RRC_RG][MBMS] MBMS_BEARER_RELEASE_REQ primitive length: %d\n",(int)(p->length));
msg("[RRC_RG][MBMS] Service Id: %d\n", p->nasRGGCPrimitive.mbms_release_req.mbms_serviceId);
msg("[RRC_RG][MBMS] Session Id: %d \n",p->nasRGGCPrimitive.mbms_release_req.mbms_sessionId);
msg("[RRC_RG][MBMS] RB Id: %d \n",p->nasRGGCPrimitive.mbms_release_req.mbms_rbId);
#endif
// rrc_rg_mbms_NAS_ServStop_rx((MBMS_ServiceIdentity*) &p->nasRGGCPrimitive.mbms_release_req.mbms_serviceId);
rrc_rg_mbms_NAS_ServStop_rx();
break;
#endif
// end MBMS
default:
// TODO : remove all remaining data
msg ("[RRC_RG] Invalid message received on GC SAP\n");
//rrc_print_buffer(rcve_buffer,count);
count = -1;
break;
}
}
return count;
}
int RTFRead(int descr, void *buf, unsigned bytes)
{
return rtf_get(descr, (char *)buf, bytes);
}
//---------------------------------------------------------------------------
// Receive data from FIFO (QOS or DC)
//void nasmt_COMMON_receive(uint16_t hlen, uint16_t dlen, int sap){
//void nasmt_COMMON_receive(uint16_t hlen, uint16_t dlen, void *pdcp_sdu, int sap){
void nasmt_COMMON_receive(uint16_t bytes_read, uint16_t payload_length, void *data_buffer, int rb_id, int sap)
{
//---------------------------------------------------------------------------
struct sk_buff *skb;
struct ipversion *ipv;
unsigned int hard_header_len;
uint16_t *p_ether_type;
uint16_t ether_type;
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: begin\n");
#endif
#ifdef PDCP_USE_NETLINK
// data_buffer is NULL if FIFOs
if (!data_buffer) {
printk("nasmt_COMMON_receive - input parameter data_buffer is NULL \n");
return;
}
#endif
skb = dev_alloc_skb( payload_length + 2 );
if(!skb) {
printk("nasmt_COMMON_receive: low on memory\n");
++gpriv->stats.rx_dropped;
return;
}
skb_reserve(skb,2);
#ifndef PDCP_USE_NETLINK
bytes_read += rtf_get(sap, skb_put(skb, payload_length), payload_length);
if (bytes_read != NAS_PDCPH_SIZE + payload_length) {
printk("nasmt_COMMON_receive: problem while reading DC sap\n");
kfree(skb->data);
dev_kfree_skb(skb);
return;
}
#else
memcpy(skb_put(skb, payload_length), data_buffer, payload_length);
bytes_read += payload_length;
#endif
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: received packet from PDCP, length %d\n", bytes_read);
#endif
skb->dev = gdev;
hard_header_len = gdev->hard_header_len;
skb->mac_header = skb->data;
skb->pkt_type = PACKET_HOST;
skb->ip_summed = CHECKSUM_UNNECESSARY;
ipv = (struct ipversion *)&(skb->data[hard_header_len]);
switch (ipv->version) {
case 6:
#ifdef NAS_DEBUG_RECEIVE_BASIC
printk("nasmt_COMMON_receive: receive IPv6 message\n");
#endif
skb->network_header = &skb->data[hard_header_len];
// set protocol default value
skb->protocol = htons(ETH_P_IPV6);
// If type Ethernet, correct it
#ifdef NAS_DRIVER_TYPE_ETHERNET
skb->protocol = eth_type_trans(skb, gdev);
#endif
break;
case 4:
#ifdef NAS_DEBUG_RECEIVE_BASIC
printk("nasmt_COMMON_receive: receive IPv4 message\n");
#endif
#ifdef NAS_DEBUG_RECEIVE
addr = (unsigned char *)&((struct iphdr *)&skb->data[hard_header_len])->saddr;
if (addr) {
printk("nasmt_COMMON_receive: Source %d.%d.%d.%d\n",addr[0],addr[1],addr[2],addr[3]);
}
addr = (unsigned char *)&((struct iphdr *)&skb->data[hard_header_len])->daddr;
if (addr) {
printk("[NAS][COMMON][RECEIVE] Dest %d.%d.%d.%d\n",addr[0],addr[1],addr[2],addr[3]);
}
printk("[NAS][COMMON][RECEIVE] protocol %d\n",((struct iphdr *)&skb->data[hard_header_len])->protocol);
#endif
skb->network_header = &skb->data[hard_header_len];
// set protocol default value
skb->protocol = htons(ETH_P_IP);
// If type Ethernet, correct it
#ifdef NAS_DRIVER_TYPE_ETHERNET
skb->protocol = eth_type_trans(skb, gdev);
#endif
break;
default:
printk("nasmt_COMMON_receive: Packet is not IPv4 or IPv6 (version=%d)\n", ipv->version);
#ifdef NAS_DRIVER_TYPE_ETHERNET
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: ether_type=%04X\n", ether_type);
#endif
skb->protocol = eth_type_trans(skb, gdev);
// minus 1(short) instead of 2(bytes) because uint16_t*
p_ether_type = (uint16_t *)&(skb->mac_header[hard_header_len-2]);
ether_type = ntohs(*p_ether_type);
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: ether_type=%04X\n", ether_type);
#endif
switch (ether_type) {
case ETH_P_ARP:
printk("[NAS][COMMON] ether_type = ETH_P_ARP\n");
skb->protocol = htons(ETH_P_ARP);
skb->network_header = &skb->mac_header[hard_header_len];
break;
default:
break;
}
#endif
}
++gpriv->stats.rx_packets;
gpriv->stats.rx_bytes += bytes_read;
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: forwarding packet of size %d to kernel\n",skb->len);
#endif
netif_rx(skb);
#ifdef NAS_DEBUG_RECEIVE
printk("nasmt_COMMON_receive: end\n");
#endif
}
//-----------------------------------------------------------------------------
// Read data in DC FIFO
int rrc_rg_read_DCin_FIFO (int UE_Id, u8 *buffer, int count){
//-----------------------------------------------------------------------------
//int maxlen = NAS_MAX_LENGTH;
int Message_Id;
int data_length;
//u8 rcve_buffer[maxlen];
struct nas_rg_dc_element *p;
int prim_length;
int prim_type;
#ifdef ALLOW_MBMS_PROTOCOL
int i;
#endif
if (count > 0) {
#ifdef DEBUG_RRC_STATE
msg ("[RRC_RG] Message Received from NAS: -%hx- for UE %d\n", buffer[0], UE_Id);
#endif
p = (struct nas_rg_dc_element *) buffer;
prim_length = (int) (p->length);
prim_type = (int) (p->type);
#ifdef DEBUG_RRC_STATE
msg ("[RRC_RG] Primitive Type %d,\t Primitive length %d \n", prim_type, prim_length);
#endif
//get the rest of the primitive
//count += rtf_get (protocol_bs->rrc.rrc_rg_DCIn_fifo[UE_Id], &(rcve_buffer[NAS_TL_SIZE]), prim_length - NAS_TL_SIZE);
//switch (rcve_buffer[0]) {
switch (prim_type) {
case CONN_ESTABLISH_CNF:
if (protocol_bs->rrc.Mobile_List[UE_Id].local_connection_ref == (int) (p->nasRGDCPrimitive.conn_establish_conf.localConnectionRef)) {
protocol_bs->rrc.establishment_cause = p->nasRGDCPrimitive.conn_establish_conf.status;
//Temp FFS
//protocol_bs->rrc.Mobile_List[UE_Id].rb_id = (int)(p->nasRGDCPrimitive.conn_establish_conf.num_RBs);
#ifdef DEBUG_RRC_STATE
msg ("[RRC_RG] primitive length: %d\t", (int) (p->length));
msg ("Local Connection reference: %d\t", p->nasRGDCPrimitive.conn_establish_conf.localConnectionRef);
msg ("Establishment status: %d\n", (int) (protocol_bs->rrc.establishment_cause));
#endif
rrc_rg_fsm_control (UE_Id, NAS_CONN_CNF);
}
break;
case DATA_TRANSFER_REQ:
if (protocol_bs->rrc.Mobile_List[UE_Id].local_connection_ref == (int) (p->nasRGDCPrimitive.data_transfer_req.localConnectionRef)) {
data_length = (u16) p->nasRGDCPrimitive.data_transfer_req.nasDataLength;
protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr = get_free_mem_block (data_length);
protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_lgth = data_length;
//get the associated data
#ifndef RRC_NETLINK
count += rtf_get (protocol_bs->rrc.rrc_rg_DCIn_fifo[UE_Id], (protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr)->data, data_length);
// memcpy((protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr)->data,&(rcve_buffer[p->length]),data_length);
#else
count += rrc_rg_read_data_from_nlh ((char *)(protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr)->data, data_length, (int) (p->length));
#endif
#ifdef DEBUG_RRC_STATE
rrc_print_buffer ((char *)buffer, count);
msg ("[RRC_RG] DATA_TRANSFER_REQ primitive length: %d\n", (int) (p->length));
msg ("[RRC_RG] Local Connection reference: %d\n", p->nasRGDCPrimitive.data_transfer_req.localConnectionRef);
msg ("[RRC_RG] Priority (not used yet): %d\n", p->nasRGDCPrimitive.data_transfer_req.priority);
msg ("[RRC_RG] Data length: %d\n", data_length);
rrc_print_buffer ((char *) (protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr)->data, data_length);
#endif
rrc_rg_msg_dlXfer (UE_Id, &Message_Id);
RRC_RG_SEND_AM_SRB3 (UE_Id);
free_mem_block (protocol_bs->rrc.Mobile_List[UE_Id].dl_nas_message_ptr);
}
break;
case RB_ESTABLISH_REQ:
if (protocol_bs->rrc.Mobile_List[UE_Id].local_connection_ref == (int) (p->nasRGDCPrimitive.rb_establish_req.localConnectionRef)) {
#ifdef DEBUG_RRC_STATE
rrc_print_buffer ((char *)buffer, count);
msg ("[RRC_RG] RB_ESTABLISH_REQ primitive length: %d\n", (int) (p->length));
msg ("[RRC_RG] Local Connection reference: %d\n", p->nasRGDCPrimitive.rb_establish_req.localConnectionRef);
msg ("[RRC_RG] RB Id: %d ", p->nasRGDCPrimitive.rb_establish_req.rbId);
msg (" QoS Class: %d", p->nasRGDCPrimitive.rb_establish_req.QoSclass);
msg (" IP DSCP: %d\n", p->nasRGDCPrimitive.rb_establish_req.dscp);
#endif
protocol_bs->rrc.Mobile_List[UE_Id].requested_rbId = p->nasRGDCPrimitive.rb_establish_req.rbId;
protocol_bs->rrc.Mobile_List[UE_Id].requested_MTrbId = protocol_bs->rrc.Mobile_List[UE_Id].requested_rbId - (UE_Id * maxRB);
protocol_bs->rrc.Mobile_List[UE_Id].requested_QoSclass = p->nasRGDCPrimitive.rb_establish_req.QoSclass;
protocol_bs->rrc.Mobile_List[UE_Id].requested_dscp = p->nasRGDCPrimitive.rb_establish_req.dscp;
if ((p->nasRGDCPrimitive.rb_establish_req.QoSclass >= 1) || (p->nasRGDCPrimitive.rb_establish_req.QoSclass <= RRC_QOS_LAST)) {
rrc_rg_fsm_control (UE_Id, NAS_RB_ESTAB);
}else{
RRC_RG_O_O_NAS_RB_Failure (UE_Id);
}
}
break;
case RB_RELEASE_REQ:
if (protocol_bs->rrc.Mobile_List[UE_Id].local_connection_ref == (int) (p->nasRGDCPrimitive.rb_release_req.localConnectionRef)) {
#ifdef DEBUG_RRC_STATE
rrc_print_buffer ((char *)buffer, count);
msg ("[RRC_RG] RB_RELEASE_REQ primitive length: %d\n", (int) (p->length));
msg ("[RRC_RG] Local Connection reference: %d\n", p->nasRGDCPrimitive.rb_release_req.localConnectionRef);
msg ("[RRC_RG] RB Id: %d \n", p->nasRGDCPrimitive.rb_release_req.rbId);
#endif
protocol_bs->rrc.Mobile_List[UE_Id].requested_rbId = p->nasRGDCPrimitive.rb_establish_req.rbId;
protocol_bs->rrc.Mobile_List[UE_Id].requested_MTrbId = protocol_bs->rrc.Mobile_List[UE_Id].requested_rbId - (UE_Id * maxRB);
rrc_rg_fsm_control (UE_Id, NAS_RB_RELEASE);
}
break;
#ifdef ALLOW_MBMS_PROTOCOL
case MBMS_UE_NOTIFY_REQ:
if (protocol_bs->rrc.Mobile_List[UE_Id].local_connection_ref == (int)(p->nasRGDCPrimitive.mbms_ue_notify_req.localConnectionRef)){
//Copy primitive information into the control block
p_rg_mbms->nas_ueID = (int)(p->nasRGDCPrimitive.mbms_ue_notify_req.localConnectionRef);
for (i = 0; i<MAX_MBMS_SERVICES; i++){
p_rg_mbms->nas_joinedServices[i] = p->nasRGDCPrimitive.mbms_ue_notify_req.joined_services[i].mbms_serviceId;
p_rg_mbms->nas_leftServices[i] = p->nasRGDCPrimitive.mbms_ue_notify_req.left_services[i].mbms_serviceId;
}
#ifdef DEBUG_RRC_STATE
rrc_print_buffer((char *)buffer,count);
msg("[RRC_RG][MBMS] MBMS_UE_NOTIFY_REQ primitive length: %d\n",(int)(p->length));
msg("[RRC_RG][MBMS] Local Connection reference: %d\n",p->nasRGDCPrimitive.mbms_ue_notify_req.localConnectionRef);
// msg("[RRC_RG][MBMS] Lists of joined services and left services are not shown \n");
#endif
// rrc_rg_mbms_NAS_Notification_rx(UE_Id); //send notify to this MT
rrc_rg_mbms_NAS_Notification_rx(); //send notify to this MT
}
break;
#endif
// end MBMS
// Next message to be transferred to GC FIFO.
case ENB_MEASUREMENT_REQ:
// TEMP : CELL_ID coordination to be checked
//if (protocol_bs->rrc.rg_cell_id == (int)(p->nasRGDCPrimitive.eNBmeasurement_req.cell_id)){
protocol_bs->rrc.eNB_measures_flag = 1;
#ifdef DEBUG_RRC_STATE
rrc_print_buffer((char *)buffer,count);
msg("[RRC_RG] ENB_MEASUREMENT_REQ primitive length: %d\n",(int)(p->length));
msg("[RRC_RG] ENB measurement started for Cell_ID: %d\n",p->nasRGDCPrimitive.eNBmeasurement_req.cell_id);
#endif
//}
break;
default:
msg ("[RRC_RG] Invalid message received in DC SAP\n");
rrc_print_buffer ((char *)buffer, count);
count = -1;
break;
}
}
return count;
return 0;
}
