FreeCalypso > hg > fc-selenite
view src/g23m-aci/gdd_dio/gdd_dio_drv.c @ 165:2c82c413775f
gcc bootentry.S: SE J100 target support
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 06 Apr 2019 08:49:03 +0000 |
parents | d393cd9bb723 |
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_ */