_mqx_uint _io_ras_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier
)
{ /* Body */
IODUN_DEV_STRUCT_PTR dev_ptr = _mem_alloc_system_zero(sizeof(IODUN_DEV_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (dev_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(dev_ptr,MEM_TYPE_IO_DUN_DEV);
dev_ptr->RECV = "CLIENTSERVER";
dev_ptr->SEND = "CLIENTCLIENT";
dev_ptr->RECV_SIZE = 12;
dev_ptr->SEND_SIZE = 12;
return (_io_dev_install(identifier,
_io_dun_open,
_io_dun_close,
_io_dun_read,
_io_dun_write,
_io_dun_ioctl,
dev_ptr));
} /* Endbody */
/*FUNCTION*****************************************************************
*
* Function Name : _adc_install
* Returned Value : _mqx_uint a task error code or MQX_OK
* Comments :
* Install a adc driver.
*
*END*********************************************************************/
_mqx_uint _io_adc_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier,
/* pointer to a HW specific structure */
pointer init
)
{ /* Body */
ADC_DRIVER_BUNDLE_PTR adc_driver_bundle;
_mqx_uint result;
if (NULL == (adc_driver_bundle = (ADC_DRIVER_BUNDLE_PTR) _mem_alloc(sizeof(ADC_DRIVER_BUNDLE))))
return ADC_ERROR_ALLOC; /* memory allocation error */
_mem_zero(adc_driver_bundle, sizeof(ADC_DRIVER_BUNDLE));
if (IO_OK == (result = _adc_hw_install(identifier, adc_driver_bundle, init)))
if (IO_OK == (result = _adt_hw_install(identifier, adc_driver_bundle, init)))
result = _io_dev_install(identifier,
_adc_open,
_adc_close,
_adc_read,
_adc_write,
_adc_ioctl,
adc_driver_bundle);
if (result != IO_OK)
_mem_free(adc_driver_bundle);
return result;
} /* Endbody */
uint_32 _io_pccardflexbus_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier,
/* [IN] Pointer to initialization info. */
PCCARDFLEXBUS_INIT_STRUCT_CPTR init_ptr
)
{ /* Body */
IO_PCCARDFLEXBUS_STRUCT_PTR info_ptr;
/* Allocate memory for the PCCARD state structure */
info_ptr = (IO_PCCARDFLEXBUS_STRUCT_PTR)_mem_alloc_system_zero((uint_32)sizeof(IO_PCCARDFLEXBUS_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (!info_ptr) {
return MQX_OUT_OF_MEMORY;
} /* Endif */
#endif
info_ptr->INIT_DATA = *init_ptr;
return (_io_dev_install(identifier,
_io_pccardflexbus_open,
_io_pccardflexbus_close,
NULL,
NULL,
_io_pccardflexbus_ioctl,
(pointer)info_ptr));
} /* Endbody */
uint_32 _io_apcflash_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier
)
{ /* Body */
IO_PCFLASH_STRUCT_PTR info_ptr;
/* Allocate memory for the state structure */
info_ptr = _mem_alloc_system_zero((uint_32)sizeof(IO_PCFLASH_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (info_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(info_ptr,MEM_TYPE_IO_PCFLASH);
/* Fill in the state structure with the info we know */
info_ptr->DRIVE = 0; /* always use ATA device 0 */
info_ptr->SECTOR_SIZE = ATA_SECTOR_SIZE;
info_ptr->TEMP_BUFF_PTR = NULL;
info_ptr->ERROR_CODE = IO_OK;
_lwsem_create(&info_ptr->LWSEM, 1L);
return (_io_dev_install(identifier,
(_mqx_int (_CODE_PTR_)(MQX_FILE_PTR, char _PTR_, char _PTR_))_io_apcflash_open,
(_mqx_int (_CODE_PTR_)(MQX_FILE_PTR)) _io_apcflash_close,
(_mqx_int (_CODE_PTR_)(MQX_FILE_PTR, char_ptr, _mqx_int)) _io_apcflash_read,
(_mqx_int (_CODE_PTR_)(MQX_FILE_PTR, char_ptr, _mqx_int)) _io_apcflash_write,
(_mqx_int (_CODE_PTR_)(MQX_FILE_PTR, _mqx_uint, pointer)) _io_apcflash_ioctl,
(pointer)info_ptr));
} /* Endbody */
static _mqx_uint _io_serial_mix_install
(
/* [IN] A string that identifies the device for fopen */
char *identifier,
/* [IN] The I/O init function */
_mqx_uint (_CODE_PTR_ init)(void *, char *),
/* [IN] The enable interrupts function */
_mqx_uint (_CODE_PTR_ enable_ints)(void *),
/* [IN] The I/O de-init function */
_mqx_uint (_CODE_PTR_ deinit)(void *, void *),
/* [IN] The output function */
void (_CODE_PTR_ putc)(void *, char),
/* [IN] The I/O ioctl function */
_mqx_uint (_CODE_PTR_ ioctl)(void *, _mqx_uint, void *),
/* [IN] The I/O init data pointer */
void *init_data_ptr,
/* [IN] The I/O queue size to use */
_mqx_uint oqueue_size,
_mqx_uint iqueue_size
)
{ /* Body */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
uint32_t result;
int_io_dev_ptr = _mem_alloc_system_zero(
(_mem_size)sizeof(IO_SERIAL_INT_DEVICE_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (int_io_dev_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(int_io_dev_ptr,MEM_TYPE_IO_SERIAL_INT_DEVICE_STRUCT);
int_io_dev_ptr->DEV_INIT = init;
int_io_dev_ptr->DEV_ENABLE_INTS = enable_ints;
int_io_dev_ptr->DEV_DEINIT = deinit;
int_io_dev_ptr->DEV_PUTC = putc;
int_io_dev_ptr->DEV_IOCTL = ioctl;
int_io_dev_ptr->DEV_INIT_DATA_PTR = init_data_ptr;
int_io_dev_ptr->QUEUE_SIZE = oqueue_size;
int_io_dev_ptr->OQUEUE_SIZE = oqueue_size;
int_io_dev_ptr->IQUEUE_SIZE = iqueue_size;
result = _io_dev_install(identifier,
_io_serial_mix_open, _io_serial_mix_close,
_io_serial_mix_read, _io_serial_mix_write,
_io_serial_mix_ioctl,
(void *)int_io_dev_ptr);
return result;
} /* Endbody */
int_32 _io_socket_install
(
char_ptr identifier
)
{ /* Body */
return _io_dev_install(identifier,
_io_socket_open,
_io_socket_close,
_io_socket_read,
_io_socket_write,
#if MQX_VERSION < 250
(int_32(_CODE_PTR_)(MQX_FILE_PTR, uint_32, uint_32_ptr))
#endif
_io_socket_ioctl,
NULL );
} /* Endbody */
_mqx_uint _io_null_install
(
/* [IN] A string that identifies the device for fopen */
char *identifier
)
{
_mqx_uint result;
result = _io_dev_install(
identifier,
_io_null_open,
_io_null_close,
_io_null_read,
_io_null_write,
_io_null_ioctl,
NULL
);
return result;
}
_mqx_uint _io_mem_install
(
/* [IN] A string that identifies the device for fopen */
char *identifier,
/* [IN] the address of the fdv_ram */
void *base_address,
/* [IN] the total size of the device */
_file_size size
)
{
IO_MEM_STRUCT_PTR handle_ptr;
#if (MAX_FILE_SIZE > MAX_MEM_SIZE)
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (size > MAX_MEM_SIZE) {
return(MQX_OUT_OF_MEMORY);
}
#endif
#endif
handle_ptr = (IO_MEM_STRUCT_PTR)
_mem_alloc_system_zero((_mem_size)sizeof(IO_MEM_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (handle_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
}
#endif
_mem_set_type(handle_ptr,MEM_TYPE_IO_MEM_STRUCT);
if (base_address == NULL) {
base_address = _mem_alloc_system((_mem_size)size);
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (base_address == NULL) {
_mem_free(handle_ptr);
return(MQX_OUT_OF_MEMORY);
}
#endif
_mem_set_type(base_address,MEM_TYPE_IO_MEM_DATA);
/* Indicate the the RAM drive was allocated from kernel memory */
handle_ptr->TYPE = MEM_TYPE_DYNAMIC;
} else {
/* Indicate the the RAM drive was statically allocated (global mem) */
handle_ptr->TYPE = MEM_TYPE_STATIC;
}
handle_ptr->BASE_ADDR = base_address;
handle_ptr->SIZE = size;
_lwsem_create(&handle_ptr->LWSEM, 1);
return (_io_dev_install(
identifier,
_io_mem_open,
_io_mem_close,
_io_mem_read,
_io_mem_write,
_io_mem_ioctl,
(void *)handle_ptr
));
}
_mqx_uint _io_serial_int_install
(
/* [IN] A string that identifies the device for fopen */
char_ptr identifier,
/* [IN] The I/O init function */
_mqx_uint (_CODE_PTR_ init)(pointer, char _PTR_),
/* [IN] The enable interrupts function */
_mqx_uint (_CODE_PTR_ enable_ints)(pointer),
/* [IN] The I/O de-init function */
_mqx_uint (_CODE_PTR_ deinit)(pointer, pointer),
/* [IN] The output function */
void (_CODE_PTR_ putc)(pointer, char),
/* [IN] The I/O ioctl function */
_mqx_uint (_CODE_PTR_ ioctl)(pointer, _mqx_uint, pointer),
/* [IN] The I/O init data pointer */
pointer init_data_ptr,
/* [IN] The I/O queue size to use */
_mqx_uint queue_size
)
{ /* Body */
IO_SERIAL_INT_DEVICE_STRUCT_PTR int_io_dev_ptr;
uint_32 result;
int_io_dev_ptr = _mem_alloc_system_zero(
(_mem_size)sizeof(IO_SERIAL_INT_DEVICE_STRUCT));
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (int_io_dev_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(int_io_dev_ptr,MEM_TYPE_IO_SERIAL_INT_DEVICE_STRUCT);
int_io_dev_ptr->DEV_INIT = init;
int_io_dev_ptr->DEV_ENABLE_INTS = enable_ints;
int_io_dev_ptr->DEV_DEINIT = deinit;
int_io_dev_ptr->DEV_PUTC = putc;
int_io_dev_ptr->DEV_IOCTL = ioctl;
int_io_dev_ptr->DEV_INIT_DATA_PTR = init_data_ptr;
int_io_dev_ptr->QUEUE_SIZE = queue_size;
result = _io_dev_install(identifier,
_io_serial_int_open, _io_serial_int_close,
_io_serial_int_read, _io_serial_int_write,
_io_serial_int_ioctl,
(pointer)int_io_dev_ptr);
#if MQX_ENABLE_LOW_POWER
if (MQX_OK == result)
{
LPM_REGISTRATION_STRUCT registration;
registration.CLOCK_CONFIGURATION_CALLBACK = _io_serial_int_clock_configuration_callback;
registration.OPERATION_MODE_CALLBACK = _io_serial_int_operation_mode_callback;
registration.DEPENDENCY_LEVEL = BSP_LPM_DEPENDENCY_LEVEL_SERIAL_INT;
result = _lpm_register_driver (®istration, int_io_dev_ptr, &(int_io_dev_ptr->LPM_INFO.REGISTRATION_HANDLE));
if (MQX_OK == result)
{
_lwsem_create (&(int_io_dev_ptr->LPM_INFO.LOCK), 1);
int_io_dev_ptr->LPM_INFO.FLAGS = 0;
}
}
#endif
return result;
} /* Endbody */
