FreeCalypso > hg > fc-magnetite
view src/g23m-aci/gdd_dio/gdd_dio_drv.c @ 640:16eb1b9640dc
target gtm900 renamed to gtm900mgc2
This change reflects the fact that the build target in question supports
MGC2GSMT hardware only, and will NOT work on other hw that confusing bears
the same end user name of GTM900, neither the LoCosto-based GTM900-C
nor the Calypso-based MG01GSMT that has a different and incompatible RFFE.
If we ever get our hands on a piece of MG01GSMT hw and add support for it,
that other target will be named gtm900mg01.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 31 Jan 2020 00:46:07 +0000 |
parents | 53929b40109c |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : +----------------------------------------------------------------------------- | Copyright 2004 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 : DIOv4 GDD functional interfaces +----------------------------------------------------------------------------- */ #define GDD_DIO_DRV_C /*==== INCLUDES =============================================================*/ #include <string.h> #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ /* DIO stuff */ #include "dio.h" #include "dio_il/dio_drv.h" /* GDD_DIO stuff */ /* We must define P_DIO_H, in order to avoid inclusion of p_dio.h. This is necessary due to the special fact, that "dio.h", which is included in the header "dio_io/dio_drv.h", mirrors the header "p_dio.h". */ #define P_DIO_H #include "gdd_dio.h" #include "gdd_dio_rxf.h" #include "gdd_dio_txf.h" #include "gdd_dio_queue.h" #include "gdd_dio_con_mgr.h" /* for gdd_dio_con_mgr_mark_dead() */ /*==== CONSTANTS ============================================================*/ /* * SEE_TRACE_DURING_SYS_INIT, if defined, allows the showing of traces during * system initialization. The definition should be removed for normal * operation. * SEE_DIO_READ_WRITE_DATA, if defined, displays the data content of DIO_READ and * DIO_WRITE. The definition should be removed for normal operation. */ /* #define SEE_TRACE_DURING_SYS_INIT */ /* #define SEE_DIO_READ_WRITE_DATA */ /*==== DEFINITIONS ==========================================================*/ #ifdef SEE_TRACE_DURING_SYS_INIT #ifdef TRACE_FUNCTION #undef TRACE_FUNCTION #define TRACE_FUNCTION TRACE_ERROR #endif /* #ifdef TRACE_FUNCTION */ #ifdef TRACE_EVENT #undef TRACE_EVENT #define TRACE_EVENT TRACE_ERROR #endif /* #ifdef TRACE_EVENT */ #endif /* #ifdef SEE_TRACE_DURING_SYS_INIT */ #define IS_DRV_NUM_BAT(n) (((n&DIO_DRV_MASK)==DIO_DRV_BAT)?TRUE:FALSE) #define IS_DRV_NUM_APP(n) (((n&DIO_DRV_MASK)==DIO_DRV_APP)?TRUE:FALSE) #define IS_DIO_TYPE_PKT(n) (((n&DIO_TYPE_MASK)==DIO_TYPE_PKT)?TRUE:FALSE) /* The following driver definitions should be removed as soon as the DIO IL contains these definitiones */ #ifndef DIO_DRV_TCP #define DIO_DRV_TCP 0x0A000000 /* driver number - TCP/IP adapter */ #endif /* DIO_DRV_TCP */ #ifndef DIO_DRV_SOCK #define DIO_DRV_SOCK 0x0B000000 /* driver number - Socket adapter */ #endif /* DIO_DRV_SOCK */ #ifndef DIO_DRV_SOCKCFG #define DIO_DRV_SOCKCFG 0x0C000000 /* driver number - Socket conf. adapter */ #endif /* DIO_DRV_SOCKCFG */ /*==== TYPES ================================================================*/ /*==== PROTOTYPES GDD DIO INTERFACE FUNCTIONS ================================*/ void dio_user_ready_gdd(U32 device_range_start, U32 device_range_end, U16 drv_handle, T_DRV_CB_FUNC signal_callback); U16 dio_user_not_ready_gdd(U32 device_range_start, U32 device_range_end); void dio_exit_gdd(void); U16 dio_set_rx_buffer_gdd(U32 device, T_dio_buffer * buffer); U16 dio_read_gdd(U32 device, T_DIO_CTRL * control_info, T_dio_buffer **buffer); U16 dio_write_gdd(U32 device, T_DIO_CTRL * control_info, T_dio_buffer *buffer); U16 dio_get_tx_buffer_gdd(U32 device, T_dio_buffer ** buffer); U16 dio_clear_gdd(U32 device); U16 dio_flush_gdd(U32 device); U16 dio_get_capabilities_gdd(U32 device, T_DIO_CAP ** capabilities); U16 dio_set_config_gdd(U32 device, T_DIO_DCB * dcb); U16 dio_get_config_gdd(U32 device, T_DIO_DCB * dcb); U16 dio_close_device_gdd(U32 device); /*==== GLOBAL VARS ==========================================================*/ /*==== LOCAL VARS ===========================================================*/ static T_DIO_FUNC dio_func_bat = { dio_user_ready_gdd, dio_user_not_ready_gdd, dio_exit_gdd, dio_set_rx_buffer_gdd, dio_read_gdd, dio_write_gdd, dio_get_tx_buffer_gdd, dio_clear_gdd, dio_flush_gdd, dio_get_capabilities_gdd, dio_set_config_gdd, dio_get_config_gdd, dio_close_device_gdd }; /*==== LOCAL FUNCS ==========================================================*/ /* +------------------------------------------------------------------------------ | Function : inst_num_from_dev_id +------------------------------------------------------------------------------ | Description : get instance number from device id | | Parameters : con_data - connection data | | Return : >= 0 - Success, instance ID < 0 - Error (invalid device) +------------------------------------------------------------------------------ */ int inst_num_from_dev_id(U32 device) { U32 drv_num = device & DIO_DRV_MASK; switch (drv_num) { case DIO_DRV_BAT: return GDD_INST_BAT; case DIO_DRV_APP: return GDD_INST_APP; case DIO_DRV_TCP: return GDD_INST_TCP; case DIO_DRV_SOCK: return GDD_INST_SOCK; case DIO_DRV_SOCKCFG: return GDD_INST_SOCKCFG; default: return -1; } } /* +------------------------------------------------------------------------------ | Function : get_instance_data +------------------------------------------------------------------------------ | Description : Local helper function to get the instance data of a device | | Parameters : gdd_dio_data - pointer to pointer to gdd_dio_data instance | (output parameter) | device - DIO device ID | | Return : FALSE - Success (gdd_dio_data has been set) | TRUE - Failed (invalid device) +------------------------------------------------------------------------------ */ U16 get_instance_data(T_GDD_DIO_DATA ** /*out*/ gdd_dio_data, U32 device) { int inst = inst_num_from_dev_id(device); if(inst >= 0) { *gdd_dio_data = &(gdd_dio_data_base[inst]); return FALSE; } else { return TRUE; } } /* +------------------------------------------------------------------------------ | Function : get_connection_data +------------------------------------------------------------------------------ | Description : Local helper function to map from DIO device ID to the | connection data pointer. | | Parameters : device - DIO device ID | gdd_dio_data - pointer to pointer to gdd_dio_data instance | con_data - pointer to connection data (output parameter) | | Return : FALSE - Success | TRUE - Failed +------------------------------------------------------------------------------ */ U16 get_connection_data(U32 device, T_GDD_DIO_CON_DATA ** /*out*/ con_data) { int i; T_GDD_DIO_DATA *gdd_dio_data = 0; if(get_instance_data(&gdd_dio_data, device)) { TRACE_ERROR("[GDD] Bad DIO device number"); return DRV_INTERNAL_ERROR; } if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_READY) { TRACE_ERROR("[GDD] State error: instance not ready"); return DRV_INTERNAL_ERROR; } for(i=0; i < gdd_dio_data->max_con; ++i) { if(gdd_dio_data->con_arr[i].dio_device EQ device) { *con_data = &(gdd_dio_data->con_arr[i]); return DRV_OK; } } TRACE_ERROR("[GDD] Cannot get connection info for this device"); return DRV_INTERNAL_ERROR; } /* +------------------------------------------------------------------------------ | Function : send_gdd_signal +------------------------------------------------------------------------------ | Description : Local helper function to send a GDD signal to a GDD client. | | Parameters : con_data - connection data | sig_type - type of signal to send +------------------------------------------------------------------------------ */ LOCAL void send_gdd_signal(T_GDD_DIO_CON_DATA * con_data, T_GDD_SIGTYPE sig_type) { T_GDD_SIGNAL sig; char * sig_type_str; switch (sig_type) { case GDD_SIGTYPE_CONNECTION_OPENED: sig_type_str = "GDD_SIGTYPE_CONNECTION_OPENED"; break; case GDD_SIGTYPE_SEND_BUF_AVAILABLE: sig_type_str = "GDD_SIGTYPE_SEND_BUF_AVAILABLE"; break; case GDD_SIGTYPE_CONNECTION_FAILED: sig_type_str = "GDD_SIGTYPE_CONNECTION_FAILED"; break; case GDD_SIGTYPE_BUF_SENT: sig_type_str = "GDD_SIGTYPE_BUF_SENT"; break; default: sig_type_str = "ununsed signal type"; break; } TRACE_USER_CLASS_P2(TC_SIGNALS, "[GDD] Sending signal %s to GDD client (con_handle=0x%4x)", sig_type_str, con_data->dio_device); sig.sig = sig_type; con_data->sig_cb(con_data->dio_device, sig); } /* +------------------------------------------------------------------------------ | Function : init_dio_driver_instance +------------------------------------------------------------------------------ | Description : Local helper initialize a dio driver instance +------------------------------------------------------------------------------ */ LOCAL void init_dio_driver_instance(T_GDD_DIO_DATA * gdd_dio_data, U16 max_devices) { gdd_dio_data->max_con = (U8) max_devices; gdd_dio_data->ker.state = GDD_DIO_KER_INIT; } /*==== FUNCTIONS EXPORTED VIA dio_export() ==================================*/ /* +------------------------------------------------------------------------------ | Function : dio_user_ready_gdd +------------------------------------------------------------------------------ | Description : The function allows the driver to open the channels that have | channel numbers of the given range. Each driver has its ready | function. The function is not called directly by the user of | the DIO interface. The DIO interface layer calls the ready | functions of the DIO driver when dio_user_init() is called. | The driver uses the given signal_callback function for channel | of the given channel number range. The driver stores the | drv_handle and passes it in the T_DRV_SIGNAL structure of the | Signal parameter to the calling process every time the callback | function is called. This function needs to be provided by each | DIO driver in order to enable more than one user using the DIO | interface. | | Parameters : device_range_start - First channel number of a range of | channels which can be handled by a DIO | user now | device_range_end - Last channel number of a range of | channels which can be handled by a | DIO user now | drv_handle - Unique handle of the DIO user. | signal_callback - This parameter points to the function | that is called at the time an event | occurs that is to be signaled. | | Return : none | +------------------------------------------------------------------------------ */ void dio_user_ready_gdd ( U32 device_range_start, U32 device_range_end, U16 drv_handle, T_DRV_CB_FUNC signal_callback ) { T_GDD_DIO_DATA *gdd_dio_data = 0; TRACE_FUNCTION("[GDD] dio_user_ready_gdd()"); /* Only packet data is currently supported - this might change later */ if(IS_DIO_TYPE_PKT(device_range_start) EQ FALSE) { TRACE_ERROR("[GDD] Non-packet device not supported"); return; } if(get_instance_data(&gdd_dio_data, device_range_start)) { TRACE_ERROR("[GDD] Bad DIO device number"); return; } if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_INIT) { TRACE_ERROR("[GDD] DIO driver not initialized"); return; } gdd_dio_data->inst_id = (T_GDD_INST_ID)inst_num_from_dev_id(device_range_start); gdd_dio_data->drv_num = device_range_start & DIO_DRV_MASK; gdd_dio_data->device_range_start = device_range_start; gdd_dio_data->device_range_end = device_range_end; gdd_dio_data->drv_handle = drv_handle; gdd_dio_data->signal_callback = signal_callback; gdd_dio_data->ker.state = GDD_DIO_KER_READY; } /* dio_user_ready_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_user_not_ready_gdd +------------------------------------------------------------------------------ | Description : The function is used to clear the signal_callback/channel | association which was previously set with dio_user_ready_gdd(). | That means the signal_callback function of channels of the | given channel number range must not be call any more. All | channels of the given channel number range need to be closed | before the function can be called. The function returns DRV_OK | if it was able to clear the signal_callback/channel | associations successfully. In case there is no channel in the | given channel number range the function also returns DRV_OK. | If there is still an open channel in the given channel number | range then the function returns DRV_INVALID_PARAMS. In this | case the signal_callback function can still be used by the | driver. | | Parameters : device_range_start - First channel number of a range of | channels which can no longer be handled | by a DIO user now | device_range_end - Last channel number of a range of | channels which can no longer be handled | by a DIO user now | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | +------------------------------------------------------------------------------ */ U16 dio_user_not_ready_gdd ( U32 device_range_start, U32 device_range_end ) { T_GDD_DIO_DATA *gdd_dio_data = 0; TRACE_FUNCTION("[GDD] dio_user_not_ready_gdd()"); if(get_instance_data(&gdd_dio_data, device_range_start)) { TRACE_ERROR("Bad DIO device number"); return DRV_INTERNAL_ERROR; } if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_READY) { TRACE_ERROR("[GDD] State error: instance not ready"); } gdd_dio_data->ker.state = GDD_DIO_KER_INIT; return DRV_OK; } /* dio_user_not_ready_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_exit_gdd +------------------------------------------------------------------------------ | Description : This function is called when this device driver is no longer | longer required. DIO_IL calls this function after both send/ | receive buffers in the driver are flushed and all BAT devies | are closed. | | Parameters : none | | Return : none | +------------------------------------------------------------------------------ */ void dio_exit_gdd(void) { int inst; TRACE_FUNCTION("[GDD] dio_exit_gdd()"); /* Shutdown all instances */ for(inst=0; inst<GDD_NUM_INSTS; ++inst) { gdd_dio_data_base[inst].ker.state = GDD_DIO_KER_DEAD; } } /* dio_exit_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_set_rx_buffer_gdd +------------------------------------------------------------------------------ | Description : This function provides a receive buffer to the driver. The | driver uses this buffer to store the received data of the | specified device. The function should always return immediately | after overtaking the buffer, without waiting for data. To | avoid reception gaps more than one receive buffer should be | provided to the driver via several calls of this function. | The provided buffers should be used in the order they were | provided. If the driver is not able to take over the provided | buffer (e.g. because its internal data buffer queue is full) | the function returns DRV_BUFFER_FULL. The driver uses the | DRV_SIGTYPE_READ signal when data is received. | | Parameters : device - Data device number or DLC number | buffer - Data buffer description | | Return : DRV_OK - Initialization successful | DRV_BUFFER_FULL - Buffer queue is full | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | +------------------------------------------------------------------------------ */ U16 dio_set_rx_buffer_gdd ( U32 device, T_dio_buffer * buffer ) { T_GDD_DIO_CON_DATA *con_data = 0; U16 pos = 0; TRACE_USER_CLASS(TC_FUNC_DATA_FLOW, "[GDD] dio_set_rx_buffer_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } if(gdd_dio_enqueue(buffer, &con_data->rx_queue, &pos) EQ FALSE) { return DRV_BUFFER_FULL; } else { if(con_data->con_state == GDD_DIO_CON_CONNECT) { con_data->con_state = GDD_DIO_CON_READY; send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_OPENED); } if(con_data->wait_send_buf) { send_gdd_signal(con_data, GDD_SIGTYPE_SEND_BUF_AVAILABLE); con_data->wait_send_buf = FALSE; } return DRV_OK; } } /* dio_set_rx_buffer_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_read_gdd +------------------------------------------------------------------------------ | Description : This function returns a receive buffer and control information. | It should always return immediately after changing internal | states, without waiting for any more data. The receive buffers | should be returned in the same order as provided with the | dio_set_rx_buffer() calls (First-In-First-Out). The returned | buffer is not in control of the driver any more. The buffer | should be returned even if it is empty. If there is no receive | buffer in control of the driver any more then buffer is set to | NULL. In this case only control information is delivered. | | Parameters : device - Data device number or DLC number | control_info - The driver copies control information | into the provided control buffer | buffer - Data buffer description | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | +------------------------------------------------------------------------------ */ U16 dio_read_gdd ( U32 device, T_DIO_CTRL * control_info, T_dio_buffer ** buffer ) { T_GDD_DIO_CON_DATA *con_data = 0; TRACE_USER_CLASS(TC_FUNC_DATA_FLOW, "[GDD] dio_read_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } /* Set control info : do nothing for now! */ if(gdd_dio_dequeue(&(con_data->rx_queue), buffer) EQ FALSE) { TRACE_ERROR("[GDD] RX queue is empty"); con_data->con_state = GDD_DIO_CON_READY; return DRV_INTERNAL_ERROR; } else { send_gdd_signal(con_data, GDD_SIGTYPE_BUF_SENT); } if(con_data->con_state NEQ GDD_DIO_CON_CLOSE) { con_data->con_state = GDD_DIO_CON_READY; } return DRV_OK; } /* dio_read_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_write_gdd +------------------------------------------------------------------------------ | Description : This function provides a send buffer to the driver which | contains data to send. This function should return immediately | after overtaking the buffer. To avoid transmission gaps more | than one send buffer should be provided to the driver via | several calls of this function. The provided send buffers | should be sent in the order they were provided. If the driver | is not able to take over the provided buffer (e.g. because its | internal buffer queue is full) the function returns | DRV_BUFFER_FULL. If buffer is set to NULL then the driver only | copies the provided control information. The driver uses the | DRV_SIGTYPE_WRITE signal when the data of the buffer is sent. | | Parameters : device - Data device number or DLC number | control_info - The driver copies control information | into the provided control buffer | buffer - Data buffer description | | Return : DRV_OK - Initialization successful | DRV_BUFFER_FULL - Buffer queue is full | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | +------------------------------------------------------------------------------ */ U16 dio_write_gdd ( U32 device, T_DIO_CTRL * control_info, T_dio_buffer * buf ) { T_GDD_DIO_CON_DATA *con_data = 0; U16 pos = 0; TRACE_USER_CLASS(TC_FUNC_DATA_FLOW, "[GDD] dio_write_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } /* Ignore control information for now */ if(gdd_dio_enqueue(buf, &con_data->tx_queue, &pos) EQ FALSE) { TRACE_ERROR("[GDD] TX buffer queue full"); return DRV_BUFFER_FULL; } gdd_dio_tx_receive_buf(con_data->dio_device, buf); return DRV_OK; } /* dio_write_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_get_tx_buffer_gdd +------------------------------------------------------------------------------ | Description : This function returns a send buffer provided via dio_write(). | It should always return immediately after changing internal | states, without waiting for any outstanding events. The send | buffers should be re-turned in the same order as provided with | the dio_write() calls (First-In-First-Out). The returned send | buffer is not in control of the driver any more. If there is | no send buffer in control of the driver any more then buffer is | set to NULL. | | Parameters : device - Data device number or DLC number | buffer - Data buffer description | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | +------------------------------------------------------------------------------ */ U16 dio_get_tx_buffer_gdd ( U32 device, T_dio_buffer ** buffer ) { T_GDD_DIO_CON_DATA *con_data = 0; TRACE_USER_CLASS(TC_FUNC_DATA_FLOW, "[GDD] dio_get_tx_buffer_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } if(gdd_dio_dequeue(&con_data->tx_queue, buffer) EQ FALSE) { TRACE_ERROR("[GDD] TX buffer queue empty"); return DRV_INTERNAL_ERROR; } return DRV_OK; } /* dio_get_tx_buffer_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_clear_gdd +------------------------------------------------------------------------------ | Description : Clear the hardware send buffer of the device. | - currently not needed for GDD_DIO (BAT adapter). | | Parameters : device - Data device number or DLC number | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | DRV_INPROCESS - The driver is busy clearing the buffer | +------------------------------------------------------------------------------ */ U16 dio_clear_gdd ( U32 device ) { TRACE_FUNCTION("[GDD] dio_clear_gdd()"); /* Do nothing ! */ return DRV_OK; } /* dio_clear_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_flush_gdd +------------------------------------------------------------------------------ | Description : Flush the hardware send buffer of the device. | - currently not needed for GDD_DIO (BAT adapter). | | Parameters : device - Data device number or DLC number. | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | DRV_INPROCESS - The driver is busy clearing the buffer | +------------------------------------------------------------------------------ */ U16 dio_flush_gdd ( U32 device ) { TRACE_FUNCTION("[GDD] dio_flush_gdd()"); /* Do nothing ! */ return DRV_OK; } /* dio_flush_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_get_capabilities_gdd +------------------------------------------------------------------------------ | Description : This function is used to retrieve the capabilities of a device. | It is not allowed to change these values neither by the | driver nor by the protocol stack. | | Parameters : device - Data device number or DLC number. | capabilities - Pointer to the device capabilities. | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | +------------------------------------------------------------------------------ */ U16 dio_get_capabilities_gdd ( U32 device, T_DIO_CAP ** capabilities ) { T_GDD_DIO_CON_DATA * con_data; TRACE_FUNCTION("[GDD] dio_get_capabilities_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } if(inst_num_from_dev_id(device) < 0) { TRACE_ERROR("[GDD] Bad device"); send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_FAILED); return DRV_INTERNAL_ERROR; } /* Only packet data is supported */ if(IS_DIO_TYPE_PKT(device)) { *capabilities = (T_DIO_CAP *) & con_data->dio_cap; return DRV_OK; } else { *capabilities = NULL; send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_FAILED); return DRV_INVALID_PARAMS; } } /* dio_get_capability_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_set_config_gdd +------------------------------------------------------------------------------ | Description : This function is used to configure a device (transmission rate, | flow control, etc). A device can be configured at any time. | dcb points to a Device Control Block. The parameters that can | be configured are included in the Device Control Block. If any | value of the configuration is out of range, not supported or | invalid in combination with any other value of the | configuration, the function returns DRV_INVALID_PARAMS. Each | device needs to be configured after the reception of a | DRV_SIGTYPE_CONNECT signal. Only dio_get_capabilities(), | dio_set_config() and dio_close_device() can be called while the | device is not configured. All other device-specific functions | return DRV_NOTCONFIGURED. | | Parameters : device - Data device number or DLC number | dcb - Pointer to a Device Control Block | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | +------------------------------------------------------------------------------ */ U16 dio_set_config_gdd ( U32 device, T_DIO_DCB * dcb ) { T_GDD_DIO_CON_DATA * con_data; TRACE_FUNCTION("[GDD] dio_set_config_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } if (dcb EQ NULL) { TRACE_ERROR("[GDD] dcb is NULL"); send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_FAILED); return DRV_INTERNAL_ERROR; } if (DIO_TYPE_PKT != dcb->device_type) { TRACE_ERROR("[GDD] bad dcb->device_type"); send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_FAILED); return DRV_INVALID_PARAMS; } /* Ignore dbc->sleep_mode. */ return DRV_OK; } /* dio_set_config_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_get_config_gdd +------------------------------------------------------------------------------ | Description : This function is used to retrieve the configuration of a | device. The driver copies the configuration into the Device | Control Block provided with dcb. | | Parameters : device - Data device number or DLC number | dcb - Pointer to a Device Control Block | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | DRV_NOTCONFIGURED - The device is not yet configured | +------------------------------------------------------------------------------ */ U16 dio_get_config_gdd ( U32 device, T_DIO_DCB * dcb ) { T_GDD_DIO_DATA * gdd_dio_data; TRACE_FUNCTION("[GDD] dio_get_config_gdd()"); if(get_instance_data(&gdd_dio_data, device)) { TRACE_ERROR("[GDD] Bad DIO device number"); return DRV_INTERNAL_ERROR; } if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_READY) { TRACE_ERROR("[GDD] State error: instance not ready"); return GDD_DIO_NOT_READY; } dcb->device_type = DIO_TYPE_PKT; dcb->sleep_mode = DIO_SLEEP_DISABLE; return DRV_OK; } /* dio_get_config_gdd */ /* +------------------------------------------------------------------------------ | Function : dio_close_device_gdd +------------------------------------------------------------------------------ | Description : This function is used to close a device. The driver returns | DRV_OK if it was able to close the device successfully. In case | the specified device does not exist the driver also returns | DRV_OK. If the driver still controls a protocol stack buffer | for this device then it returns DRV_INVALID_PARAMS. In this | case the device is not closed. In order to get the remaining | buffers the protocol stack needs to call the functions | dio_read() and dio_get_tx_buffer(). | | Parameters : device - Data device number or DLC number | | Return : DRV_OK - Initialization successful | DRV_INVALID_PARAMS - User operation can not be terminated yet | DRV_INTERNAL_ERROR - Internal driver error | +------------------------------------------------------------------------------ */ U16 dio_close_device_gdd ( U32 device ) { T_GDD_DIO_CON_DATA * con_data; TRACE_FUNCTION("[GDD] dio_close_device_gdd()"); if(get_connection_data(device, &con_data) NEQ DRV_OK) { return DRV_INTERNAL_ERROR; } /* Inform client: in case the connection was closing, we mark the connection as dead. If not, it means that the connection (which was not yet established) has failed. */ if(con_data->con_state EQ GDD_DIO_CON_CLOSE) { gdd_dio_con_mgr_mark_dead(con_data->dio_device); } else { send_gdd_signal(con_data, GDD_SIGTYPE_CONNECTION_FAILED); } return DRV_OK; } /* dio_close_device_bat */ /*==== EXPORTED FUNCTIONS ===================================================*/ /* +------------------------------------------------------------------------------ | Function : dio_init_bat +------------------------------------------------------------------------------ | Description : The function initializes the BAT driver. The | function returns DRV_INITIALIZED if the driver has already been | initialized and is ready to be used or is already in use. In | case of initialization failure (e.g. the configuration given | with drv_init can not be used) the function returns | DRV_INITFAILURE. In this case the driver can not be used. | | Parameters : none | | Return : DRV_OK - Initialization successful | DRV_INITIALIZED - Interface already initialized | DRV_INITFAILURE - Initialization failed | +------------------------------------------------------------------------------ */ U16 dio_init_bat ( T_DIO_DRV * drv_init ) { T_GDD_DIO_DATA * gdd_dio_data = &gdd_dio_data_base[GDD_INST_BAT]; TRACE_FUNCTION("[GDD] dio_init_bat()"); if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_DEAD) { TRACE_FUNCTION("Instance 'BAT' already initialized"); return DRV_INITIALIZED; } init_dio_driver_instance(gdd_dio_data, drv_init->max_devices); return DRV_OK; } /* dio_init_bat */ /* +------------------------------------------------------------------------------ | Function : dio_export_bat +------------------------------------------------------------------------------ | Description : The function returns, through dio_func, a list of functions | that are exported by the BAT driver. DIO_IL calls this | function after dio_init_bat call return DRV_OK. | | Parameters : dio_func - Return as a pointer to the list of functions | exported by the driver. | | Return : none | +------------------------------------------------------------------------------ */ void dio_export_bat ( T_DIO_FUNC ** dio_func ) { TRACE_FUNCTION("[GDD] dio_export_bat"); *dio_func = (T_DIO_FUNC*) &dio_func_bat; } /* dio_export_bat */ /* +------------------------------------------------------------------------------ | Function : dio_init_app +------------------------------------------------------------------------------ | Description : The function initializes the APP driver. The | function returns DRV_INITIALIZED if the driver has already been | initialized and is ready to be used or is already in use. In | case of initialization failure (e.g. the configuration given | with drv_init can not be used) the function returns | DRV_INITFAILURE. In this case the driver can not be used. | | Parameters : none | | Return : DRV_OK - Initialization successful | DRV_INITIALIZED - Interface already initialized | DRV_INITFAILURE - Initialization failed | +------------------------------------------------------------------------------ */ U16 dio_init_app ( T_DIO_DRV * drv_init ) { T_GDD_DIO_DATA * gdd_dio_data = &gdd_dio_data_base[GDD_INST_APP]; TRACE_FUNCTION("[GDD] dio_init_app()"); if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_DEAD) { TRACE_FUNCTION("[GDD] Instance 'APP' already initialized"); return DRV_INITIALIZED; } init_dio_driver_instance(gdd_dio_data, drv_init->max_devices); return DRV_OK; } /* dio_init_app */ /* +------------------------------------------------------------------------------ | Function : dio_export_app +------------------------------------------------------------------------------ | Description : The function returns, through dio_func, a list of functions | that are exported by the APP driver. DIO_IL calls this | function after dio_init_bat call return DRV_OK. | | Parameters : dio_func - Return as a pointer to the list of functions | exported by the driver. | | Return : none | +------------------------------------------------------------------------------ */ void dio_export_app ( T_DIO_FUNC ** dio_func ) { TRACE_FUNCTION("[GDD] dio_export_app()"); *dio_func = (T_DIO_FUNC*) &dio_func_bat; } /* dio_export_app */ /* +------------------------------------------------------------------------------ | Function : dio_init_sock +------------------------------------------------------------------------------ | Description : The function initializes the TCP driver. The | function returns DRV_INITIALIZED if the driver has already been | initialized and is ready to be used or is already in use. In | case of initialization failure (e.g. the configuration given | with drv_init can not be used) the function returns | DRV_INITFAILURE. In this case the driver can not be used. | | Parameters : none | | Return : DRV_OK - Initialization successful | DRV_INITIALIZED - Interface already initialized | DRV_INITFAILURE - Initialization failed | +------------------------------------------------------------------------------ */ U16 dio_init_tcp ( T_DIO_DRV * drv_init ) { T_GDD_DIO_DATA * gdd_dio_data = &gdd_dio_data_base[GDD_INST_TCP]; TRACE_FUNCTION("[GDD] dio_init_tcp()"); if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_DEAD) { TRACE_FUNCTION("[GDD] Instance 'TCP' already initialized"); return DRV_INITIALIZED; } init_dio_driver_instance(gdd_dio_data, drv_init->max_devices); return DRV_OK; } /* dio_init_tcp */ /* +------------------------------------------------------------------------------ | Function : dio_export_tcp +------------------------------------------------------------------------------ | Description : The function returns, through dio_func, a list of functions | that are exported by the TCP driver. DIO_IL calls this | function after dio_init_bat call return DRV_OK. | | Parameters : dio_func - Return as a pointer to the list of functions | exported by the driver. | | Return : none | +------------------------------------------------------------------------------ */ void dio_export_tcp ( T_DIO_FUNC ** dio_func ) { TRACE_FUNCTION("[GDD] dio_export_tcp()"); *dio_func = (T_DIO_FUNC*) &dio_func_bat; } /* dio_export_tcp */ /* +------------------------------------------------------------------------------ | Function : dio_init_sock +------------------------------------------------------------------------------ | Description : The function initializes the SOCK driver. The | function returns DRV_INITIALIZED if the driver has already been | initialized and is ready to be used or is already in use. In | case of initialization failure (e.g. the configuration given | with drv_init can not be used) the function returns | DRV_INITFAILURE. In this case the driver can not be used. | | Parameters : none | | Return : DRV_OK - Initialization successful | DRV_INITIALIZED - Interface already initialized | DRV_INITFAILURE - Initialization failed | +------------------------------------------------------------------------------ */ U16 dio_init_sock ( T_DIO_DRV * drv_init ) { T_GDD_DIO_DATA * gdd_dio_data = &gdd_dio_data_base[GDD_INST_SOCK]; TRACE_FUNCTION("[GDD] dio_init_sock()"); if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_DEAD) { TRACE_FUNCTION("[GDD] Instance 'SOCK' already initialized"); return DRV_INITIALIZED; } init_dio_driver_instance(gdd_dio_data, drv_init->max_devices); return DRV_OK; } /* dio_init_sock */ /* +------------------------------------------------------------------------------ | Function : dio_export_sock +------------------------------------------------------------------------------ | Description : The function returns, through dio_func, a list of functions | that are exported by the SOCK driver. DIO_IL calls this | function after dio_init_bat call return DRV_OK. | | Parameters : dio_func - Return as a pointer to the list of functions | exported by the driver. | | Return : none | +------------------------------------------------------------------------------ */ void dio_export_sock ( T_DIO_FUNC ** dio_func ) { TRACE_FUNCTION("[GDD] dio_export_sock()"); *dio_func = (T_DIO_FUNC*) &dio_func_bat; } /* dio_export_sock */ /* +------------------------------------------------------------------------------ | Function : dio_init_sockcfg +------------------------------------------------------------------------------ | Description : The function initializes the SOCKCFG driver. The | function returns DRV_INITIALIZED if the driver has already been | initialized and is ready to be used or is already in use. In | case of initialization failure (e.g. the configuration given | with drv_init can not be used) the function returns | DRV_INITFAILURE. In this case the driver can not be used. | | Parameters : none | | Return : DRV_OK - Initialization successful | DRV_INITIALIZED - Interface already initialized | DRV_INITFAILURE - Initialization failed | +------------------------------------------------------------------------------ */ U16 dio_init_sockcfg ( T_DIO_DRV * drv_init ) { T_GDD_DIO_DATA * gdd_dio_data = &gdd_dio_data_base[GDD_INST_SOCKCFG]; TRACE_FUNCTION("[GDD] dio_init_sockcfg()"); if (gdd_dio_data->ker.state NEQ GDD_DIO_KER_DEAD) { TRACE_FUNCTION("[GDD] Instance 'SOCKCFG' already initialized"); return DRV_INITIALIZED; } init_dio_driver_instance(gdd_dio_data, drv_init->max_devices); return DRV_OK; } /* dio_init_sockcfg */ /* +------------------------------------------------------------------------------ | Function : dio_export_sockcfg +------------------------------------------------------------------------------ | Description : The function returns, through dio_func, a list of functions | that are exported by the SOCKCFG driver. DIO_IL calls this | function after dio_init_bat call return DRV_OK. | | Parameters : dio_func - Return as a pointer to the list of functions | exported by the driver. | | Return : none | +------------------------------------------------------------------------------ */ void dio_export_sockcfg ( T_DIO_FUNC ** dio_func ) { TRACE_FUNCTION("[GDD] dio_export_sockcfg()"); *dio_func = (T_DIO_FUNC*) &dio_func_bat; } /* dio_export_sockcfg */ #ifdef _SIMULATION_ /* Set the signal callback for all GDD drivers - for simulation only !!! */ GLOBAL void set_bat_driver_callback_for_simulation(T_DRV_CB_FUNC signal_callback) { gdd_dio_data_base[GDD_INST_BAT].signal_callback = signal_callback; gdd_dio_data_base[GDD_INST_APP].signal_callback = signal_callback; gdd_dio_data_base[GDD_INST_TCP].signal_callback = signal_callback; gdd_dio_data_base[GDD_INST_SOCK].signal_callback = signal_callback; gdd_dio_data_base[GDD_INST_SOCKCFG].signal_callback = signal_callback; } #endif /* _SIMULATION_ */