FreeCalypso > hg > fc-magnetite
view src/aci2/mfw/mfw_utils.c @ 685:3fb7384e820d
tpudrv12.h: FCDEV3B goes back to being itself
A while back we had the idea of a FreeCalypso modem family whereby our
current fcdev3b target would some day morph into fcmodem, with multiple
FC modem family products, potentially either triband or quadband, being
firmware-compatible with each other and with our original FCDEV3B. But
in light of the discovery of Tango modules that earlier idea is now being
withdrawn: instead the already existing Tango hw is being adopted into
our FreeCalypso family.
Tango cannot be firmware-compatible with triband OM/FCDEV3B targets
because the original quadband RFFE on Tango modules is wired in TI's
original Leonardo arrangement. Because this Leonardo/Tango way is now
becoming the official FreeCalypso way of driving quadband RFFEs thanks
to the adoption of Tango into our FC family, our earlier idea of
extending FIC's triband RFFE control signals with TSPACT5 no longer makes
much sense - we will probably never produce any new hardware with that
once-proposed arrangement. Therefore, that triband-or-quadband FCFAM
provision is being removed from the code base, and FCDEV3B goes back to
being treated the same way as CONFIG_TARGET_GTAMODEM for RFFE control
purposes.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 24 Sep 2020 21:03:08 +0000 |
parents | 93999a60b835 |
children |
line wrap: on
line source
/* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) $Workfile:: mfw_utils.c $| | $Author:: NDH $Revision:: 1 $| | CREATED: 6.1.2003 $Modtime:: 10.04.00 14:58 $| | STATE : code $| +--------------------------------------------------------------------+ MODULE : MFW_UTILS PURPOSE : This modul contains General Functional Utilities. HISTORY: Oct 04, 2004 REF: CRR 25519 Deepa M.D Bug:Re-align structure members in MFW Fix:Structure elements have been realigned to avoid the structure padding Jun 05, 2004 REF: CRR 18262 NISHIKANT KULKARNI Description: The sample sends a STOP DTMF message without release of the key by the user Solution: Instead of sending DTMF commands in "VTS_MOD_Auto" mode, on key press DTMF tone is started using VTS_MOD_ManStart and on key release DTMF tone is stopped using VTS_MOD_ManStop mode. */ #include <string.h> #if defined (NEW_FRAME) #include "typedefs.h" #include "vsi.h" #include "pei.h" #include "custom.h" #include "gsm.h" #else #include "STDDEFS.H" #include "custom.h" #include "gsm.h" #include "vsi.h" #endif #include "mfw_mfw.h" #include "mfw_utils.h" #include "cus_aci.h" #include "prim.h" #ifndef PCM_2_FFS #include "pcm.h" #endif // xnkulkar SPR-18262: This length of array for storing DTMF mode (Start/Stop), is equal to the number // of DTMF tone requests that can be stored in queue. #define MAX_DTMF_Q_ENTRIES 50 /***************************Go-lite Optimization changes start***********************/ //Oct 04, 2004 REF: CRR 25519 Deepa M.D //Structure elements (T_MFW_CBUF_HEADER)are realigned to avoid the structure padding typedef struct { //xnkulkar SPR-18262: This member is used to store the mode for various DTMF tones present in queue to be sent. UBYTE vts_mode[MAX_DTMF_Q_ENTRIES]; USHORT item_size; UBYTE *mfw_cb; ULONG mfw_cb_read_pos; ULONG mfw_cb_write_pos; USHORT num_elements; USHORT max_num_items; UBYTE null_char; UBYTE overwrite; UBYTE static_buf; UBYTE active; } T_MFW_CBUF_HEADER; /***************************Go-lite Optimization changes end***********************/ static T_MFW_CBUF_HEADER cbf_hdr[MAX_CBUF_QUEUES]; static UBYTE cbf_num_of_buffers; /* ** Static Function Prototypes */ static SHORT mfw_cbuf_get_free_id(void); /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_init | +--------------------------------------------------------------------+ PURPOSE : Create and Initialise the Circular Buffer */ SHORT mfw_cbuf_create (USHORT max_num_items, USHORT item_size, UBYTE overwrite, UBYTE null_char, UBYTE static_buf, void *buffer_ptr) { SHORT bufId; if (cbf_num_of_buffers < MAX_CBUF_QUEUES) { /* ** Get the first available Id for a free buffer */ bufId = mfw_cbuf_get_free_id(); if (bufId == MFW_CBUF_NO_BUFS_AVAILABLE) return (MFW_CBUF_NO_BUFS_AVAILABLE); } else { /* ** return -1 as an indication that there are no more buffer handles available */ return (MFW_CBUF_NO_BUFS_AVAILABLE); } /* ** We now have a valid bufferId but check the validity of the incoming parameters ** before we allocate the buffer. */ if (item_size == 0) return (MFW_CBUF_INVALID_ITEM_SIZE); if (max_num_items == 0) return (MFW_CBUF_INVALID_MAX_ITEMS); if ((static_buf) && (buffer_ptr == (void *)0)) return (MFW_CBUF_INVALID_BUF_PTR); if ((!static_buf) && (buffer_ptr != (void *)0)) return (MFW_CBUF_INVALID_BUF_PTR); /* ** Set the selected buffer to active */ cbf_hdr[bufId].active = TRUE; if (!static_buf) { /* ** If the buffer isn't static, then get the dynamic memory for it. */ cbf_hdr[bufId].mfw_cb = mfwAlloc(item_size * max_num_items); cbf_hdr[bufId].static_buf = FALSE; if (cbf_hdr[bufId].mfw_cb == (void *)0) { /* ** The memory Allocation failed, mark the buffer as inactive and return an error */ cbf_hdr[bufId].active = FALSE; return (MFW_CBUF_MEM_ALLOC_FAILURE); } } else { /* ** If the buffer is static, the calling function will have provided a ** pointer to the buffer to be used. */ cbf_hdr[bufId].mfw_cb = (UBYTE *)buffer_ptr; cbf_hdr[bufId].static_buf = TRUE; } /* ** Initialise the buffer header which contains the information needed to ** maintain the buffer */ cbf_hdr[bufId].max_num_items = max_num_items; cbf_hdr[bufId].item_size = item_size; cbf_hdr[bufId].null_char = null_char; cbf_hdr[bufId].overwrite = overwrite; /* ** The buffer is created with no elements in it. */ cbf_hdr[bufId].num_elements = 0; cbf_hdr[bufId].mfw_cb_read_pos = 0; cbf_hdr[bufId].mfw_cb_write_pos = 0; /* ** Ensure the buffer is initialised with the required null character */ memset(cbf_hdr[bufId].mfw_cb, cbf_hdr[bufId].null_char, item_size * max_num_items); return (bufId); } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_delete | +--------------------------------------------------------------------+ PURPOSE : delete a dynamically allocated buffer, freeing the memory A statically allocated buffer CANNOT be released. */ SHORT mfw_cbuf_delete (SHORT bufId) { if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return (MFW_CBUF_INVALID_BUF_ID); if (cbf_hdr[bufId].active == FALSE) return (MFW_CBUF_INVALID_BUF_ID); if (cbf_hdr[bufId].static_buf) return (MFW_CBUF_INVALID_STATIC_BUF); /* ** Free the dynamically allocated memory and set buffer to inactive ** all the other information is irrelevant as once the buffer is marked inactive ** it cannot be used. */ mfwFree(cbf_hdr[bufId].mfw_cb, cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); cbf_hdr[bufId].active = FALSE; return (MFW_CBUF_OK); } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_reset | +--------------------------------------------------------------------+ PURPOSE : clears all the data from the buffer and resets the read and write pointers. */ SHORT mfw_cbuf_reset (SHORT bufId) { if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return (MFW_CBUF_INVALID_BUF_ID); if (cbf_hdr[bufId].active == FALSE) return (MFW_CBUF_INVALID_BUF_ID); /* ** The buffer is reset with no elements in it. */ cbf_hdr[bufId].num_elements = 0; cbf_hdr[bufId].mfw_cb_read_pos = 0; cbf_hdr[bufId].mfw_cb_write_pos = 0; /* ** Ensure the buffer is initialised with the required null character */ memset(cbf_hdr[bufId].mfw_cb, cbf_hdr[bufId].null_char, cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); return (MFW_CBUF_OK); } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_put | +--------------------------------------------------------------------+ PURPOSE : Add an item to the appropriate circular buffer */ SHORT mfw_cbuf_put (SHORT bufId, void *data_ptr) { if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return (MFW_CBUF_INVALID_BUF_ID); if (cbf_hdr[bufId].active == FALSE) return (MFW_CBUF_INVALID_BUF_ID); if (data_ptr == (void *)0) return (MFW_CBUF_INVALID_BUF_PTR); if (cbf_hdr[bufId].num_elements < cbf_hdr[bufId].max_num_items) { /* ** Standard Add data ... no data lost. ** Memcpy the input data into the circular buffer */ memcpy(&cbf_hdr[bufId].mfw_cb[cbf_hdr[bufId].mfw_cb_write_pos], data_ptr, cbf_hdr[bufId].item_size); /* ** Move the write_pointer along to the next required position */ cbf_hdr[bufId].mfw_cb_write_pos = (cbf_hdr[bufId].mfw_cb_write_pos + cbf_hdr[bufId].item_size) % (cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); cbf_hdr[bufId].num_elements++; return (MFW_CBUF_OK); } else if (cbf_hdr[bufId].overwrite) { /* ** Overwrite Add data ... The oldest Data in the buffer is lost. ** Memcpy the input data into the circular buffer */ memcpy(&cbf_hdr[bufId].mfw_cb[cbf_hdr[bufId].mfw_cb_write_pos], data_ptr, cbf_hdr[bufId].item_size); /* ** Move the write_pointer along to the next required position */ cbf_hdr[bufId].mfw_cb_write_pos = (cbf_hdr[bufId].mfw_cb_write_pos + cbf_hdr[bufId].item_size) % (cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); /* ** Move the read pointer along to the next required position as the data it points to ** has been overwritten */ cbf_hdr[bufId].mfw_cb_read_pos = (cbf_hdr[bufId].mfw_cb_read_pos + cbf_hdr[bufId].item_size) % (cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); return (MFW_CBUF_OK_DATA_LOSS); } else { /* ** The Queue is full ... return an error */ return (MFW_CBUF_PUT_FAILED_Q_FULL); } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_get | +--------------------------------------------------------------------+ PURPOSE : Get an event from the DTMF Q */ SHORT mfw_cbuf_get (SHORT bufId, void *buffer_ptr) { if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return (MFW_CBUF_INVALID_BUF_ID); if (cbf_hdr[bufId].active == FALSE) return (MFW_CBUF_INVALID_BUF_ID); if (buffer_ptr == (void *)0) return (MFW_CBUF_INVALID_BUF_PTR); if (cbf_hdr[bufId].num_elements != 0) { /* ** Copy the data from the internal buffer into the output buffer, and reset the internal buffer */ memcpy(buffer_ptr, &cbf_hdr[bufId].mfw_cb[cbf_hdr[bufId].mfw_cb_read_pos], cbf_hdr[bufId].item_size); memset(&cbf_hdr[bufId].mfw_cb[cbf_hdr[bufId].mfw_cb_read_pos], cbf_hdr[bufId].null_char, cbf_hdr[bufId].item_size); /* ** Move the read pointer along to the next required position */ cbf_hdr[bufId].mfw_cb_read_pos = (cbf_hdr[bufId].mfw_cb_read_pos + cbf_hdr[bufId].item_size) % (cbf_hdr[bufId].item_size * cbf_hdr[bufId].max_num_items); cbf_hdr[bufId].num_elements--; return (MFW_CBUF_OK); } else { /* ** The Queue is empty ... put valid (null) data into the buffer and return an error */ memset(buffer_ptr, cbf_hdr[bufId].null_char, cbf_hdr[bufId].item_size); return (MFW_CBUF_BUFFER_EMPTY); } } /* +-----------------------------------------------------------------------+ |xnkulkar SPR-18262 | |ROUTINE: SHORT mfw_cbuf_put_mode() | |PURPOSE : Put the mode (Start/Stop) for the DTMF tone in queue | | | +-----------------------------------------------------------------------+ */ SHORT mfw_cbuf_put_mode (SHORT bufId,UBYTE vts_mode) { TRACE_FUNCTION("mfw_cbuf_put_mode()"); // Check for the validity of buffer ID and "limit" for the number of elements // if ok, put the mode (Start / Stop) for the specified DTMF tone in the queue if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return MFW_CBUF_INVALID_BUF_ID; if (cbf_hdr[bufId].num_elements >= cbf_hdr[bufId].max_num_items) return MFW_CBUF_PUT_FAILED_Q_FULL; cbf_hdr[bufId].vts_mode[cbf_hdr[bufId].mfw_cb_write_pos] = vts_mode; return (MFW_CBUF_OK); } /* +-----------------------------------------------------------------------+ |xnkulkar SPR-18262 | |ROUTINE: SHORT mfw_cbuf_get_mode() | |PURPOSE : Get the mode (Start/Stop) for the DTMF tone in queue | | | +-----------------------------------------------------------------------+ */ SHORT mfw_cbuf_get_mode (SHORT bufId) { TRACE_FUNCTION("mfw_cbuf_get_mode()"); // Check for the validity of buffer ID and "limit" for the number of elements // if ok, return the mode (Start / Stop) for the requested DTMF tone if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return MFW_CBUF_INVALID_BUF_ID; if (cbf_hdr[bufId].num_elements >= cbf_hdr[bufId].max_num_items) return MFW_CBUF_PUT_FAILED_Q_FULL; return cbf_hdr[bufId].vts_mode[cbf_hdr[bufId].mfw_cb_read_pos]; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: MFW_CBUF | | STATE : code ROUTINE: (static) mfw_cbuf_num_elements | +--------------------------------------------------------------------+ PURPOSE : Get the number of events on the DTMF Q */ USHORT mfw_cbuf_num_elements (SHORT bufId) { /* ** In this function, if the buffer Id is invalid in any way, we will need to ** return 0 for the number of elements and know that any other action on ** the buffer will result in an error state. */ if ((bufId < 0) || (bufId >= MAX_CBUF_QUEUES)) return (0); if (cbf_hdr[bufId].active == FALSE) return (0); /* ** Having got to here, the buffer id is valid so return the number of elements */ return (cbf_hdr[bufId].num_elements); } static SHORT mfw_cbuf_get_free_id(void) { SHORT i; for (i=0; i<MAX_CBUF_QUEUES; i++) { if (cbf_hdr[i].active == FALSE) { /* ** This is the first inactive buffer, pass the index back */ return (i); } } /* ** There are no inaqctive buffers, return an Error */ return (MFW_CBUF_NO_BUFS_AVAILABLE); }