FreeCalypso > hg > fc-magnetite
view src/g23m-aci/dti/dti_kerf.c @ 516:1ed9de6c90bd
src/g23m-gsm/sms/sms_for.c: bogus malloc removed
The new error handling code that was not present in TCS211 blob version
contains a malloc call that is bogus for 3 reasons:
1) The memory allocation in question is not needed in the first place;
2) libc malloc is used instead of one of the firmware's proper ways;
3) The memory allocation is made inside a function and then never freed,
i.e., a memory leak.
This bug was caught in gcc-built FreeCalypso fw projects (Citrine
and Selenite) because our gcc environment does not allow any use of
libc malloc (any reference to malloc produces a link failure),
but this code from TCS3.2 is wrong even for Magnetite: if this code
path is executed repeatedly over a long time, the many small allocations
made by this malloc call without a subsequent free will eventually
exhaust the malloc heap provided by the TMS470 environment, malloc will
start returning NULL, and the bogus code will treat it as an error.
Because the memory allocation in question is not needed at all,
the fix entails simply removing it.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sun, 22 Jul 2018 06:04:49 +0000 |
parents | 53929b40109c |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : DTILIB | Modul : DTI +----------------------------------------------------------------------------- | 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 : Definitions for the Protocol Stack Library | DTI +----------------------------------------------------------------------------- */ /* * Version 1.6 */ #ifndef DTI_KERF_C #define DTI_KERF_C #endif /*==== CONST =======================================================*/ #include <string.h> #include "typedefs.h" #include "pconst.cdg" #include "vsi.h" #include "custom.h" #include "gsm.h" #include "prim.h" #include "dti.h" #include "dti_int_def.h" #include "dti_int_prot.h" #ifdef FF_TCP_IP #include "atp/atp_api.h" #include "atp/atp_messages.h" #include "aaa.h" #include "dti_atp.h" #include "gprs.h" #include "dti_conn_mng.h" /* for getting EXTRACT_DTI_ID */ #endif /*==== LOCALS ================================================================*/ #ifdef _SIMULATION_ LOCAL void send_data_test_req_or_ind ( DTI_HANDLE hDTI, DTI_LINK *link, T_DTI2_DATA_IND *dti_data_ind ); #endif /* _SIMULATION_ */ #ifdef FF_TCP_IP static BOOL ATP_used_flag; #endif /*==== GLOBALS ===============================================================*/ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_init | +--------------------------------------------------------------------+ * * Malloc and set default parameters and specified entity_options for the database * */ GLOBAL DTI_HANDLE dti_init( U8 maximum_links, T_HANDLE handle, U32 entity_options, void (sig_callback( U8 instance, U8 interfac, U8 channel, U8 reason, T_DTI2_DATA_IND *dti_data_ind) ) ) { U16 i; DTI_HANDLE hDTI; DTI_LINK *link, *last_link; trace_function(handle, "dti_init()", entity_options); #if defined ALLOCATE_DATABASE_BLOCK /* * Allocate all needed memory for the DTI Database in one block. */ MALLOC( hDTI, (U16) /* Database */ (sizeof(temp_mem_1) - sizeof(DTI_LINK) + /* Every links */ ((sizeof(temp_mem_2) - sizeof(temp_mem_1))* maximum_links))); /* * Set defaults to the Database. */ set_default_para_data_base(hDTI); /* * Number of links in the Data Base (DTI_DATA_BASE). */ hDTI->max_links = maximum_links; hDTI->handle = handle; hDTI->entity_options = entity_options; /* * Cast the links and init them. */ { U32 link_addr_offset = 0; for(i = 0; i < maximum_links; i++) { if(i == 0) { hDTI->first_link = ((U32) &((temp_mem_1*) hDTI)->tmp_link[i]); link = (DTI_LINK*)hDTI->first_link; init_link_table(link); link_addr_offset = ((U32) &((temp_mem_2*) hDTI)->tmp_link[1]) - ((U32) link); } else { link = link + link_addr_offset; init_link_table(link); } } } #else /* * Allocate the memory over separate blocks. */ MALLOC (hDTI, (U16)(sizeof(DTI_DATA_BASE) - 1)); /* * Set defaults */ set_default_para_data_base(hDTI); /* * Number of links in the Data Base (DTI_DATA_BASE). */ hDTI->max_links = maximum_links; hDTI->handle = handle; hDTI->entity_options = entity_options; /* * Allocate LINK_TABLE for maximum_links and set default parameters */ if(maximum_links > 0) { MALLOC (link, (U16) sizeof(DTI_LINK)); init_link_table(link); hDTI->first_link = (U32) link; for(i = 1; i < maximum_links; i++) { last_link = link; MALLOC (link, (U16) sizeof(DTI_LINK)); init_link_table(link); last_link->next_link = (U32) link; } } #endif #ifdef FF_TCP_IP if (!ATP_used_flag) /* initialise array of references to ATP links */ { for ( i=0; i<MAX_ATP_LINKS; i++) { atp_links[i]= D_LINK; } } #endif /* * Set the callback function for the entity / instance */ hDTI->sig_callback = sig_callback; return hDTI; } /* dti_init() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_deinit | +--------------------------------------------------------------------+ * * Malloc and set default parameter for the Data Base * */ GLOBAL void dti_deinit( DTI_HANDLE hDTI) { trace_function(hDTI->handle, "dti_deinit()", hDTI->entity_options); if(hDTI EQ D_NO_DATA_BASE) return; #if defined ALLOCATE_DATABASE_BLOCK /* * Free the datablock as a block. */ MFREE (hDTI); #else /* * Free the links of the link table with DTI queue */ free_dti_link_structure(hDTI); /* * Free the DTI_DATA_BASE */ MFREE (hDTI); #endif } /* dti_deinit() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : acquire_link | +--------------------------------------------------------------------+ * * This function acquires a link */ LOCAL DTI_RESULT acquire_link(DTI_HANDLE hDTI, U32 link_id, U8 direction, DTI_LINK **link) { trace_function(hDTI->handle, "acquire_link()", hDTI->entity_options); if((*link = get_pointer_link_table(hDTI, link_id, direction)) NEQ NULL) return DTI_S_FOUND; if((*link=get_pointer_free_link(hDTI)) NEQ NULL) { set_default_para_link_table (hDTI, *link, link_id, direction); return DTI_S_CREATED_NEW; } /* * No free link and so no connection possible. */ trace_message_link_id(hDTI->handle, "DTI ERROR: No link free in dtilib", link_id, hDTI->entity_options); return DTI_E_FAIL; } /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_connect_req_or_ind | +--------------------------------------------------------------------+ * PURPOSE: Send a Connect primitive depending on the direction. */ LOCAL void send_connect_req_or_ind (DTI_HANDLE hDTI, DTI_LINK *link) { #define VSI_CALLER hDTI->handle, /* * Check if the link is upwards or downwards * and send the according connect primitive. */ switch(link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: { PALLOC (dti_connect_ind, DTI2_CONNECT_IND); dti_connect_ind->link_id = link->link_id; dti_connect_ind->version = link->version; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_connect_ind); } else { PSEND(link->link_handle, dti_connect_ind); trace_message_link_id(hDTI->handle, "OUT: DTI2_CONNECT_IND", link->link_id, hDTI->entity_options); } } break; case DTI_CHANNEL_TO_LOWER_LAYER: { PALLOC (dti_connect_req, DTI2_CONNECT_REQ); dti_connect_req->link_id = link->link_id; dti_connect_req->version = link->version; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_connect_req); } else { PSEND(link->link_handle, dti_connect_req); trace_message_link_id(hDTI->handle, "OUT: DTI2_CONNECT_REQ", link->link_id, hDTI->entity_options); } } break; default: /* * no known channel type open so do not send anything */ break; } #undef VSI_CALLER } /* send_connect_req_or_ind() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_connect_res_or_cnf | +--------------------------------------------------------------------+ * PURPOSE: Send a Connect Confirm primitive depending on the direction. */ LOCAL void send_connect_res_or_cnf (DTI_HANDLE hDTI, DTI_LINK *link) { #define VSI_CALLER hDTI->handle, /* * Check if the link is upwards or downwards * and send the according connect primitive. */ switch(link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: { PALLOC (dti_connect_cnf, DTI2_CONNECT_CNF); dti_connect_cnf->link_id = link->link_id; dti_connect_cnf->version = link->version; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_connect_cnf); } else { PSEND(link->link_handle, dti_connect_cnf); trace_message_link_id(hDTI->handle, "OUT: DTI2_CONNECT_CNF", link->link_id, hDTI->entity_options); } } break; case DTI_CHANNEL_TO_LOWER_LAYER: { PALLOC (dti_connect_res, DTI2_CONNECT_RES); dti_connect_res->link_id = link->link_id; dti_connect_res->version = link->version; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_connect_res); } else { PSEND(link->link_handle, dti_connect_res); trace_message_link_id(hDTI->handle, "OUT: DTI2_CONNECT_RES", link->link_id, hDTI->entity_options); } } break; default: /* * no known channel type open so do not send anything */ break; } #undef VSI_CALLER } /* send_connect_res_or_cnf() */ /* +-------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : send_open_ready_callback | +-------------------------------------------------------------------------+ * * Activate connection_opened and tx_buffer_ready callback funktions. */ LOCAL void send_open_ready_callback(DTI_HANDLE hDTI, DTI_LINK *link) { #ifdef FF_TCP_IP /* * trigger DTI Primitive transmission separatly, because it can not be done by ATP */ if(link->link_type EQ RIVIERA_ATP_LINK) { PALLOC(dti_ready_ind, DTI2_READY_IND); dti_ready_ind->link_id = link->link_id; #define VSI_CALLER 0, PSEND_NTRACE(link->link_handle, dti_ready_ind); #undef VSI_CALLER /* * stop ATP reception Flow Control */ TRACE_EVENT("initial: ATP_RX_FLOW_OFF"); atp_set_signal(hDTI->entity_id_p, link->port_nb, ATP_RX_FLOW_OFF, ATP_RX_FLOW_UNMASK); } #endif /* FF_TCP_IP */ /* * send indication for the open connection */ hDTI->sig_callback( link->instance, link->interfac, link->channel, DTI_REASON_CONNECTION_OPENED, NULL); /* * Call the callback function with the signal tx_buffer_ready * if the queue is used and not full */ if((link->direction EQ DTI_NULL_LINK) OR ((link->queue_len < link->queue_size) OR (link->link_options EQ DTI_QUEUE_UNBOUNDED))) { link->tx_state = DTI_TX_IDLE; hDTI->sig_callback( link->instance, link->interfac, link->channel, DTI_REASON_TX_BUFFER_READY, NULL ); } } /* send_open_ready_callback() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_open | +--------------------------------------------------------------------+ * * This function opens or resets a DTI connection. * */ GLOBAL BOOL dti_open (DTI_HANDLE hDTI, U8 instance, U8 interfac, U8 channel, U8 queue_size, U8 direction, U32 link_options, U32 version, U8 *neighbor_entity, U32 link_id) { DTI_LINK *link; BOOL send_req_or_ind = FALSE; BOOL send_res_or_cnf = FALSE; BOOL open_vsi_channel = FALSE; BOOL riviera_atp_channel = FALSE; /* came by DAA hack */ #ifdef BT_ADAPTER BOOL riviera_bt_channel = FALSE; /* came by dirty BT interface hack */ #endif /* riviera_bt_channel */ U8 signal = DTI_NO_SIGNAL; trace_function(hDTI->handle, "dti_open()", hDTI->entity_options); trace_message_l_e(hDTI->handle, "open connection", link_id, (char*)neighbor_entity, hDTI->entity_options); #ifdef BT_ADAPTER /* * Check if open with a riviera entity. */ if (strcmp ((CHAR*)neighbor_entity, BTI_NAME) EQ 0) { riviera_bt_channel = TRUE; } #endif /* BT_ADAPTER */ #ifdef FF_TCP_IP TRACE_EVENT_P5 ("dti_open: QS:%d DIR:%d LOPT:%d NE:%s LID:%d V:4", queue_size, direction, link_options, neighbor_entity, link_id); if (strcmp ((CHAR*)neighbor_entity, RIV_NAME) EQ 0) { riviera_atp_channel = TRUE; TRACE_EVENT("Riviera link to be opened!"); } #endif /* FF_TCP_IP */ /* * Validate and correct passed parameters */ if(validate_open_parameters(hDTI, link_id, &queue_size, &direction, &link_options, version, neighbor_entity) EQ DTI_E_FAIL) { return FALSE; } /* * Find a link with the given link_id and direction */ switch (acquire_link (hDTI, link_id, direction, &link) ) { case DTI_S_FOUND: /* * Found already existing link */ switch (link->connect_state) { case DTI_CLOSING: link->connect_state = DTI_IDLE; /* fall through */ case DTI_IDLE: /* * Reset the link and set the parameter. */ trace_message(hDTI->handle, "existing DTI connection is being reset!", hDTI->entity_options); set_open_para_link_table(hDTI, link, version, link_options, instance, interfac, channel, queue_size, DTI_IDLE); /* * Send a confirm primitive if we use SAP DTI2.DOC. Then also set the parameter. */ send_req_or_ind = TRUE; signal = DTI_REASON_CONNECTION_OPENED; if (link->direction NEQ DTI_NULL_LINK) { /* * Close the old channel. */ vsi_c_close (hDTI->handle, link->link_handle); } /* * Set the flag to open a new channel. */ open_vsi_channel = TRUE; break; case DTI_SETUP: /* * Collision of DTI2_CONNECT_REQ and DTI2_CONNECT_IND. The parameters * have been set in dti_open before. They stay in this state. */ break; case DTI_CLOSED: /* * Start with connecting */ set_open_para_link_table ( hDTI, link, version, link_options, instance, interfac, channel, queue_size, DTI_SETUP ); link->connect_state = DTI_SETUP; send_req_or_ind = TRUE; open_vsi_channel = TRUE; break; case DTI_CONNECTING: /* * Got a connecting primitive, send a confirm primitive and set the parameter. */ set_open_para_link_table ( hDTI, link, version, link_options, instance, interfac, channel, queue_size, DTI_IDLE ); send_res_or_cnf = TRUE; signal = DTI_REASON_CONNECTION_OPENED; open_vsi_channel = TRUE; break; default: /* * Wrong state */ trace_message_link_id(hDTI->handle, "DTI ERROR: Wrong state of dtilib", link_id, hDTI->entity_options); break; } break; /* * Created new link */ case DTI_S_CREATED_NEW: /* * Open the requested channel and send a req/ind primitive. */ open_vsi_channel = TRUE; /* * DTILIB can handle DTI SAP DTI.DOC and DTI2.DOC. By using DTI.DOC (the old * SAP) the parameter are set but the connect primitives are not supported. * * SAP DTI.DOC does also not support a queue. So the queue len is set to * 0 in the function set_link_parameter(). */ set_open_para_link_table ( hDTI, link, version, link_options, instance, interfac, channel, queue_size, DTI_SETUP ); send_req_or_ind = TRUE; break; default: /* * No free link - no connection possible. */ return FALSE; } /*lint !e788 enum constant not used */ /* in case of RIV link, get parameters from AAA */ #ifdef FF_TCP_IP if( riviera_atp_channel) { link->link_type = RIVIERA_ATP_LINK; link->entity_db = hDTI; /* remember the entity the link belongs to */ link->dti_id = EXTRACT_DTI_ID(link_id); /* link->link_options = FLOW_CNTRL_DISABLED; */ /* to avoid the full DTI state machine */ /* get the parameters valid within RIV environment from AAA */ if(!aaa_get_connection_data( link->dti_id, &(link->port_nb), &(hDTI->entity_id_p), &(hDTI->own_name))) { TRACE_ERROR("aaa_get_connection_data() failed!"); } else { TRACE_EVENT_P2("got connection_data: name: %s, link_id: %d", (char*) (hDTI->own_name), link->link_id); } if(hDTI->handle EQ PEI_ERROR) { TRACE_ERROR("error getting my own entity handle!"); } } #endif /* mark links connection type */ if( !riviera_atp_channel #ifdef BT_ADAPTER AND !riviera_bt_channel #endif ) /*lint !e774 (Info -- Boolean within 'if' always evaluates to True), only used for FF_TCP_IP/BT */ { link->link_type = ENTITY_LINK; } /* * link to BlueTooth */ #ifdef BT_ADAPTER if(riviera_bt_channel) { link->link_type = RIVIERA_BT_LINK; } #endif /* * Open a channel to VSI. If it is not possible to open, return FALSE to the entity * so that the entity can try again. */ if(open_vsi_channel) { /* * If NULL device then disable flow control */ if(direction EQ DTI_NULL_LINK) { trace_message(hDTI->handle, "DTI connection is to be opened for NULL device", hDTI->entity_options); /* * it is not exactly necessary to set this here, * but only a logical consequence */ link->link_options = DTI_FLOW_CNTRL_DISABLED; link->link_type = NULL_LINK; link->connect_state = DTI_IDLE; /* * Activate callback function with reason_connection_opened * and, additionally, signal tx_buffer_ready if the queue is used. */ send_open_ready_callback(hDTI, link); return TRUE; } if (link->link_type EQ ENTITY_LINK) /* check for connection within GPF */ { open_comm_channel(hDTI->handle, &link->link_handle, (char *) neighbor_entity, hDTI->entity_options); } #ifdef FF_TCP_IP else if (link->link_type EQ RIVIERA_ATP_LINK) /* check for connection towards Riv */ { link->dti_data_ind = NULL; link->connect_state = DTI_IDLE; /* we don't use connect prims here, */ /* so set it by hand */ signal = DTI_REASON_CONNECTION_OPENED; send_res_or_cnf = FALSE; send_req_or_ind = FALSE; open_comm_channel( hDTI->handle, /* open com handle to hDTI-entity */ &link->link_handle, (char *) hDTI->own_name, hDTI->entity_options); /* the port has already been opened by AAA, so only remember link as leading to ATP, * for sending data or events 'backwards' to that entity */ if(link->link_handle >= VSI_OK) { if(atp_links[link->port_nb] EQ D_LINK) { atp_links[link->port_nb] = link; ATP_used_flag = TRUE; } else { TRACE_ERROR("link reference could not be saved for DAA"); } } } #endif if(link->link_handle < VSI_OK) { trace_message_link_id(hDTI->handle, "DTI ERROR: open a comm channel not possible", link_id, hDTI->entity_options); set_default_para_link_table(hDTI, link, D_FREE_LINK_ID, D_DIRECTION); return FALSE; } #ifdef BT_ADAPTER if(link->link_type EQ RIVIERA_BT_LINK) /* connection links into RIV environment */ { /* xxxx: handle new BT link */ } #endif } /* if(open_channel) */ if(send_res_or_cnf) /* shouldn't happen for ATP links! */ { /* Send DTI2_CONNECT_RES or DTI2_CONNECT_CNF */ send_connect_res_or_cnf (hDTI, link); } else if(send_req_or_ind) /* is supposed to happen for ATP links??? */ { /* Send DTI2_CONNECT_REQ or DTI_CONNECT_IND. */ if(link->link_type EQ ENTITY_LINK) { send_connect_req_or_ind (hDTI, link); } } /* * Activate the callback function to the entity. */ if(signal EQ DTI_REASON_CONNECTION_OPENED) { if (!(hDTI->entity_options & DTI_NO_TRACE) ) { trace_message_l_e(hDTI->handle, "DTI connection opened", /*lint !e605 Increase in pointer capability */ link_id, (char*)neighbor_entity, hDTI->entity_options); } /* * Activate callback function with reason_connection_opened * and, additionally, signal tx_buffer_ready if the queue is used. */ send_open_ready_callback (hDTI, link); } return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_disconnect_req_or_ind | +--------------------------------------------------------------------+ * PURPOSE: Send a Disconnect primitive depending on the direction. */ LOCAL void send_disconnect_req_or_ind (DTI_HANDLE hDTI, DTI_LINK* link, U8 cause) { #define VSI_CALLER hDTI->handle, /* * Check if the link is upwards or downwards * and send the according disconnect primitive. */ switch (link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: { PALLOC (dti_disconnect_ind, DTI2_DISCONNECT_IND); dti_disconnect_ind->link_id = link->link_id; dti_disconnect_ind->cause = cause; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_disconnect_ind); } else { PSEND(link->link_handle, dti_disconnect_ind); trace_message_link_id(hDTI->handle, "OUT: DTI2_DISCONNECT_IND", link->link_id, hDTI->entity_options); } } break; case DTI_CHANNEL_TO_LOWER_LAYER: { PALLOC (dti_disconnect_req, DTI2_DISCONNECT_REQ); dti_disconnect_req->link_id = link->link_id; dti_disconnect_req->cause = cause; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_disconnect_req); } else { PSEND(link->link_handle, dti_disconnect_req); trace_message_link_id(hDTI->handle, "OUT: DTI2_DISCONNECT_REQ", link->link_id, hDTI->entity_options); } } break; default: /* * no known channel type open so do not send anything */ break; } #undef VSI_CALLER } /* send_disconnect_req_or_ind() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_ready_req_or_ind | +--------------------------------------------------------------------+ * PURPOSE: Send a Flow Control primitive depending on the direction. */ LOCAL void send_ready_req_or_ind (DTI_HANDLE hDTI, DTI_LINK *link) { #define VSI_CALLER hDTI->handle, #ifdef FF_TCP_IP /* * do not send flow control primitives in case of riviera link * but send a Data primitive to trigger next data reception * this is needed because ATP may has sent data * where DTILIB was not initialized yet */ if(link->link_type EQ RIVIERA_ATP_LINK) { PALLOC(dti_data_ind, DTI2_DATA_IND); dti_data_ind->link_id = link->link_id; dti_data_ind->desc_list2.list_len = 0; dti_data_ind->desc_list2.first = (U32)NULL; PSEND(link->link_handle, dti_data_ind); return; } #endif /* FF_TCP_IP */ /* * Check if the link is upwards or downwards * and send the according connect primitive. */ switch (link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: #ifdef BT_ADAPTER if(link->link_type EQ RIVIERA_BT_LINK) { btidti_getdata_req(link_id); } else #endif /* BT_ADAPTER */ { if(link->link_type EQ ENTITY_LINK) { PALLOC (dti_ready_ind, DTI2_READY_IND); dti_ready_ind->link_id = link->link_id; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_ready_ind); } else { PSEND(link->link_handle, dti_ready_ind); trace_message_link_id(hDTI->handle, "OUT: DTI2_READY_IND", link->link_id, hDTI->entity_options); } } } break; case DTI_CHANNEL_TO_LOWER_LAYER: #ifdef BT_ADAPTER if(link->link_type EQ RIVIERA_BT_LINK) { btidti_getdata_req(link_id); } else #endif /* BT_ADAPTER */ { if(link->link_type EQ ENTITY_LINK) { PALLOC (dti_getdata_req, DTI2_GETDATA_REQ); dti_getdata_req->link_id = link->link_id; if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_getdata_req); } else { PSEND(link->link_handle, dti_getdata_req); trace_message_link_id(hDTI->handle, "OUT: DTI2_GETDATA_REQ", link->link_id, hDTI->entity_options); } } } break; default: /* * no known channel type open so do not send anything */ break; } #undef VSI_CALLER } /* send_ready_req_or_ind() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_close | +--------------------------------------------------------------------+ * * The function searchs a link in the databank link list and closes it. * Then it calls the callback function with the signal DTI_REASON_CONNECTION_CLOSED. */ GLOBAL void dti_close (DTI_HANDLE hDTI, U8 instance, U8 interfac, U8 channel, BOOL flush) { DTI_LINK *link; trace_function( hDTI->handle, "dti_close()", hDTI->entity_options); /* * Find the link in the database */ if((link = get_pointer_link_table_channel(hDTI, instance, interfac, channel)) NEQ NULL) { trace_message_link_id(hDTI->handle, "closing DTI connection", /*lint !e605 Increase in pointer capability */ link->link_id, hDTI->entity_options); if (link->direction EQ DTI_NULL_LINK) { set_default_para_link_table(hDTI, link, D_FREE_LINK_ID, D_DIRECTION); return; } switch (link->connect_state) { /* * The link is already closed */ case DTI_CLOSED: trace_message_link_id(hDTI->handle, "Link is already closed for this entity", link->link_id, hDTI->entity_options); return; /* * In all other states the entity sends a disconnect primitive */ default: /* * exit only after send queue has been emptied? */ if(flush EQ TRUE) { /* * if it is not empty, wait for data flow primitives * from the peer entity */ if(link->queue_len NEQ 0) { link->connect_state = DTI_CLOSING; return; } else { /* * call the callback function right now. */ hDTI->sig_callback( link->instance, link->interfac, link->channel, DTI_REASON_CONNECTION_CLOSED, NULL ); } } if (link->link_type NEQ RIVIERA_ATP_LINK) /* check for connection towards ATP. The NULL_LINK case is handled * above, already. */ { send_disconnect_req_or_ind (hDTI, link, DTI_CAUSE_NORMAL_CLOSE); } #ifdef FF_TCP_IP else /* the links goes towards Riviera */ { U8 i; atp_links[link->port_nb] = D_LINK; ATP_used_flag = FALSE; for (i=0; i<MAX_ATP_LINKS; i++) { if(atp_links[i] NEQ D_LINK) { ATP_used_flag = TRUE; TRACE_EVENT("there are still open ATP links!"); break; } } } #endif /* FF_TCP_IP */ /* * close the communication channel */ vsi_c_close (hDTI->handle, link->link_handle); /* * Set the default parameter. The channel is closed in the neighbour entity. */ set_default_para_link_table(hDTI,link, D_FREE_LINK_ID, D_DIRECTION); /* * Note: Flow control and data primitives are silently discarded. */ break; } } else { /* * there is no link to be found in the table */ trace_message_iic(hDTI->handle, "DTI link is alredy closed", instance, interfac, channel, hDTI->entity_options); } } /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_start | +--------------------------------------------------------------------+ * * If the entity wants to receive data primitives, this function must be * called. */ GLOBAL void dti_start( DTI_HANDLE hDTI, U8 instance, U8 interfac, U8 channel) { DTI_LINK *link; trace_function( hDTI->handle, "dti_start()", hDTI->entity_options); /* * Find the link in the database. */ link = get_pointer_link_table_channel(hDTI, instance, interfac, channel); if(link EQ NULL) { /* * Link id is not in the table. */ trace_message_iic(hDTI->handle, "DTI ERROR: dti_start() - No link id in the database", instance, interfac, channel, hDTI->entity_options); return; } /* * Is the entity connected ? */ if(link->connect_state NEQ DTI_IDLE) { trace_message_link_id(hDTI->handle, "DTI ERROR: link is not connected", link->link_id, hDTI->entity_options); return; } /* * Check if the flow control is not used but do nothing. */ if(link->link_options EQ DTI_FLOW_CNTRL_DISABLED) return; /* * Handle the states */ switch(link->rx_state) { case DTI_RX_IDLE: /* * Change the state to indicate ready to receive data. */ link->rx_state = DTI_RX_READY; /* * No flow control primitive was sent. So send one now. * NOTE: The parameter link->direction gives information about the * direction for sending the data. */ send_ready_req_or_ind (hDTI, link); break; case DTI_RX_STOPPED: /* * The entity has stopped the flow control. * The flow control was sent already. * So change state to DTI_RX_READY. */ link->rx_state = DTI_RX_READY; break; case DTI_RX_READY: /* * dti_start() was already called. */ break; default: /* * Unexpected state - set ERROR. */ trace_message_link_id(hDTI->handle, "DTI ERROR: wrong state", link->link_id, hDTI->entity_options); break; } } /* dti_start() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_stop | +--------------------------------------------------------------------+ * * This function is called if the entity wants to stop receiving of data * primitives. */ GLOBAL void dti_stop( DTI_HANDLE hDTI, U8 instance, U8 interfac, U8 channel) { DTI_LINK *link; trace_function( hDTI->handle, "dti_stop()", hDTI->entity_options); /* * Find the link in the databank. */ link = get_pointer_link_table_channel(hDTI, instance, interfac, channel); /* * It is link id in the table ? */ if(link EQ NULL) { trace_message_iic(hDTI->handle, "DTI ERROR: dti_stop() - No link id in the database", instance, interfac, channel, hDTI->entity_options); return; } /* * Is the entity connected ? */ if(link->connect_state NEQ DTI_IDLE) { trace_message_link_id(hDTI->handle, "DTI ERROR: dti_stop() - link is not connected", link->link_id, hDTI->entity_options); return; } /* * Check if the flow control is not used - then do nothing */ if(link->link_options EQ DTI_FLOW_CNTRL_DISABLED) return; /* * Handle the states */ switch(link->rx_state) { case DTI_RX_READY: /* * The flow control was already sent therefor change to stop state. */ link->rx_state = DTI_RX_STOPPED; break; case DTI_RX_STOPPED: case DTI_RX_IDLE: /* * dti_stop() was already called. * So there is no need to change state. */ break; default: /* * Other state - ERROR */ trace_message_link_id(hDTI->handle, "DTI ERROR: dti_stop() - wrong state", link->link_id, hDTI->entity_options); break; } } /* dti_stop() */ #ifdef _SIMULATION_ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_data_test_req_or_ind | +--------------------------------------------------------------------+ * PURPOSE: Get a DTI_DATA_IND and translate it to DTI_DATA_TEST_IND * and send it. */ LOCAL void send_data_test_req_or_ind (DTI_HANDLE hDTI, DTI_LINK* link, T_DTI2_DATA_IND* dti_data_ind) { #define VSI_CALLER hDTI->handle, U16 len_buf_bits; U16 i; U16 len; U16 j; T_desc2 *p_desc; trace_function(hDTI->handle, "send_data_test_req_or_ind()", hDTI->entity_options); len_buf_bits = dti_data_ind->desc_list2.list_len * 8; /* * Build the SDU primitive and send it */ { PALLOC_SDU (dti_data_test_ind, DTI2_DATA_TEST_IND, len_buf_bits); memset (dti_data_test_ind, 0, sizeof (T_DTI2_DATA_TEST_IND)); dti_data_test_ind->link_id = dti_data_ind->link_id; dti_data_test_ind->parameters = dti_data_ind->parameters; dti_data_test_ind->sdu.l_buf = len_buf_bits; dti_data_test_ind->sdu.o_buf = 0; /* * Copy the descs into sdu structure. */ if(len_buf_bits > 0) { j = 0; p_desc = (T_desc2*)(dti_data_ind->desc_list2.first); while(p_desc NEQ NULL) { len = p_desc->len; for(i=0; i < len; i++) { dti_data_test_ind->sdu.buf[j] = p_desc->buffer[i]; j++; } p_desc = (T_desc2*)(p_desc->next); } } /* * Check if the link is upwards or downwards * and send the according disconnect primitive. */ switch (link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_data_test_ind); } else { PSEND(link->link_handle, dti_data_test_ind); trace_message_l_dl(hDTI->handle, "OUT: DTI2_DATA_TEST_IND", dti_data_ind->link_id, dti_data_ind->desc_list2.list_len, hDTI->entity_options); } break; case DTI_CHANNEL_TO_LOWER_LAYER: if(hDTI->entity_options & DTI_NO_TRACE) { PPASS_NTRACE(dti_data_test_ind, dti_data_test_req, DTI2_DATA_TEST_REQ); PSEND_NTRACE(link->link_handle, dti_data_test_req); } else { PPASS(dti_data_test_ind, dti_data_test_req, DTI2_DATA_TEST_REQ); PSEND(link->link_handle, dti_data_test_req); trace_message_l_dl(hDTI->handle, "OUT: DTI2_DATA_TEST_REQ", dti_data_ind->link_id, dti_data_ind->desc_list2.list_len, hDTI->entity_options); } break; default: /* * no known channel type open so do not send anything */ break; } } /* * Free the dti_data_ind primitive and the descs in the linked list. */ mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); #undef VSI_CALLER } /* send_data_test_req_or_ind() */ #endif /* _SIMULATION_ */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : dti_kerf.c | | STATE : code ROUTINE : send_data_req_or_ind | +--------------------------------------------------------------------+ * PURPOSE: Send a Data primitive depending on the direction. */ LOCAL void send_data_req_or_ind (DTI_HANDLE hDTI, DTI_LINK* link, T_DTI2_DATA_IND* dti_data_ind) { #ifndef _SIMULATION_ U32 link_id; U16 list_len; #endif /* !_SIMULATION_ */ #ifdef BT_ADAPTER if(link->link_type EQ RIVIERA_BT_LINK) { btidti_data_req(dti_data_ind); } else #endif /* BT_ADAPTER */ /* * Check if the primitive is directed to a GPF or ATP entity, and send it. */ #ifdef FF_TCP_IP if(link->link_type EQ RIVIERA_ATP_LINK) { dti_send_data_to_atp(hDTI, link, dti_data_ind); return; } #endif /* FF_TCP_IP */ #ifdef _SIMULATION_ send_data_test_req_or_ind(hDTI, link, dti_data_ind); #else /* _SIMULATION_ */ #define VSI_CALLER hDTI->handle, /* * Check if the link is upwards or downwards * and send the according disconnect primitive. */ switch (link->direction) { case DTI_CHANNEL_TO_HIGHER_LAYER: #ifdef BT_ADAPTER if(link->link_type EQ RIVIERA_LINK) { btidti_data_req(dti_data_ind); } else #endif /* BT_ADAPTER */ { if(hDTI->entity_options & DTI_NO_TRACE) { PSEND_NTRACE(link->link_handle, dti_data_ind); } else { link_id = dti_data_ind->link_id; list_len = dti_data_ind->desc_list2.list_len; PSEND(link->link_handle, dti_data_ind); trace_message_l_dl(hDTI->handle, "OUT: DTI2_DATA_IND", link_id, list_len, hDTI->entity_options); } } break; case DTI_CHANNEL_TO_LOWER_LAYER: if(hDTI->entity_options & DTI_NO_TRACE) { PPASS_NTRACE(dti_data_ind, dti_data_req, DTI2_DATA_REQ); PSEND_NTRACE(link->link_handle, dti_data_req); } else { PPASS(dti_data_ind, dti_data_req, DTI2_DATA_REQ); link_id = dti_data_req->link_id; list_len = dti_data_req->desc_list2.list_len; PSEND(link->link_handle, dti_data_req); trace_message_l_dl(hDTI->handle, "OUT: DTI2_DATA_REQ", link_id, list_len, hDTI->entity_options); } break; default: /* * no known channel type open so do not send anything */ break; } #undef VSI_CALLER #endif /* else _SIMULATION_ */ } /* send_data_req_or_ind() */ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : dti_send_data | +--------------------------------------------------------------------+ * * This function sends data. If the database direction is set to * DTI_UPLINK then it sends a dti_data_req primitive otherwise a DTI_DATA_IND * primitive. */ GLOBAL void dti_send_data (DTI_HANDLE hDTI, U8 instance, U8 interfac, U8 channel, T_DTI2_DATA_IND *dti_data_ind) { DTI_LINK *link; T_DTI2_DATA_IND *hlp_data_ind; trace_function(hDTI->handle, "dti_send_data()", hDTI->entity_options); /* * Find the link in the database. */ link = get_pointer_link_table_channel(hDTI, instance, interfac, channel); if(link EQ NULL) { /* * link_id is not in the table. */ trace_message_iic(hDTI->handle, "DTI ERROR: dti_send_data() - No link id in the database", instance, interfac, channel, hDTI->entity_options); mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); return; } /* * Is the entity connected ? */ if(link->connect_state NEQ DTI_IDLE) { trace_message_link_id(hDTI->handle, "DTI ERROR: dti_send_data() - link is not connected", link->link_id, hDTI->entity_options); mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); return; } /* * If link is a NULL device then just free the message */ if (link->direction EQ DTI_NULL_LINK) { mfree_desc (hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); return; } /* * There is no flow control, so the primitive doesn't get into the queue * and has to get sent at once. */ if(link->link_options EQ DTI_FLOW_CNTRL_DISABLED) { send_data_req_or_ind(hDTI, link, dti_data_ind); return; } switch (link->tx_state) { case DTI_TX_IDLE: case DTI_TX_BUFFER_FULL: /* * While waiting for a flow control primitive no sending is possible. * Put the primitive dti_data_ind in the queue. */ put_dti_data_ind_in_queue_managed (hDTI, link, dti_data_ind); break; case DTI_TX_FLOW: /* * The flow control primitive is already received. * So just send Data primitive and change state. * Because of ATP links there might be still a prim in the queue * therefore we have to use the queue for this */ put_dti_data_ind_in_queue(hDTI, link, dti_data_ind); /* * Read the last packet from the queue and send it. */ { hlp_data_ind = get_dti_data_ind_from_queue(hDTI, link); hlp_data_ind->link_id = link->link_id; /* * The packet will be sent. Now change the state to DTI_TX_IDLE. */ link->tx_state = DTI_TX_IDLE; /* * Send the primitive depending on its direction. */ send_data_req_or_ind(hDTI, link, hlp_data_ind); } break; default: /* * Unknown state.. */ trace_message_link_id(hDTI->handle, "DTI ERROR: dti_send_data() - wrong state", link->link_id, hDTI->entity_options); mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); break; } /* * if queue is full now, send a warning callback */ if((link->queue_len >= link->queue_size) AND (link->link_options NEQ DTI_QUEUE_UNBOUNDED)) { link->tx_state = DTI_TX_BUFFER_FULL; hDTI->sig_callback(link->instance, link->interfac, link->channel, DTI_REASON_TX_BUFFER_FULL, NULL); } } /* dti_send_data() */ /* +--------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : flow_control_prim_received | +--------------------------------------------------------------------------+ PURPOSE : Process primitives DTI_GETDATA_REQ and DTI_READY_IND received from neighbour DTI */ GLOBAL void flow_control_prim_received (DTI_HANDLE hDTI, U32 link_id, U8 direction) { DTI_LINK* link; T_DTI2_DATA_IND* dti_data_ind; trace_function(hDTI->handle, "flow_control_prim_received()", hDTI->entity_options); /* * get link pointer */ link = get_pointer_link_table(hDTI, link_id, direction); if(link EQ NULL) { /* * There is no link_id which requested to the link_id in the link_table. */ trace_message_link_id(hDTI->handle, "DTI ERROR: fc_prim - No link in data base", link_id, hDTI->entity_options); return; } /* * check for valid link * the link is valid if it is in IDLE or CLOSING state * Flow Control primitives are unexpected if Flow Control is disabled */ if(((link->connect_state NEQ DTI_IDLE) AND (link->connect_state NEQ DTI_CLOSING)) OR (link->link_options EQ DTI_FLOW_CNTRL_DISABLED)) { TRACE_EVENT_P4("HORST=7, weil: connect_state %d, link_options %d, link_id %u, direction %d", link->connect_state, link->link_options, link_id, direction); return; } /* * get next prim from queue */ dti_data_ind = get_dti_data_ind_from_queue(hDTI, link); /* * Select the state. */ switch (link->tx_state) { case DTI_TX_IDLE: case DTI_TX_FLOW: /* * A flow control primitive is received. Send a data packet * if there is any in the queue or change the state. * In case of an RIVIERA_ATP_LINK it is necessary to check the send queue * also in DTI_TX_FLOW state */ if(dti_data_ind NEQ NULL) { /* * Select link_id and send data. */ dti_data_ind->link_id = link->link_id; send_data_req_or_ind(hDTI, link, dti_data_ind); /* * Stay in this state. */ } else { /* * Change the state because there is a flow control primitive * and no packet has been sent. */ link->tx_state = DTI_TX_FLOW; } break; case DTI_TX_BUFFER_FULL: /* * The buffer had been full. Send packets from queue and signal ready */ if(dti_data_ind NEQ NULL) { /* * Select link_id and send data. */ dti_data_ind->link_id = link->link_id; send_data_req_or_ind(hDTI, link, dti_data_ind); /* * Change the state if the queue is ready * to get the next data from the entity */ if(link->queue_len < link->queue_size) { link->tx_state = DTI_TX_IDLE; } } else { /* * Change the state because there is a flow control primitive * and no packet has been sent. */ link->tx_state = DTI_TX_FLOW; } /* * Signal to the callback function that the buffer is ready. */ if((link->connect_state NEQ DTI_CLOSING) AND (link->tx_state NEQ DTI_TX_BUFFER_FULL)) { hDTI->sig_callback(link->instance, link->interfac, link->channel, DTI_REASON_TX_BUFFER_READY, NULL); } break; default: trace_message_link_id(hDTI->handle, "DTI ERROR: Wrong state for flow control primitive", link->link_id, hDTI->entity_options); /* * free whole prim, incl. descs */ if(dti_data_ind NEQ NULL) { mfree_desc(hDTI, (T_desc_list2*) &(dti_data_ind->desc_list2)); PFREE(dti_data_ind); } break; } /* * if the connection is to be closed and the send queue is empty * then close the connection now */ if((link->queue_len EQ 0) AND (link->connect_state EQ DTI_CLOSING)) { send_disconnect_req_or_ind(hDTI, link, DTI_CAUSE_NORMAL_CLOSE); close_link_with_signal(hDTI, link); } } /* flow_control_prim_received() */ /* +--------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : connect_init_prim_received | +--------------------------------------------------------------------------+ PURPOSE : Process primitives DTI_CONNECT_REQ and DTI_CONNECT_IND received from neighbour DTI */ GLOBAL void connect_init_prim_received (DTI_HANDLE hDTI, U32 link_id, U32 version, U8 direction) { DTI_LINK* link; BOOL send_cnf = FALSE; BOOL send_disc = FALSE; U8 signal = DTI_NO_SIGNAL; trace_function( hDTI->handle, "connect_init_prim_received()", hDTI->entity_options); /* * Check version of peer dtilib */ if(check_dti_version(hDTI, version) EQ FALSE) { trace_message_link_id(hDTI->handle, "DTI ERROR: init_prim - Wrong DTI version", link_id, hDTI->entity_options); /* * Inform peer dtilib that connection failed */ link = get_pointer_link_table(hDTI, link_id, direction); if(link NEQ NULL) { send_disconnect_req_or_ind (hDTI, link, DTI_CAUSE_UNSUPPORTED_VERSION); close_link_with_signal(hDTI, link); } return; } switch (acquire_link (hDTI, link_id, direction, &link) ) { case DTI_S_FOUND: /* * Entry for link_id found, continue connecting procedure */ break; case DTI_S_CREATED_NEW: /* * There is no entry with the requested link_id in the link_table yet. * Wait for call of dti_open(). * The remaining parameters are set in dti_open(). Then the response * primitive will be sent. */ link->connect_state = DTI_CONNECTING; return; default: /* * No free link */ return; } /* * Start up connecting. */ switch (link->connect_state) { case DTI_IDLE: /* * Reset the link and send a response primitive, free the data packets, * and call the callback funktion. */ set_reset_req_para_link_table(hDTI, link); send_cnf = TRUE; signal = DTI_REASON_CONNECTION_OPENED; trace_message_link_id(hDTI->handle, "DTI connection opened", link->link_id, hDTI->entity_options); break; case DTI_SETUP: /* * Collision ! The neighbour entity has sent a dti_connect_ind * primitive as well which means the neighbor enitiy is willing to connect as well. * So we send a response and open the connection. */ link->connect_state = DTI_IDLE; send_cnf = TRUE; signal = DTI_REASON_CONNECTION_OPENED; link->rx_state = DTI_RX_IDLE; trace_message_link_id(hDTI->handle, "DTI connection opened", link->link_id, hDTI->entity_options); break; case DTI_CLOSING: /* * because of the connect request, internal buffers * are being reset. Thus, the send queue is empty now * and the connection can be closed down. * there has to be a confirmation for the connect * primitive anyway */ send_disc = TRUE; send_cnf = TRUE; break; case DTI_CLOSED: /* * dti_open() is not called yet. The confirm primitive will * be sent then and the parameter will be set. */ link->connect_state = DTI_CONNECTING; break; default: trace_message_link_id(hDTI->handle, "DTI ERROR: init_prim - Wrong state dtilib", link_id, hDTI->entity_options); break; } /* * Send the confirm primitive. */ if (send_cnf) { send_connect_res_or_cnf (hDTI, link); } /* * Send the disconnect primitive. */ if (send_disc) { send_disconnect_req_or_ind (hDTI, link, DTI_CAUSE_NORMAL_CLOSE); close_link_with_signal(hDTI, link); /* * No more signals to be sent in this case.. */ return; } /* * Activate callback function with reason_connection_opened * and, additionally, signal tx_buffer_ready if the queue is used. */ if(signal EQ DTI_REASON_CONNECTION_OPENED) { send_open_ready_callback (hDTI, link); } } /* connect_init_prim_received() */ /* +--------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : connect_confirm_prim_received | +--------------------------------------------------------------------------+ PURPOSE : Process primitives DTI_CONNECT_RES and DTI_CONNECT_CNF received from neighbour DTI */ GLOBAL void connect_confirm_prim_received (DTI_HANDLE hDTI, U32 link_id, U32 version, U8 direction) { DTI_LINK* link; U8 signal = DTI_NO_SIGNAL; trace_function(hDTI->handle, "connect_confirm_prim_received()", hDTI->entity_options); /* * Note: No need to check the version because this has already been done * by the primitives dti_connect_req and dti_connect_ind. */ if((link = get_pointer_link_table(hDTI, link_id, direction)) EQ NULL) { trace_message_link_id(hDTI->handle, "DTI ERROR: cnf_prim - No link in dtilib", link_id, hDTI->entity_options); return; } /* * The link is in the list so check the state. */ switch (link->connect_state) { case DTI_SETUP: /* * The entity can now enter the final state. The entity connection * is established. */ link->connect_state = DTI_IDLE; signal = DTI_REASON_CONNECTION_OPENED; link->rx_state = DTI_RX_IDLE; trace_message_link_id(hDTI->handle, "DTI connection opened", link->link_id, hDTI->entity_options); break; case DTI_CLOSED: case DTI_IDLE: /* * We are already in the final state. So there is nothing to do here. */ break; default: trace_message_link_id(hDTI->handle, "DTI ERROR: cnf_prim - Wrong state dtilib", link_id, hDTI->entity_options); break; } /* * Activate callback function with reason_connection_opened * and, additionally, signal tx_buffer_ready if the queue is used. */ if(signal EQ DTI_REASON_CONNECTION_OPENED) { send_open_ready_callback (hDTI, link); } } /* connect_confirm_prim_received() */ /* +--------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : disconnect_prim_received | +--------------------------------------------------------------------------+ PURPOSE : Process primitives DTI_DISCONNECT_IND and DTI_DISCONNECT_REQ received from neighbour DTI */ GLOBAL void disconnect_prim_received (DTI_HANDLE hDTI, U32 link_id, U8 direction) { DTI_LINK *link; trace_function(hDTI->handle, "disconnect_prim_received()", hDTI->entity_options); /* * Is the link in the link list ? */ if((link = get_pointer_link_table( hDTI, link_id, direction) ) NEQ NULL) { switch (link->connect_state) { /* * Link is already closed. */ case DTI_CLOSED: trace_message_link_id(hDTI->handle, "DTI link alredy closed", link->link_id, hDTI->entity_options); break; /* * Close the link. */ default: close_link_with_signal(hDTI, link); break; } } } /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERP | | STATE : code ROUTINE : data_prim_received | +--------------------------------------------------------------------+ * * Process primitives DTI_DATA_REQ and DTI_DATA_IND received from DTI peer */ GLOBAL void data_prim_received(DTI_HANDLE hDTI, T_DTI2_DATA_IND *dti_data_ind, U8 direction) { DTI_LINK *link; U32 link_id; trace_function(hDTI->handle, "data_prim_received()", hDTI->entity_options); /* * Check if old or new SAP is supported. */ link_id = dti_data_ind->link_id; /* * Is the link in the link list ? */ link = get_pointer_link_table(hDTI, link_id, direction); if(link EQ NULL) { /* * The link_id is not in the list of ids. */ trace_message_link_id(hDTI->handle, "DTI ERROR: data_prim - No link in data base", link_id, hDTI->entity_options); /* * Just ignore the received data primitive. */ mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE(dti_data_ind); return; } /* * If there is no connection silently discard primitive. */ if(link->connect_state NEQ DTI_IDLE) { trace_message_link_id(hDTI->handle, "DTI ERROR: data_prim_received() - link is not connected", link->link_id, hDTI->entity_options); /* * Just ignore the received data primitive. */ mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE(dti_data_ind); return; } /* * Check if no flow control should be supported. Pass the primitive at once * to the entity over the callback function. */ if(link->link_options EQ DTI_FLOW_CNTRL_DISABLED) { hDTI->sig_callback(link->instance, link->interfac, link->channel, DTI_REASON_DATA_RECEIVED, dti_data_ind); return; } #ifdef FF_TCP_IP /* * Get primitive content in case it is a RIVIERA_ATP_LINK */ if(link->link_type EQ RIVIERA_ATP_LINK) { if((link->rx_state EQ DTI_RX_READY) OR (link->rx_state EQ DTI_RX_STOPPED)) { /* * DTI does not really know if there is data available * In case there is no ATP data the list_len value is set to 0 */ get_data_from_atp(hDTI, link, dti_data_ind); if(dti_data_ind->desc_list2.list_len EQ 0) { /* * there is no data in the ATP buffer any more * so release the primitive and start ATP flow control again */ mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); TRACE_EVENT("atp_set_signal: ATP_RX_FLOW_ON"); atp_set_signal(hDTI->entity_id_p, link->port_nb, ATP_RX_FLOW_ON, ATP_RX_FLOW_UNMASK); return; } } else { /* * the entity has stopped data flow * currently it is not allowed to receive data */ mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); return; } } #endif /* FF_TCP_IP */ /* * Handle the states. */ switch(link->rx_state) { case DTI_RX_READY: /* * Receive dti_data_ind, give a signal and send flow control primitive. */ hDTI->sig_callback(link->instance, link->interfac, link->channel, DTI_REASON_DATA_RECEIVED, dti_data_ind); /* * Check if the entity has stoped during the callback. * If yes do not send a flow control. */ if(link->rx_state EQ DTI_RX_READY) { send_ready_req_or_ind(hDTI, link); } else { link->rx_state = DTI_RX_IDLE; } break; case DTI_RX_STOPPED: /* * The entity has stoped the communication but the flow control primitive to * the neighbour entity was sent. The last dti_data_ind signal must be sended * to the entity. DTILIB change to DTI_RX_IDLE. */ link->rx_state = DTI_RX_IDLE; hDTI->sig_callback(link->instance, link->interfac, link->channel, DTI_REASON_DATA_RECEIVED, dti_data_ind); break; default: trace_message_link_id(hDTI->handle, "DTI ERROR: Wrong state for dti_data_ind primitive", link_id, hDTI->entity_options); mfree_desc(hDTI, &dti_data_ind->desc_list2); PFREE (dti_data_ind); break; } } /* data_prim_received() */ #ifdef _SIMULATION_ /* +--------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERP | | STATE : code ROUTINE : data_test_prim_received | +--------------------------------------------------------------------+ PURPOSE : Process primitives DTI_DATA_TEST_REQ and DTI_DATA_TEST_IND received from neighbour DTI */ GLOBAL void data_test_prim_received (DTI_HANDLE hDTI, T_DTI2_DATA_TEST_IND *dti_data_test_ind, U8 direction) { USHORT len_buff, offset, i; T_desc2 *test_desc; trace_function(hDTI->handle, "data_test_prim_received()", hDTI->entity_options); /* * Fill in dti_data_ind the structure. */ { PALLOC (dti_data_ind, DTI2_DATA_IND); dti_data_ind->link_id = dti_data_test_ind->link_id; dti_data_ind->parameters = dti_data_test_ind->parameters; len_buff = dti_data_test_ind->sdu.l_buf>>3; offset = dti_data_test_ind->sdu.o_buf>>3; /* * Build a new desc and fill in the parameter. */ dti_make_new_desc(hDTI, &test_desc, len_buff, TRUE); for(i=0; i < len_buff; i++) test_desc->buffer[i] = dti_data_test_ind->sdu.buf[i+offset]; dti_data_ind->desc_list2.list_len = len_buff; dti_data_ind->desc_list2.first = (ULONG) test_desc; /* * Handle the primitive. */ PFREE (dti_data_test_ind); data_prim_received (hDTI, dti_data_ind, direction); } } #endif /* _SIMULATION_ */ /* +-------------------------------------------------------------------------+ | PROJECT : DTILIB MODULE : DTI_KERF | | STATE : code ROUTINE : vsi_c_psend_ntrace | +-------------------------------------------------------------------------+ * * vsi_c_psend without traces */ #ifdef MEMORY_SUPERVISION GLOBAL SHORT vsi_c_psend_ntrace ( T_HANDLE Caller, T_HANDLE ComHandle, T_VOID_STRUCT *ptr, ULONG MsgLen, const char *file, int line ) #else /* MEMORY_SUPERVISION */ GLOBAL SHORT vsi_c_psend_ntrace ( T_HANDLE Caller, T_HANDLE ComHandle, T_VOID_STRUCT *ptr, ULONG MsgLen ) #endif /* MEMORY_SUPERVISION */ { T_QMSG QMsg; QMsg.Msg.Primitive.Prim = (T_VOID_STRUCT*)(D2P(ptr)); QMsg.Msg.Primitive.PrimLen = MsgLen; QMsg.MsgType = MSG_PRIMITIVE; #ifdef MEMORY_SUPERVISION return ( vsi_c_send ( Caller, ComHandle, &QMsg, file, line) ); #else return ( vsi_c_send ( Caller, ComHandle, &QMsg) ); #endif /* MEMORY_SUPERVISION */ }