FreeCalypso > hg > fc-tourmaline
view src/g23m-gprs/llc/llc_itxf.c @ 287:3dee79757ae4
UI fw: load handheld audio mode on boot
We have now reached the point where use of audio mode config files
should be considered mandatory. In ACI usage we can tell users that
they need to perform an AT@AUL of some appropriate audio mode, but
in UI-enabled fw we really need to have the firmware load audio modes
on its own, so that correct audio config gets established when the
handset or development board runs on its own, without a connected host
computer.
Once have FC Venus with both main and headset audio channels and
headset plug insertion detection, our fw will need to automatically
load the handheld mode or the headset mode depending on the plug
insertion state. For now we load only the handheld mode, which has
been tuned for FC-HDS4 on FC Luna.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 13 Nov 2021 03:20:57 +0000 |
parents | fa8dc04885d8 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : This modul is part of the entity LLC and implements all | procedures and functions as described in the | SDL-documentation (ITX-statemachine) +----------------------------------------------------------------------------- */ #ifndef LLC_ITXF_C #define LLC_ITXF_C #endif #define ENTITY_LLC /*==== INCLUDES =============================================================*/ #include <string.h> /* to get memcpy() */ #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gprs.h" #include "gsm.h" /* to get a lot of macros */ #include "cnf_llc.h" /* to get cnf-definitions */ #include "mon_llc.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "llc.h" /* to get the global entity definitions */ #include "llc_f.h" /* to get the global entity definitions */ #include "llc_txs.h" /* to get signal interface to TX */ #include "llc_itxt.h" /* to get signal interface to TX */ #include "llc_llmes.h" /* to get signal interface to LLME */ #include "llc_itxf.h" /* to get ITX local functions */ /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ LOCAL void itx_send_i_frame (T_ITX_I_QUEUE_ENTRY* entry, T_ABIT_REQ_TYPE tr); LOCAL void itx_i_queue_get_next (T_IQ_STATUS* status, T_ITX_I_QUEUE_ENTRY** entry, T_ABIT_REQ_TYPE* rt); LOCAL void itx_i_queue_get_retr (T_IQ_STATUS* status, T_ITX_I_QUEUE_ENTRY** entry, T_ABIT_REQ_TYPE* rt); LOCAL void itx_s_queue_retrieve (BOOL* found, T_COMMAND* sx, T_ABIT_REQ_TYPE* rt, T_FRAME_NUM* nr, T_SACK_BITMAP* bm, USHORT* bm_byte_size); LOCAL void itx_send_s_frame (T_COMMAND sx, T_ABIT_REQ_TYPE rt, T_FRAME_NUM nr, T_SACK_BITMAP* bm, USHORT bm_byte_size); /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : itx_init +------------------------------------------------------------------------------ | Description : This procedure initialises all necessary variables of | i_frames_tx for all SAPIs. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_init (void) { UBYTE inc; TRACE_FUNCTION( "itx_init" ); /* * Initialise all 4 SAPIs with state TLLI_UNASSIGNED. */ SWITCH_SERVICE (llc, itx, 0); INIT_STATE (ITX_0, ITX_TLLI_UNASSIGNED); SWITCH_SERVICE (llc, itx, 1); INIT_STATE (ITX_1, ITX_TLLI_UNASSIGNED); SWITCH_SERVICE (llc, itx, 2); INIT_STATE (ITX_2, ITX_TLLI_UNASSIGNED); SWITCH_SERVICE (llc, itx, 3); INIT_STATE (ITX_3, ITX_TLLI_UNASSIGNED); /* * Initialise the ITX data structure */ for (inc = 0; inc < ITX_NUM_INC; inc++) { SWITCH_SERVICE (llc, itx, inc); /* * Free old used resources (in case of an LLC restart): * memory, stored primitives, running timer. */ itx_i_queue_clean(); itx_s_queue_clean(); /* * Init data area */ llc_data->itx->tx_waiting = FALSE; llc_data->itx->buffer_was_full = FALSE; llc_data->itx->i_queue.first = NULL; llc_data->itx->s_queue = NULL; llc_data->itx->n_pb_retr = 0; } return; } /* itx_init() */ /* +------------------------------------------------------------------------------ | Function : itx_init_sapi +------------------------------------------------------------------------------ | Description : This procedure initialises all necessary variables of | i_frames_tx for the current SAPI. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_init_sapi (void) { TRACE_FUNCTION( "itx_init_sapi" ); llc_data->itx->buffer_was_full = FALSE; llc_data->itx->t201_entry = NULL; llc_data->itx->n_pb_retr = 0; llc_data->itx->B_tx = 0; return; } /* itx_init_sapi() */ /* +------------------------------------------------------------------------------ | Function : itx_queue_sequence_check +------------------------------------------------------------------------------ | Description : This procedure checks for the A bit request conditions "end of | a sequence of transmitted I frames" | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_queue_sequence_check (T_IQ_STATUS status, T_ITX_I_QUEUE_ENTRY* entry, T_ABIT_REQ_TYPE* rt) { TRACE_FUNCTION( "itx_queue_sequence_check" ); /* * Do not overwrite rt, if it is already set */ if (*rt == ABIT_SET_REQ ) { return; } /* * Handle rt depending on status */ switch (status) { case IQ_NEW_FRAME: /* * If a next frame is not available, the sequence ends */ if (entry == NULL) { *rt = ABIT_SET_REQ; } break; case IQ_RETR_FRAME: /* * If no frame to retransmit is following, the sequence ends */ while (entry) { if (entry->status == IQ_RETR_FRAME) { /* * Another one is following */ return; } entry = entry->next; } *rt = ABIT_SET_REQ; break; default: TRACE_ERROR("Status unexpected"); break; } } /* +------------------------------------------------------------------------------ | Function : itx_i_queue_get_next +------------------------------------------------------------------------------ | Description : This procedure gets the next new frame from the I frame queue. | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void itx_i_queue_get_next (T_IQ_STATUS* status, T_ITX_I_QUEUE_ENTRY** entry, T_ABIT_REQ_TYPE* rt ) { T_ITX_I_QUEUE_ENTRY* iq_ptr; TRACE_FUNCTION( "itx_i_queue_get_next" ); /* * Search for a frame with type equal status */ iq_ptr = llc_data->itx->i_queue.first; while (iq_ptr) { /* * check if we have found the entry */ if (iq_ptr->status == IQ_NEW_FRAME) { *entry = iq_ptr; *status = IQ_NEW_FRAME; /* * check for A bit set condition */ itx_queue_sequence_check (IQ_NEW_FRAME, iq_ptr->next, rt); /* * next one found */ return; } iq_ptr = iq_ptr->next; } /* * We have nothing found to transmit */ *entry = NULL; *status = IQ_NO_FRAME; *rt = ABIT_NO_REQ; } /* itx_i_queue_get_next() */ /* +------------------------------------------------------------------------------ | Function : itx_i_queue_get_retr +------------------------------------------------------------------------------ | Description : This procedure gets the next frame maked for retransmission | from the I frame queue. | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void itx_i_queue_get_retr (T_IQ_STATUS* status, T_ITX_I_QUEUE_ENTRY** entry, T_ABIT_REQ_TYPE* rt ) { T_ITX_I_QUEUE_ENTRY* iq_ptr; TRACE_FUNCTION( "itx_i_queue_get_retr" ); /* * Search for a frame makred for retransmission * Retransmissions can't be stored after new frames */ iq_ptr = llc_data->itx->i_queue.first; while (iq_ptr && iq_ptr->status != IQ_NEW_FRAME) { /* * check if we have found the entry */ if (iq_ptr->status == IQ_RETR_FRAME) { *entry = iq_ptr; *status = IQ_RETR_FRAME; /* * check for A bit set condition */ itx_queue_sequence_check (IQ_RETR_FRAME, iq_ptr->next, rt); /* * next one found */ return; } iq_ptr = iq_ptr->next; } /* * We have nothing found to transmit */ *entry = NULL; *status = IQ_NO_FRAME; *rt = ABIT_NO_REQ; } /* itx_i_queue_get_retr () */ /* +------------------------------------------------------------------------------ | Function : itx_send_next_frame +------------------------------------------------------------------------------ | Description : If LLC is not suspended and TX is ready to receive a frame, | this procedure handles the sending of the next I/S or S frame, | if one is availabel in the I or S queue. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_send_next_frame (T_ABIT_REQ_TYPE req) { T_ITX_I_QUEUE_ENTRY* entry; T_IQ_STATUS status; T_ABIT_REQ_TYPE rt = ABIT_NO_REQ; T_SACK_BITMAP bm; T_COMMAND sx; T_FRAME_NUM nr; USHORT bm_byte_size; BOOL found; TRACE_FUNCTION( "itx_send_next_frame" ); /* * First check, if TX is ready to receive a frame */ if ((llc_data->itx->tx_waiting == FALSE) || (llc_data->suspended == TRUE)) { /* * Label ITX_SEND_1 */ return; } /* * Try to get a frame marked for retransmission from the I queue */ itx_i_queue_get_retr (&status, &entry, &rt); /* * If we found none, try to get a new frame */ if (status == IQ_NO_FRAME ) { /* * Try it only, if the transmit window is not full => V(S) < V(A) + k */ if ( FRAME_WIN_VALID(llc_data->sapi->vs, llc_data->sapi->va, *(llc_data->ku)) ) { itx_i_queue_get_next (&status, &entry, &rt); } } switch (status) { case IQ_NO_FRAME: /* * Label ITX_SEND_2 */ /* * No I frame to send, look for a S frame */ itx_s_queue_retrieve (&found, &sx, &rt, &nr, &bm, &bm_byte_size); /* * If an command was found, send it, else leave */ if (found) { itx_send_s_frame (sx, rt, nr, &bm, bm_byte_size); } break; case IQ_NEW_FRAME: /* * Set A-bit flag in case of V(S) = V(A) + k after sending */ if( llc_data->sapi->vs == (llc_data->sapi->va + *(llc_data->ku) - 1) % (MAX_SEQUENCE_NUMBER+1) ) { rt = ABIT_SET_REQ; } /* * Set current value of V(S) and OC to the next frame and * increment it. Must be done before calling send_i_frame * because of possible recursion! */ entry->ns = llc_data->sapi->vs++; entry->oc_i_tx = llc_data->sapi->oc_i_tx; /* * Handle OC(tx) and MAX_SEQUENCE_NUMBER for acknowledged transfer. */ if (llc_data->sapi->vs > MAX_SEQUENCE_NUMBER) { llc_data->sapi->vs = 0; llc_data->sapi->oc_i_tx += (MAX_SEQUENCE_NUMBER+1); } /* * Transmit I frame and set waiting for acknowlege */ itx_send_i_frame (entry, rt); break; case IQ_RETR_FRAME: /* * Increment retransmission counter and check if * another transmission of this frame is allowed. */ entry->n_retr++; if (entry->n_retr <= *(llc_data->n200) ) { /* * Retransmit frame and set waiting for acknowlege */ itx_send_i_frame (entry, rt); } else { /* * Initiate re-establish */ sig_itx_llme_reest_ind (LLGMM_ERRCS_ACK_NO_PEER_RES_REEST); } break; default: TRACE_ERROR ("UNEXPECTED RETURN CODE"); break; } } /* itx_send_next_frame() */ /* +------------------------------------------------------------------------------ | Function : itx_s_queue_clean +------------------------------------------------------------------------------ | Description : This procedure removes all entries from the S frame queue | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_s_queue_clean (void) { T_ITX_S_QUEUE_ENTRY** entry = &(llc_data->itx->s_queue); TRACE_FUNCTION( "itx_s_queue_clean" ); while (*entry) { /* * get pointer to next (=first) entry */ T_ITX_S_QUEUE_ENTRY* current = *entry; /* * remove next entry from the entry (make second to first) */ *entry = current->next; /* * free the removed entry */ MFREE (current); } } /* itx_s_queue_clean() */ /* +------------------------------------------------------------------------------ | Function : itx_i_queue_clean +------------------------------------------------------------------------------ | Description : This procedure removes all entries including the attached L3 | data from the I-frame queue. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_i_queue_clean (void) { T_ITX_I_QUEUE_ENTRY** entry = &(llc_data->itx->i_queue.first); TRACE_FUNCTION( "itx_i_queue_clean" ); while( *entry ) { /* * get pointer to next (=first) entry */ T_ITX_I_QUEUE_ENTRY* current = *entry; /* * remove next entry from the entry (make second to first) */ *entry = current->next; /* * free L3 primitive data, if attached to the removed entry */ if (current->frame) { /* * Decrease attached counter. If no one is still attached * free the primitive memory */ if (current->frame->attached_counter > CCI_NO_ATTACHE) { current->frame->attached_counter --; if (current->frame->attached_counter == CCI_NO_ATTACHE) { #ifdef LL_DESC /* * The descriptor contents of the primitive structure * must be freed as well. */ llc_cl_desc3_free((T_desc3*)current->frame->desc_list3.first); #endif /* LL_DESC */ PFREE (current->frame); } else { TRACE_0_INFO("LL_DATA_REQ still attached"); } } } /* * free next entry */ MFREE (current); } /* * Adjust number of stored entries in I frame queue */ llc_data->itx->i_queue.entries = 0; /* * Adjust I frame queue size */ llc_data->itx->B_tx = 0; /* * If a I frame is associated with T201, also reset this */ TIMERSTOP (T201); llc_data->itx->t201_entry = NULL; } /* itx_i_queue_clean() */ /* +------------------------------------------------------------------------------ | Function : itx_handle_ll_ready_ind +------------------------------------------------------------------------------ | Description : This procedure checks if further storing of L3 data is allowed. | If possible, a LL_READY_IND is send. | | Parameters : data_send - TRUE if data sent was the reason to call | +------------------------------------------------------------------------------ */ GLOBAL void itx_handle_ll_ready_ind (BOOL data_send) { ULONG M = *(llc_data->mu) * 16; TRACE_FUNCTION( "itx_handle_ll_ready_ind" ); /* * If data_send was the reason to call this function, * only send ready, if buffer was full last call. */ if ((data_send == TRUE) && (llc_data->itx->buffer_was_full == FALSE)) { /* * Nothing to do */ return; } /* * Check if we already have stored more frames than current ku or if * M - if relevant - would exceed if we would add an N201 size frame. * If this is true set buffer_was_full to TRUE. Otherwise send out an * LL_READY_IND. */ if ((llc_data->itx->i_queue.entries < *(llc_data->ku) + ITX_ADD_QUEUE_SIZE) AND ( (M == 0) OR (*(llc_data->n201_i) <= M - llc_data->itx->B_tx) ) ) { PALLOC (ll_ready_ind, LL_READY_IND); ll_ready_ind->sapi = llc_data->current_sapi; TRACE_1_OUT_PARA("s:%d", ll_ready_ind->sapi); PSEND (hCommSNDCP, ll_ready_ind); llc_data->itx->buffer_was_full = FALSE; } else { llc_data->itx->buffer_was_full = TRUE; TRACE_0_INFO("ITX buffer full"); } } /* itx_handle_ll_ready_ind() */ /* +------------------------------------------------------------------------------ | Function : itx_i_queue_store +------------------------------------------------------------------------------ | Description : This procedure tries to store the L3 data request. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_i_queue_store ( #ifdef LL_DESC T_LL_DESC_REQ* ll_desc_req, BOOL *result #else T_LL_DATA_REQ* ll_desc_req, BOOL *result #endif ) { #ifdef LL_DESC T_desc3* desc3; #endif ULONG M = *(llc_data->mu) * 16; TRACE_FUNCTION( "itx_i_queue_store" ); /* * Check, if M would exceed if we transmit this frame. */ #ifdef LL_DESC if ( M == 0 || (ULONG)(ll_desc_req->desc_list3.list_len) <= M - llc_data->itx->B_tx ) #else if ( M == 0 || (ULONG)(BYTELEN(ll_desc_req->sdu.l_buf)) <= M - llc_data->itx->B_tx ) #endif { /* * Store data to the end of the queue (queue type: oldies first) */ T_ITX_I_QUEUE_ENTRY** entry = &(llc_data->itx->i_queue.first); while( *entry ) entry = &((*entry)->next); MALLOC( *entry, sizeof(T_ITX_I_QUEUE_ENTRY) ); if( *entry ) { /* * Memory successful allocated. Fill in struct entries. */ (*entry)->next = NULL; (*entry)->status = IQ_NEW_FRAME; (*entry)->n_retr = 0; (*entry)->ns = 0; (*entry)->frame = ll_desc_req; /* * Store primitive header parameter */ (*entry)->ll_qos = ll_desc_req->ll_qos; (*entry)->radio_prio = ll_desc_req->radio_prio; (*entry)->reference = ll_desc_req->reference1; (*entry)->seg_pos = ll_desc_req->seg_pos; #ifdef REL99 /* * Fill packet flow identifier with corrrect values if it is from one of the SNDCP SAP. * If data request is from GMM fill PFI = LL_PFI_SIGNALING, * If data request is from GSMS fill PFI = LL_PFI_SMS * for all other SAPs(if sapi 2 & 8 are supported in future) set pkt_flow_id is to LL_PKT_FLOW_ID_NOT_PRES, * until specification are clarified. */ switch(ll_desc_req->sapi) { case LL_SAPI_1: /* * From 24.008 & 23.060 it is interpreted that for all signalling data, a * predefined PFI LL_PFI_SIGNALING shall be used. */ (*entry)->pkt_flow_id = LL_PFI_SIGNALING; break; case LL_SAPI_3: case LL_SAPI_5: case LL_SAPI_9: case LL_SAPI_11: (*entry)->pkt_flow_id = (UBYTE)ll_desc_req->pkt_flow_id; break; case LL_SAPI_7: /* * From 24.008 & 23.060 it is interpreted that for all SMS data, a * predefined PFI LL_PFI_SMS shall be used. */ (*entry)->pkt_flow_id = LL_PFI_SMS; break; default: /* * It is possible when we support llc sapi 2 and 8 are supported. * Fill PFI valuse it LL_PKT_FLOW_ID_NOT_PRES */ (*entry)->pkt_flow_id = LL_PKT_FLOW_ID_NOT_PRES; break; } #endif /*REL99 */ #ifdef LL_DESC desc3 = (T_desc3*)ll_desc_req->desc_list3.first; (*entry)->offset = desc3->offset; (*entry)->len = desc3->len; /* * Increase attached counter */ ll_desc_req->attached_counter ++; /* * Increase number of stored entries in I frame queue */ llc_data->itx->i_queue.entries++; /* * Increase amount of stored Information in I frame queue */ llc_data->itx->B_tx += (ll_desc_req->desc_list3.list_len); #else (*entry)->sdu_o_buf = ll_desc_req->sdu.o_buf; (*entry)->sdu_l_buf = ll_desc_req->sdu.l_buf; /* * Increase attached counter */ ll_desc_req->attached_counter ++; /* * Increase number of stored entries in I frame queue */ llc_data->itx->i_queue.entries++; /* * Increase amount of stored Information in I frame queue */ llc_data->itx->B_tx += BYTELEN(ll_desc_req->sdu.l_buf); #endif /*LL_DESC */ /* * Store data succeded */ *result = TRUE; return; } else { /* * Out of memory */ TRACE_ERROR( "Out of memory in itx_i_queue_store()" ); } } *result = FALSE; return; } /* itx_i_queue_store() */ /* +------------------------------------------------------------------------------ | Function : itx_i_queue_get_ready +------------------------------------------------------------------------------ | Description : This procedure checks, if the next entry in the queue is | already acknowledged. If this is true, the entry will be | removed and the frame reference will be returned. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_i_queue_get_ready (BOOL* found, #ifdef LL_2to1 T_LL_reference1* reference, #else T_reference1* reference, #endif UBYTE state) { T_ITX_I_QUEUE_ENTRY** entry = &(llc_data->itx->i_queue.first); TRACE_FUNCTION( "itx_i_queue_get_ready" ); /* * The first entry is the oldest. Only this must be observed. */ if ((*entry) != NULL && (*entry)->status == IQ_IS_ACK_FRAME) { /* * store pointer to the entry */ T_ITX_I_QUEUE_ENTRY* current = *entry; /* * remove entry from the queue (make second to first) */ *entry = current->next; /* * Decrease number of stored entries in I frame queue */ llc_data->itx->i_queue.entries--; if (current->frame) { /* * return original data request reference number */ *reference = current->reference; /* * decrease amount of stored Information in I frame queue. * Take the original value of sdu_len as it was send by L3 */ #ifdef LL_DESC if (llc_data->itx->B_tx >= (ULONG)(current->len)) { llc_data->itx->B_tx -= (ULONG)(current->len); #else if (llc_data->itx->B_tx >= (ULONG)(BYTELEN(current->sdu_l_buf))) { llc_data->itx->B_tx -= (ULONG)(BYTELEN(current->sdu_l_buf)); #endif } else { llc_data->itx->B_tx = 0; TRACE_0_INFO("Unexpected SDU bytelen handled"); } /* * decrease attached counter. If no one is still attached * free the primitive memory */ if (current->frame->attached_counter > CCI_NO_ATTACHE) { current->frame->attached_counter --; if (current->frame->attached_counter == CCI_NO_ATTACHE) { #ifdef LL_DESC llc_cl_desc3_free((T_desc3*)current->frame->desc_list3.first); #endif /* LL_DESC */ PFREE (current->frame); } else { TRACE_0_INFO("LL_DATA_REQ still attached"); } } } else { *found = FALSE; TRACE_0_INFO("No LL_DATA_REQ attached to queue entry"); return; } /* * if the retrieved I frame is associated with T201, reset this */ if (current == llc_data->itx->t201_entry) { if (state != ITX_ABM_PEER_BUSY) { /* * In this state the timer handles other stuff */ TIMERSTOP (T201); } llc_data->itx->t201_entry = NULL; } /* * free retrieved entry */ MFREE (current); *found = TRUE; } else { *found = FALSE; } } /* itx_i_queue_get_ready() */ /* +------------------------------------------------------------------------------ | Function : itx_i_queue_set_status +------------------------------------------------------------------------------ | Description : This procedure sets the acknowledge flag to the frame send with | N equal to num. | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_i_queue_set_status (T_IQ_STATUS status, T_FRAME_NUM num) { T_ITX_I_QUEUE_ENTRY* entry = llc_data->itx->i_queue.first; TRACE_FUNCTION( "itx_i_queue_set_status" ); while (entry) { /* * check if we have found the entry */ if (entry->ns == num ) { /* * found it - set ack and leave */ entry->status = status; return; } /* * goto next entry */ entry = entry->next; } } /* itx_i_queue_set_status() */ /* +----------------------------------------------------------------------------- | Function : itx_s_queue_store +------------------------------------------------------------------------------ | Description : This procedure stores the command to the end of the S queue | | Parameters : | +------------------------------------------------------------------------------ */ GLOBAL void itx_s_queue_store (T_COMMAND command, T_ABIT_REQ_TYPE req_type, T_FRAME_NUM nr, T_SACK_BITMAP* bitmap) { T_ITX_S_QUEUE_ENTRY** entry = &(llc_data->itx->s_queue); TRACE_FUNCTION( "itx_s_queue_store" ); /* * find the end */ while( *entry ) entry = &((*entry)->next); /* * allocate memory */ MALLOC( *entry, sizeof(T_ITX_S_QUEUE_ENTRY) ); if( *entry ) { /* * Memory successful allocated. Fill in struct entries. */ (*entry)->next = NULL; (*entry)->sx = command; (*entry)->rt = req_type; (*entry)->nr = nr; /* * Copy SACK bitmap */ if (bitmap) { (*entry)->bitmap = *bitmap; } } else { /* * Out of memory */ TRACE_ERROR( "Out of memory in itx_i_queue_store()" ); } } /* itx_s_queue_store() */ /* +------------------------------------------------------------------------------ | Function : itx_s_queue_retrieve +------------------------------------------------------------------------------ | Description : This procedure returns the first entry and removes it from the | the queue or, if not available returns a RR command with found | set to false. | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void itx_s_queue_retrieve (BOOL* found, T_COMMAND* sx, T_ABIT_REQ_TYPE* rt, T_FRAME_NUM* nr, T_SACK_BITMAP* bm, USHORT* bm_byte_size) { int i; T_ITX_S_QUEUE_ENTRY** entry = &(llc_data->itx->s_queue); TRACE_FUNCTION( "itx_s_queue_retrieve" ); /* * Take the next entry, if available */ if (*entry != NULL) { /* * Store pointer to the entry */ T_ITX_S_QUEUE_ENTRY* current = *entry; /* * Remove entry from the queue (make second to first) */ *entry = current->next; *sx = current->sx; *rt = current->rt; *nr = current->nr; *bm = current->bitmap; /* * Free retrieved entry */ MFREE (current); *found = TRUE; /* * Special handling for SACK command */ if(*sx == I_SACK) { /* * Calculate bitmap size */ for(i = S_FRAME_SACK_MAX_CTRL_OCTETS-1; i >= 0; i--) { if( bm->data[i] != 0) { /* * Return bm size in bits */ *bm_byte_size = i+1; return; } } } /* * No valid bitmap found, return */ *bm_byte_size = 0; return; } else { /* * Set default return values */ *found = FALSE; *sx = I_RR; *nr = llc_data->sapi->vr; *rt = ABIT_NO_REQ; *bm_byte_size = 0; } } /* itx_s_queue_retrieve () */ /* +------------------------------------------------------------------------------ | Function : itx_send_i_frame +------------------------------------------------------------------------------ | Description : This procedure gets the next supervisor information to send | and build together with the I frame to transmit the final | (expect ciphering and FSC, which will be done by TX) LLC frame. | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void itx_send_i_frame (T_ITX_I_QUEUE_ENTRY* entry, T_ABIT_REQ_TYPE a_req) { #ifdef LL_DESC T_desc_list3* desc_list3; T_desc3* desc3; U8* desc_buf; #else T_sdu* sdu; #endif T_COMMAND sx; T_ABIT_REQ_TYPE rt; T_SACK_BITMAP bm; T_FRAME_NUM nr; USHORT bm_byte_size; USHORT header_size; USHORT offset; BOOL found; TRACE_FUNCTION( "itx_send_i_frame" ); #ifdef LL_DESC if (entry && entry->frame) { PALLOC(ll_unitdesc_req, LL_UNITDESC_REQ); ll_unitdesc_req->attached_counter = entry->frame->attached_counter; ll_unitdesc_req->desc_list3 = entry->frame->desc_list3; /* * Restore original primitive header parameter of the frame. */ ll_unitdesc_req->sapi = llc_data->current_sapi; ll_unitdesc_req->tlli = llc_data->tlli_new; ll_unitdesc_req->ll_qos = entry->ll_qos; ll_unitdesc_req->cipher = LL_CIPHER_ON; ll_unitdesc_req->radio_prio = entry->radio_prio; ll_unitdesc_req->seg_pos = entry->seg_pos; #ifdef REL99 ll_unitdesc_req->pkt_flow_id = entry->pkt_flow_id; #endif /* REL99 */ desc_list3 = &(ll_unitdesc_req->desc_list3); desc3 = (T_desc3*)(desc_list3->first); /* * Restore original desc3 offset and length */ desc3->offset = entry->offset; desc3->len = entry->len; #else if (entry && entry->frame) { PPASS (entry->frame, ll_unitdesc_req, LL_UNITDATA_REQ); /* * Restore original primitive header parameter of the frame. */ ll_unitdesc_req->sapi = llc_data->current_sapi; ll_unitdesc_req->tlli = llc_data->tlli_new; ll_unitdesc_req->ll_qos = entry->ll_qos; ll_unitdesc_req->cipher = LL_CIPHER_ON; ll_unitdesc_req->radio_prio = entry->radio_prio; ll_unitdesc_req->seg_pos = entry->seg_pos; #ifdef REL99 ll_unitdesc_req->pkt_flow_id = entry->pkt_flow_id; #endif /* REL99 */ sdu = &(ll_unitdesc_req->sdu); /* * Restore original SDU offset and length */ sdu->o_buf = entry->sdu_o_buf; sdu->l_buf = entry->sdu_l_buf; #endif /* * Get next S-frame. Take the returned RR if not found = FALSE. */ itx_s_queue_retrieve (&found, &sx, &rt, &nr, &bm, &bm_byte_size); /* * Overwrite A-bit flag request, if neccessary */ if (a_req == ABIT_SET_REQ) { rt = ABIT_SET_REQ; } #ifndef LL_DESC /* * header_size is 4 octets + 1 byte SACK header and the size of * SACK bitmap. The SDU length equal bytes more than the original values. */ if (bm_byte_size > 0) { header_size = I_CTRL_MIN_OCTETS + 1 + bm_byte_size; sdu->o_buf -= header_size * 8; sdu->l_buf += header_size * 8; } else { header_size = I_CTRL_MIN_OCTETS; sdu->o_buf -= header_size * 8; sdu->l_buf += header_size * 8; } if (entry->sdu_o_buf < header_size * 8) { TRACE_ERROR ("ERROR: SDU offset not big enough"); /* * Now try to give stack a chance to continue */ sdu->o_buf = 0; } offset = sdu->o_buf/8; /* * Build LLC Header: * First insert address field (PD and C/R bit are always 0) */ sdu->buf[offset++] = llc_data->current_sapi; /* * Insert 1st octet of control field: * Set A bit and 5 most significant bits of N(S) */ if (rt == ABIT_SET_REQ) { sdu->buf[offset++] = 0x40 | (UBYTE)(entry->ns >> 4); } else { sdu->buf[offset++] = (UBYTE)(entry->ns >> 4); } /* * Insert 2nd octet of control field: * 4 least significant bits of N(S) and 3 most significant bits of N(R) */ sdu->buf[offset++] = (UBYTE)(((entry->ns << 4) & 0xF0) | (nr >> 6)); /* * Insert 3nd octet of control field: * 6 least significant bits of N(R) and the supervisory function bits */ sdu->buf[offset++] = (UBYTE)(((nr << 2) & 0xFC) | sx); /* * Special SACK handling */ if (sx == I_SACK && bm_byte_size != 0) { USHORT i; /* * Insert 1 SACK octet: k - number of SACK bytes */ sdu->buf[offset++] = (UBYTE)bm_byte_size; /* * Insert SACK bitmap */ for (i = 0; i < bm_byte_size; i++) { sdu->buf[offset++] = bm.data[i]; } } /* * Set frame to waiting for ack */ entry->status = IQ_W4ACK_FRAME; #else /* LL_DESC*/ /* * header_size is 4 octets + 1 byte SACK header and the size of * SACK bitmap. The SDU length equal bytes more than the original values. */ if (bm_byte_size > 0) { header_size = I_CTRL_MIN_OCTETS + 1 + bm_byte_size; desc3->offset -= header_size; desc3->len += header_size; desc_list3->list_len += header_size; } else { header_size = I_CTRL_MIN_OCTETS; desc3->offset -= header_size; desc3->len += header_size; desc_list3->list_len += header_size; } if (entry->offset < header_size) { TRACE_ERROR ("ERROR: SDU offset not big enough"); /* * Now try to give stack a chance to continue */ desc3->offset = 0; } offset = desc3->offset; desc_buf = (UBYTE*)desc3->buffer; if(!desc_buf) { TRACE_ERROR("desc_buf is NULLPTR !!!"); return; } /* * Build LLC Header: * First insert address field (PD and C/R bit are always 0) */ desc_buf[offset++] = llc_data->current_sapi; /* * Insert 1st octet of control field: * Set A bit and 5 most significant bits of N(S) */ if (rt == ABIT_SET_REQ) { desc_buf[offset++] = 0x40 | (UBYTE)(entry->ns >> 4); } else { desc_buf[offset++] = (UBYTE)(entry->ns >> 4); } /* * Insert 2nd octet of control field: * 4 least significant bits of N(S) and 3 most significant bits of N(R) */ desc_buf[offset++] = (UBYTE)(((entry->ns << 4) & 0xF0) | (nr >> 6)); /* * Insert 3nd octet of control field: * 6 least significant bits of N(R) and the supervisory function bits */ desc_buf[offset++] = (UBYTE)(((nr << 2) & 0xFC) | sx); /* * Special SACK handling */ if (sx == I_SACK && bm_byte_size != 0) { USHORT i; /* * Insert 1 SACK octet: k - number of SACK bytes */ desc_buf[offset++] = (UBYTE)bm_byte_size; /* * Insert SACK bitmap */ for (i = 0; i < bm_byte_size; i++) { desc_buf[offset++] = bm.data[i]; } } /* * Set frame to waiting for ack */ entry->status = IQ_W4ACK_FRAME; #endif /* LL_DESC */ #ifdef TRACE_EVE { static char* sf[] = { "RR", "ACK", "RNR", "SACK" }; if(sx <= 3) { TRACE_4_INFO("Next I-Frame %s NS:%d NR:%d A:%d", sf[sx], entry->ns, nr, rt); } } #endif /* * reset TX ready flag */ llc_data->itx->tx_waiting = FALSE; /* * If A bit was set, associate T201 with the transmitted I frame * and start T201 */ if (rt == ABIT_SET_REQ) { llc_data->itx->t201_entry = entry; TIMERSTART(T201, llc_data->t200->length); } /* * Now send the frame to TX ( do this as last statement - recursion possible) */ sig_itx_tx_data_req( ll_unitdesc_req, I_FRAME, entry->ns, GRLC_DTACS_DEF, header_size, entry->oc_i_tx); } } /* itx_send_i_frame() */ /* +------------------------------------------------------------------------------ | Function : itx_send_s_frame +------------------------------------------------------------------------------ | Description : This procedure sends the supervisor command to TX | | Parameters : | +------------------------------------------------------------------------------ */ LOCAL void itx_send_s_frame (T_COMMAND sx, T_ABIT_REQ_TYPE rt, T_FRAME_NUM nr, T_SACK_BITMAP* bm, USHORT bm_byte_size) { USHORT offset; #ifndef LL_DESC T_sdu* sdu; USHORT sdu_bitsize; #else T_desc3* desc3; USHORT desc_bytesize; U8* buf; #endif TRACE_FUNCTION( "itx_send_s_frame" ); #ifndef LL_DESC /* * Calculate SDU size */ sdu_bitsize = (S_FRAME_MIN_OCTETS_WITHOUT_FCS * 8) + (bm_byte_size * 8); /* * Build primitive and include supervisory command */ { PALLOC_SDU (ll_unitdata_req, LL_UNITDATA_REQ, sdu_bitsize); ll_unitdata_req->sapi = llc_data->current_sapi; ll_unitdata_req->tlli = llc_data->tlli_new; ll_unitdata_req->attached_counter = CCI_NO_ATTACHE; /* * LLC does not know the QoS profile. S frames should use * LL_NO_REL */ ll_unitdesc_req->ll_qos = llc_data->cur_qos; TRACE_EVENT_P1("peak throughput = %d",llc_data->cur_qos.peak); /* * LLC signalling frames are always sent with highest priority. */ ll_unitdesc_req->radio_prio = llc_data->cur_radio_prio; TRACE_EVENT_P1("radio priority = %d",llc_data->cur_radio_prio); #ifdef REL99 /* * From 24.008 & 23.060 it is interpreted that for all signalling data, a * predefined PFI LL_PFI_SIGNALING shall be used. */ ll_unitdesc_req->pkt_flow_id = llc_data->cur_pfi; TRACE_EVENT_P1("packet flow id = %d",llc_data->cur_pfi); #endif /* REL99 */ /* * Don't worry about L3 reference - TX will ignore it */ /* * SDU offset is 0. The SDU length is sdu_bitsize */ sdu = &(ll_unitdata_req->sdu); sdu->o_buf = 0; sdu->l_buf = sdu_bitsize; offset = 0; /* * Build LLC Header: * First insert address field (PD and C/R bit are always 0) */ sdu->buf[offset++] = llc_data->current_sapi; /* * Set A bit and 3 most significant bits of N(R) */ if (rt == ABIT_SET_REQ) { /* LINTED [following sdu index fits into sdu] */ sdu->buf[offset++] = 0xA0 | (UBYTE)(nr >> 6); } else { /* LINTED [following sdu index fits into sdu] */ sdu->buf[offset++] = 0x80 | (UBYTE)(nr >> 6); } /* * 6 least significant bits of N(R) and the supervisory function bits */ { /* LINTED [following sdu index fits into sdu] */ sdu->buf[offset++] = (UBYTE)(((nr << 2) & 0xFC) | sx); } /* * Special SACK bitmap handling */ if (sx == I_SACK && bm_byte_size != 0 && bm != NULL) { USHORT i; /* * Insert SACK bitmap */ for (i = 0; i < bm_byte_size; i++) { /* LINTED [following sdu indexes are fitting into sdu] */ sdu->buf[offset++] = bm->data[i]; } } #ifdef TRACE_EVE { static char* sf[] = { "RR", "ACK", "RNR", "SACK" }; if(sx <= 3) { TRACE_3_INFO("Next S-Frame %s NR:%d A:%d", sf[sx], nr, rt); } } #endif /* * Reset TX ready flag (before sending because of possible recursion) */ llc_data->itx->tx_waiting = FALSE; /* * Now send the frame to TX. header_size and oc are not used and set to zero. */ sig_itx_tx_data_req( ll_unitdata_req, S_FRAME, nr, GRLC_DTACS_DEF, 0, 0); } #else /* LL_DESC */ /* * Calculate DESC size */ desc_bytesize = (S_FRAME_MIN_OCTETS_WITHOUT_FCS) + (bm_byte_size); /* * Build primitive and include supervisory command */ { PALLOC (ll_unitdesc_req, LL_UNITDESC_REQ); desc3 = llc_palloc_desc(desc_bytesize, 0); ll_unitdesc_req->desc_list3.first = (ULONG)desc3; ll_unitdesc_req->desc_list3.list_len = desc3->len; ll_unitdesc_req->sapi = llc_data->current_sapi; ll_unitdesc_req->tlli = llc_data->tlli_new; ll_unitdesc_req->attached_counter = CCI_NO_ATTACHE; /* * LLC does not know the QoS profile. S frames should use * LL_NO_REL */ ll_unitdesc_req->ll_qos.peak = GRLC_PEAK_SUB; #ifdef LL_2to1 ll_unitdesc_req->ll_qos.relclass = PS_NO_REL; #else ll_unitdesc_req->ll_qos.relclass = LL_NO_REL; #endif /* * LLC signalling frames are always sent with highest priority. */ ll_unitdesc_req->radio_prio = GRLC_RADIO_PRIO_1; #ifdef REL99 /* * From 24.008 & 23.060 it is interpreted that for all signalling data, a * predefined PFI LL_PFI_SIGNALING shall be used. */ ll_unitdesc_req->pkt_flow_id = LL_PFI_SIGNALING; #endif /* REL99 */ /* * Don't worry about L3 reference - TX will ignore it */ /* * SDU offset is 0. The SDU length is sdu_bitsize */ desc3->offset = 0; desc3->len = desc_bytesize; offset = 0; buf = (U8*)desc3->buffer; /* * Build LLC Header: * First insert address field (PD and C/R bit are always 0) */ buf[offset++] = llc_data->current_sapi; /* * Set A bit and 3 most significant bits of N(R) */ if (rt == ABIT_SET_REQ) { /* LINTED [following sdu index fits into sdu] */ buf[offset++] = 0xA0 | (UBYTE)(nr >> 6); } else { /* LINTED [following sdu index fits into sdu] */ buf[offset++] = 0x80 | (UBYTE)(nr >> 6); } /* * 6 least significant bits of N(R) and the supervisory function bits */ { /* LINTED [following sdu index fits into sdu] */ buf[offset++] = (UBYTE)(((nr << 2) & 0xFC) | sx); } /* * Special SACK bitmap handling */ if (sx == I_SACK && bm_byte_size != 0 && bm != NULL) { USHORT i; /* * Insert SACK bitmap */ for (i = 0; i < bm_byte_size; i++) { /* LINTED [following sdu indexes are fitting into sdu] */ buf[offset++] = bm->data[i]; } } #ifdef TRACE_EVE { static char* sf[] = { "RR", "ACK", "RNR", "SACK" }; if(sx <= 3) { TRACE_3_INFO("Next S-Frame %s NR:%d A:%d", sf[sx], nr, rt); } } #endif /* * Reset TX ready flag (before sending because of possible recursion) */ llc_data->itx->tx_waiting = FALSE; /* * Now send the frame to TX. header_size and oc are not used and set to zero. */ sig_itx_tx_data_req( ll_unitdesc_req, S_FRAME, nr, GRLC_DTACS_DEF, 0, 0); } #endif /* LL_DESC */ } /* itx_send_s_frame() */