/**
* \brief creates a mutex for inter-thread mutual exclusion for resource protection
*
*
*
* \param[in] p_handle Handle to a mutex control block
* \param[in] p_name Name of mutex
*
* \return e_SUCCESS on success, e_FAILURE on error
*
* \sa OS_mutex_delete, OS_mutex_lock, OS_mutex_unlock
* \note
*
* \warning
*/
e_ret_status OS_mutex_create(handle p_handle, const void *const p_name)
{
GateMutex_Params gateParams;
GateMutex_Handle mtx_handle = {0};
Error_Block eb;
GateMutex_Params_init(&gateParams);
Error_init(&eb);
gateParams.instance->name = "Default_Name";
mtx_handle = GateMutex_create(&gateParams, &eb);
if (NULL == mtx_handle) {
return e_FAILURE;
}
*(GateMutex_Handle *)p_handle = mtx_handle;
return e_SUCCESS;
}
/*
* ======== USBMSCHFatFsTiva_open ========
*/
USBMSCHFatFs_Handle USBMSCHFatFsTiva_open(USBMSCHFatFs_Handle handle,
unsigned char drv,
USBMSCHFatFs_Params *params)
{
unsigned int key;
DRESULT dresult;
FRESULT fresult;
USBMSCHFatFsTiva_Object *object = handle->object;
USBMSCHFatFsTiva_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
Task_Params taskParams;
Semaphore_Params semParams;
GateMutex_Params gateParams;
Hwi_Params hwiParams;
} paramsUnion;
/* Determine if the device was already opened */
key = Hwi_disable();
if (object->driveNumber != DRIVE_NOT_MOUNTED) {
Hwi_restore(key);
return (NULL);
}
/* Mark as being used */
object->driveNumber = drv;
Hwi_restore(key);
/* Store the USBMSCHFatFs parameters */
if (params == NULL) {
/* No params passed in, so use the defaults */
params = (USBMSCHFatFs_Params *) &USBMSCHFatFs_defaultParams;
}
/* Initialize the USB stack for host mode. */
USBStackModeSet(0, eUSBModeHost, NULL);
/* Register host class drivers */
USBHCDRegisterDrivers(0, usbHCDDriverList, numHostClassDrivers);
/* Open an instance of the MSC host driver */
object->MSCInstance = USBHMSCDriveOpen(0, USBMSCHFatFsTiva_cbMSCHandler);
if (!(object->MSCInstance)) {
Log_print0(Diags_USER1,"USBMSCHFatFs: Error initializing the MSC Host");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Create the Hwi object to service interrupts */
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.priority = hwAttrs->intPriority;
Hwi_construct(&(object->hwi), hwAttrs->intNum, USBMSCHFatFsTiva_hwiHandler,
&(paramsUnion.hwiParams), NULL);
/* Initialize USB power configuration */
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
/* Enable the USB stack */
USBHCDInit(0, object->memPoolHCD, HCDMEMORYPOOLSIZE);
/* RTOS primitives */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->semUSBConnected), 0, &(paramsUnion.semParams));
GateMutex_Params_init(&(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Library Access";
GateMutex_construct(&(object->gateUSBLibAccess), &(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Wait";
GateMutex_construct(&(object->gateUSBWait), &(paramsUnion.gateParams));
/*
* Note that serviceUSBHost() should not be run until the USB Stack has been
* initialized!!
*/
Task_Params_init(&(paramsUnion.taskParams));
/*
* If serviceTaskStackPtr is null, then Task_construct performs a
* Memory_alloc - requiring a Heap
*/
paramsUnion.taskParams.stack = params->serviceTaskStackPtr;
/*
* If service priority passed in is higher than what is configured by the
* Task module, then use the highest priority available.
*/
if (Task_numPriorities - 1 < params->servicePriority) {
paramsUnion.taskParams.priority = (Task_numPriorities - 1);
}
else {
paramsUnion.taskParams.priority = params->servicePriority;
}
/* If no stack size is passed in, then use the default task stack size */
if (params->serviceTaskStackSize) {
paramsUnion.taskParams.stackSize = params->serviceTaskStackSize;
}
else {
paramsUnion.taskParams.stackSize = Task_defaultStackSize;
}
Task_construct(&(object->taskHCDMain),USBMSCHFatFsTiva_serviceUSBHost,
&(paramsUnion.taskParams), NULL);
/* Register the new disk_*() functions */
dresult = disk_register(drv,
USBMSCHFatFsTiva_diskInitialize,
USBMSCHFatFsTiva_diskStatus,
USBMSCHFatFsTiva_diskRead,
USBMSCHFatFsTiva_diskWrite,
USBMSCHFatFsTiva_diskIOctl);
/* Check for drive errors */
if (dresult != RES_OK) {
Log_error0("USBMSCHFatFs: disk functions not registered");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Mount the FatFs (this function does not access the SDCard yet...) */
fresult = f_mount(drv, &(object->filesystem));
if (fresult != FR_OK) {
Log_error1("USBMSCHFatFs: drive %d not mounted", drv);
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
Log_print1(Diags_USER1, "USBMSCHFatFs: drive %d opened", drv);
return (handle);
}
/*
* ======== USBCDCMOUSE_init ========
*/
void USBCDCMOUSE_init(void)
{
Error_Block eb;
Semaphore_Params semParams;
GateMutex_Params gateParams;
Error_init(&eb);
/* RTOS primitives */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
semParams.__iprms.name = "semTxSerial";
semTxSerial = Semaphore_create(0, &semParams, &eb);
if (semTxSerial == NULL) {
System_abort("Can't create TX semaphore");
}
semParams.__iprms.name = "semRxSerial";
semRxSerial = Semaphore_create(0, &semParams, &eb);
if (semRxSerial == NULL) {
System_abort("Can't create RX semaphore");
}
semParams.__iprms.name = "semMouse";
semMouse = Semaphore_create(0, &semParams, &eb);
if (semMouse == NULL) {
System_abort("Can't create USB semaphore");
}
semParams.__iprms.name = "semUSBConnected";
semUSBConnected = Semaphore_create(0, &semParams, &eb);
if (semUSBConnected == NULL) {
System_abort("Can't create USB semaphore");
}
GateMutex_Params_init(&gateParams);
gateParams.__iprms.name = "gateTxSerial";
gateTxSerial = GateMutex_create(NULL, &eb);
if (gateTxSerial == NULL) {
System_abort("Can't create gate");
}
gateParams.__iprms.name = "gateRxSerial";
gateRxSerial = GateMutex_create(NULL, &eb);
if (gateRxSerial == NULL) {
System_abort("Can't create gate");
}
gateParams.__iprms.name = "gateMouse";
gateMouse = GateMutex_create(NULL, &eb);
if (gateMouse == NULL) {
System_abort("Can't create mouse gate");
}
gateParams.__iprms.name = "gateUSBWait";
gateUSBWait = GateMutex_create(NULL, &eb);
if (gateUSBWait == NULL) {
System_abort("Could not create USB Wait gate");
}
/* Initialize the USB module, enable events and connect if UBUS is present */
USB_setup(true, true);
}
