/*
* ======== WiFiCC3100_open ========
*/
WiFi_Handle WiFiCC3100_open(WiFi_Handle handle, unsigned int spiIndex,
WiFi_evntCallback evntCallback, WiFi_Params *params)
{
unsigned int key;
WiFiCC3100_Object *object = handle->object;
WiFiCC3100_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
#if !defined(MSP430WARE)
Hwi_Params hwiParams;
#endif
Semaphore_Params semParams;
} paramsUnion;
key = Hwi_disable();
if (object->isOpen) {
Hwi_restore(key);
Log_warning0("WiFi Hwi already in use.");
return (NULL);
}
object->isOpen = true;
Hwi_restore(key);
/* Construct semaphores to block read/write transactions. */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
paramsUnion.semParams.instance->name = "WiFi.writeSemaphore";
Semaphore_construct(&(object->writeSemaphore), 0, &(paramsUnion.semParams));
paramsUnion.semParams.instance->name = "WiFi.readSemaphore";
Semaphore_construct(&(object->readSemaphore), 0, &(paramsUnion.semParams));
#if !defined(MSP430WARE)
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.arg = (UArg) handle;
paramsUnion.hwiParams.enableInt = false;
/* Hwi_construct cannot fail, use NULL instead of an Error Block */
Hwi_construct(&(object->wifiHwi), hwAttrs->irqIntNum,
WiFiCC3100_hostIntHandler, &(paramsUnion.hwiParams), NULL);
#endif
#if defined(MSP430WARE) || defined(MSP432WARE)
MAP_GPIO_clearInterruptFlag(hwAttrs->irqPort, hwAttrs->irqPin);
MAP_GPIO_enableInterrupt(hwAttrs->irqPort, hwAttrs->irqPin);
#else
GPIOIntClear(hwAttrs->irqPort, hwAttrs->irqPin);
GPIOIntEnable(hwAttrs->irqPort, hwAttrs->irqPin);
#endif
/* Store SPI interface parameters */
object->spiIndex = spiIndex;
object->bitRate = params->bitRate;
return (handle);
}
/*******************************************************************************
* @fn bspI2cInit
*
* @brief Initialize the RTOS I2C driver (must be called only once)
*
* @param none
*
* @return none
*/
void bspI2cInit(void)
{
Semaphore_Params semParamsMutex;
// Create protection semaphore
Semaphore_Params_init(&semParamsMutex);
semParamsMutex.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&mutex, 1, &semParamsMutex);
// Reset the I2C controller
HapiResetPeripheral(PRCM_PERIPH_I2C0);
I2C_init();
I2C_Params_init(&i2cParams);
i2cParams.bitRate = I2C_400kHz;
i2cHandle = I2C_open(Board_I2C, &i2cParams);
// Initialize local variables
slaveAddr = 0xFF;
interface = BSP_I2C_INTERFACE_0;
if (i2cHandle == NULL)
{
Task_exit();
}
}
void bspI2cInit(void)
{
Semaphore_Params semParamsMutex;
// Create protection semaphore
Semaphore_Params_init(&semParamsMutex);
semParamsMutex.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&mutex, 1, &semParamsMutex);
// Reset the I2C controller
HWREG(PRCM_BASE + PRCM_O_RESETI2C) = PRCM_RESETI2C_I2C;
I2C_init();
I2C_Params_init(&I2CParams);
I2CParams.bitRate = I2C_400kHz;
I2Chandle = I2C_open(Board_I2C, &I2CParams);
// Initialize local variables
slaveAddr = 0xFF;
interface = BSP_I2C_INTERFACE_0;
#ifdef POWER_SAVING
checkI2cConstraint = false;
#endif
/*
if (I2Chandle == NULL) {
while(1) {
// wait here for ever
}
}
*/
}
/*
* ======== GateMutex_Instance_init ========
*/
Void GateMutex_Instance_init(GateMutex_Object *obj,
const GateMutex_Params *params)
{
Semaphore_Handle sem;
sem = GateMutex_Instance_State_sem(obj);
Semaphore_construct(Semaphore_struct(sem), 1, NULL);
obj->owner = NULL;
}
/*
* ======== Lck_Instance_init ========
*/
Void Lck_Instance_init(Lck_Object *obj, const Lck_Params *params)
{
Semaphore_Handle sem;
sem = Lck_Instance_State_sem(obj);
Semaphore_construct(Semaphore_struct(sem), 1, NULL);
obj->value = 0;
obj->owner = NULL;
}
/*
* ======== ThreadSupport_Instance_init ========
*/
Int ThreadSupport_Instance_init(ThreadSupport_Handle obj,
ThreadSupport_RunFxn fxn, const ThreadSupport_Params* params,
Error_Block* eb)
{
Task_Params tpars;
Semaphore_Handle bios6sem;
bios6sem = ThreadSupport_Instance_State_join_sem(obj);
Task_Params_init(&tpars);
tpars.arg0 = (UArg)obj;
if (params->stackSize != 0) {
tpars.stackSize = params->stackSize;
}
tpars.env = obj;
tpars.instance->name = params->instance->name;
if (params->osPriority != ThreadSupport_INVALID_OS_PRIORITY) {
tpars.priority = params->osPriority;
}
else {
if (params->priority == ThreadSupport_Priority_LOWEST) {
tpars.priority = ThreadSupport_lowestPriority;
}
else if (params->priority == ThreadSupport_Priority_BELOW_NORMAL) {
tpars.priority = ThreadSupport_belowNormalPriority;
}
else if (params->priority == ThreadSupport_Priority_NORMAL) {
tpars.priority = ThreadSupport_normalPriority;
}
else if (params->priority == ThreadSupport_Priority_ABOVE_NORMAL) {
tpars.priority = ThreadSupport_aboveNormalPriority;
}
else if (params->priority == ThreadSupport_Priority_HIGHEST) {
tpars.priority = ThreadSupport_highestPriority;
}
else {
Error_raise(eb, ThreadSupport_E_priority, params->priority, 0);
return (ThreadSupport_PRI_FAILURE);
}
}
obj->tls = params->tls;
obj->startFxn = fxn;
obj->startFxnArg = params->arg;
Semaphore_construct(Semaphore_struct(bios6sem), 0, NULL);
obj->task = Task_create(&ThreadSupport_runStub, &tpars, eb);
if (Error_check(eb)) {
return (ThreadSupport_TASK_FAILURE);
}
return (0);
}
/*
* ======== SemProcessSupport_Instance_init ========
*/
Void SemProcessSupport_Instance_init(SemProcessSupport_Handle sem,
Int count, Int key, const SemProcessSupport_Params* params)
{
Semaphore_Handle bios6sem;
Semaphore_Params semParams;
Semaphore_Params_init(&semParams);
semParams.mode = (Semaphore_Mode)params->mode;
bios6sem = SemProcessSupport_Instance_State_sem(sem);
Semaphore_construct(
Semaphore_struct(bios6sem), count, &semParams);
}
/*
* ======== SemProcessSupport_Instance_init ========
*/
Void SemProcessSupport_Instance_init(SemProcessSupport_Handle sem,
Int count, Int key, const SemProcessSupport_Params* params)
{
Semaphore_Handle bios6sem;
Semaphore_Params semParams;
Semaphore_Params_init(&semParams);
if (params->mode == ISemaphore_Mode_COUNTING) {
semParams.mode = Semaphore_Mode_COUNTING;
}
else {
semParams.mode = Semaphore_Mode_BINARY;
}
bios6sem = SemProcessSupport_Instance_State_sem(sem);
Semaphore_construct(
Semaphore_struct(bios6sem), count, &semParams);
}
/*******************************************************************************
* @fn devpkLcdOpen
*
* @brief Initialize the LCD
*
* @descr Initializes the pins used by the LCD, creates resource access
* protection semaphore, turns on the LCD device, initializes the
* frame buffer, initializes to white background/dark foreground,
* and finally clears the display.
*
* @return true if success
*/
bool devpkLcdOpen(void)
{
hLcdPin = PIN_open(&pinState, BoardDevpackLCDPinTable);
if (hLcdPin != 0)
{
display.bg = ClrBlack;
display.fg = ClrWhite;
// Open the SPI driver
bspSpiOpen();
// Exclusive access
Semaphore_Params_init(&semParamsLCD);
semParamsLCD.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&semLCD, 1, &semParamsLCD);
hSemLCD = Semaphore_handle(&semLCD);
// Turn on the display
PIN_setOutputValue(hLcdPin,Board_DEVPK_LCD_DISP,1);
// Graphics library init
GrContextInit(&g_sContext, &g_sharp96x96LCD);
// Graphics properties
GrContextForegroundSet(&g_sContext, display.fg);
GrContextBackgroundSet(&g_sContext, display.bg);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
// Clear display
GrClearDisplay(&g_sContext);
GrFlush(&g_sContext);
}
return hLcdPin != 0;
}
int main(void) {
//Initialize pins, turn on GPIO module
PIN_init(BoardGpioInitTable);
//Initialize task
Task_Params params;
Task_Params_init(¶ms);
params.priority = TASK_PRI;
params.stackSize = TASK_STACK_SIZE;
params.stack = taskStack;
Task_construct(&taskStruct, taskFxn, ¶ms, NULL);
// Construct semaphore used for pending in task
Semaphore_Params sParams;
Semaphore_Params_init(&sParams);
sParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&sem, 0, &sParams);
hSem = Semaphore_handle(&sem);
BIOS_start();
}
/*
* ======== main ========
*/
Void main()
{
PIN_init(BoardGpioInitTable);
//enable iCache prefetching
VIMSConfigure(VIMS_BASE, TRUE, TRUE);
// Enable cache
VIMSModeSet(VIMS_BASE, VIMS_MODE_ENABLED);
#ifndef POWER_SAVING
/* Set constraints for Standby, powerdown and idle mode */
Power_setConstraint(Power_SB_DISALLOW);
Power_setConstraint(Power_IDLE_PD_DISALLOW);
#endif // POWER_SAVING
//Initialize task
Task_Params params;
Task_Params_init(¶ms);
params.priority = TASK_PRI;
params.stackSize = TASK_STACK_SIZE;
params.stack = taskStack;
//semaphore init
Semaphore_Params sParams;
Semaphore_Params_init(&sParams);
sParams.mode = Semaphore_Mode_BINARY;
/* Initialize ICall module */
ICall_init();
/* Start tasks of external images - Priority 5 */
ICall_createRemoteTasks();
/* Kick off profile - Priority 3 */
GAPRole_createTask();
SimpleBLEPeripheral_createTask();
//Contruct task
Task_construct(&taskStruct, taskFxn, ¶ms, NULL);
// Construct semaphore used for pending in task ADC
Semaphore_construct(&sem, 0, &sParams);
hSem = Semaphore_handle(&sem);
#ifdef FEATURE_OAD_BIM
{
uint8_t counter;
uint32_t *vectorTable = (uint32_t*) 0x20000000;
uint32_t *flashVectors = &__vector_table;
// Write image specific interrupt vectors into RAM vector table.
for(counter = 0; counter < 15; ++counter)
{
*vectorTable++ = *flashVectors++;
}
}
#endif //FEATURE_OAD_BIM
/* enable interrupts and start SYS/BIOS */
BIOS_start();
}
/*!
* @brief Function to initialize the CC26XX SPI peripheral specified by the
* particular handle. The parameter specifies which mode the SPI
* will operate.
*
* The function will set a dependency on it power domain, i.e. power up the
* module and enable the clock. The IOs are allocated. Neither the SPI nor UDMA module
* will be enabled.
*
* @pre SPI controller has been initialized.
* Calling context: Task
*
* @param handle A SPI_Handle
*
* @param params Pointer to a parameter block, if NULL it will use
* default values
*
* @return A SPI_Handle on success or a NULL on an error or if it has been
* already opened
*
* @sa SPICC26XXDMA_close()
*/
SPI_Handle SPICC26XXDMA_open(SPI_Handle handle, SPI_Params *params)
{
/* Use union to save on stack allocation */
union {
Semaphore_Params semParams;
Hwi_Params hwiParams;
} paramsUnion;
SPI_Params defaultParams;
SPICC26XX_Object *object;
SPICC26XX_HWAttrs const *hwAttrs;
unsigned int key;
/* Get the pointer to the object and hwAttrs */
object = handle->object;
hwAttrs = handle->hwAttrs;
/* Disable preemption while checking if the SPI is open. */
key = Hwi_disable();
/* Check if the SPI is open already with the base addr. */
if (object->isOpen == true) {
Hwi_restore(key);
Log_warning1("SPI:(%p) already in use.", hwAttrs->baseAddr);
return (NULL);
}
/* Mark the handle as being used */
object->isOpen = true;
Hwi_restore(key);
/* If params are NULL use defaults */
if (params == NULL) {
/* No params passed in, so use the defaults */
SPI_Params_init(&defaultParams);
params = &defaultParams;
}
Assert_isTrue((params->dataSize >= 4) &&
(params->dataSize <= 16), NULL);
/* Initialize the SPI object */
object->currentTransaction = NULL;
object->bitRate = params->bitRate;
object->dataSize = params->dataSize;
object->frameFormat = params->frameFormat;
object->mode = params->mode;
object->transferMode = params->transferMode;
object->transferTimeout = params->transferTimeout;
object->returnPartial = false;
#ifdef SPICC26XXDMA_WAKEUP_ENABLED
object->wakeupCallbackFxn = NULL;
#endif
/* Determine if we need to use an 8-bit or 16-bit framesize for the DMA */
object->frameSize = (params->dataSize < 9) ? SPICC26XXDMA_8bit : SPICC26XXDMA_16bit;
Log_print2(Diags_USER2,"SPI:(%p) DMA buffer incrementation size: %s",
hwAttrs->baseAddr,
(object->frameSize) ? (UArg)"16-bit" : (UArg)"8-bit");
/* Register power dependency - i.e. power up and enable clock for SPI. */
Power_setDependency(hwAttrs->powerMngrId);
/* Configure the hardware module */
SPICC26XXDMA_initHw(handle);
/* CSN is initialized using hwAttrs initially, but can be re-configured later */
object->csnPin = hwAttrs->csnPin;
/* Configure IOs after hardware has been initialized so that IOs aren't */
/* toggled unnecessary and make sure it was successful */
if (!SPICC26XXDMA_initIO(handle)) {
/* Trying to use SPI driver when some other driver or application
* has already allocated these pins, error! */
Log_warning0("Could not allocate SPI pins, already in use.");
/* Release power dependency - i.e. potentially power down serial domain. */
Power_releaseDependency(hwAttrs->powerMngrId);
/* Mark the module as available */
key = Hwi_disable();
object->isOpen = false;
Hwi_restore(key);
/* Signal back to application that SPI driver was not succesfully opened */
return (NULL);
}
/* Create the Hwi for this SPI peripheral. */
Hwi_Params_init(¶msUnion.hwiParams);
paramsUnion.hwiParams.arg = (UArg) handle;
Hwi_construct(&(object->hwi), (int) hwAttrs->intNum, SPICC26XXDMA_hwiFxn, ¶msUnion.hwiParams, NULL);
/* Check the transfer mode */
if (object->transferMode == SPI_MODE_BLOCKING) {
Log_print1(Diags_USER2, "SPI DMA:(%p) in SPI_MODE_BLOCKING mode",
hwAttrs->baseAddr);
/* Create a semaphore to block task execution for the duration of the
* SPI transfer */
Semaphore_Params_init(¶msUnion.semParams);
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->transferComplete), 0, ¶msUnion.semParams);
/* Store internal callback function */
object->transferCallbackFxn = SPICC26XXDMA_transferCallback;
}
else {
Log_print1(Diags_USER2, "SPI DMA:(%p) in SPI_MODE_CALLBACK mode", hwAttrs->baseAddr);
/* Check to see if a callback function was defined for async mode */
Assert_isTrue(params->transferCallbackFxn != NULL, NULL);
/* Save the callback function pointer */
object->transferCallbackFxn = params->transferCallbackFxn;
}
/* Declare the dependency on the UDMA driver */
object->udmaHandle = UDMACC26XX_open();
/* Configure PIN driver for CSN callback in optional RETURN_PARTIAL slave mode */
/* and/or optional wake up on CSN assert slave mode */
if (object->mode == SPI_SLAVE) {
PIN_registerIntCb(object->pinHandle, SPICC26XXDMA_csnCallback);
PIN_setUserArg(object->pinHandle, (UArg) handle);
}
Log_print1(Diags_USER1, "SPI:(%p) opened", hwAttrs->baseAddr);
/* Register notification functions */
#ifdef SPICC26XXDMA_WAKEUP_ENABLED
Power_registerNotify(&object->spiPreObj, Power_ENTERING_STANDBY, (Fxn)spiPreNotify, (UInt32)handle, NULL );
#endif
Power_registerNotify(&object->spiPostObj, Power_AWAKE_STANDBY, (Fxn)spiPostNotify, (UInt32)handle, NULL );
return (handle);
}
/*
* ======== 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);
}
/*
* ======== pthread_create ========
*/
int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
void *(*startroutine)(void *), void *arg)
{
Semaphore_Params semParams;
Task_Params taskParams;
pthread_Obj *thread = NULL;
Error_Block eb;
pthread_attr_t *pAttr;
Error_init(&eb);
Task_Params_init(&taskParams);
*newthread = NULL;
thread = (pthread_Obj *)Memory_alloc(Task_Object_heap(),
sizeof(pthread_Obj), 0, &eb);
if (thread == NULL) {
return (ENOMEM);
}
pAttr = (attr == NULL) ? &defaultPthreadAttrs : (pthread_attr_t *)attr;
taskParams.priority = pAttr->priority;
taskParams.stack = pAttr->stack;
taskParams.stackSize = pAttr->stacksize + pAttr->guardsize;
/* Save the function in arg0 for ROV */
taskParams.arg0 = (UArg)startroutine;
taskParams.arg1 = (UArg)thread;
taskParams.env = arg;
taskParams.priority = -1;
thread->detached = (pAttr->detachstate == PTHREAD_CREATE_JOINABLE) ? 0 : 1;
thread->fxn = startroutine;
thread->joinThread = NULL;
thread->cancelState = PTHREAD_CANCEL_ENABLE;
thread->cancelPending = 0;
thread->priority = pAttr->priority;
thread->cleanupList = NULL;
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
thread->blockedMutex = NULL;
Queue_elemClear((Queue_Elem *)thread);
Queue_construct(&(thread->mutexList), NULL);
#endif
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(thread->joinSem), 0, &semParams);
thread->task = Task_create((Task_FuncPtr)_pthread_runStub,
&taskParams, &eb);
if (thread->task == NULL) {
Semaphore_destruct(&(thread->joinSem));
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
return (ENOMEM);
}
*newthread = (pthread_t)thread;
Task_setPri(thread->task, pAttr->priority);
return (0);
}
/*!
* @brief Function to initialize a given I2C CC26XX peripheral specified by the
* particular handle. The parameter specifies which mode the I2C
* will operate.
*
* After calling the open function, the I2C is enabled. If there is no active
* I2C transactions, the device can enter standby.
*
* @pre The I2CCC26XX_Config structure must exist and be persistent before this
* function can be called. I2CCC26XX has been initialized with I2CCC26XX_init().
* Calling context: Task
*
* @param handle An I2C_Handle
*
* @param params Pointer to a parameter block, if NULL it will use default values.
*
* @return A I2C_Handle on success, or a NULL on an error or if it has been
* already opened.
*
* @note The generic I2C API should be used when accessing the I2CCC26XX.
*
* @sa I2CCC26XX_close(), I2CCC26XX_init(), I2C_open(), I2C_init()
*/
I2C_Handle I2CCC26XX_open(I2C_Handle handle, I2C_Params *params)
{
union {
Hwi_Params hwiParams;
Semaphore_Params semParams;
} paramsUnion;
UInt key;
I2C_Params i2cParams;
I2CCC26XX_Object *object;
I2CCC26XX_HWAttrs const *hwAttrs;
/* Get the pointer to the object and hwAttrs */
object = handle->object;
hwAttrs = handle->hwAttrs;
/* Determine if the device index was already opened */
key = Hwi_disable();
if(object->isOpen == true){
Hwi_restore(key);
return (NULL);
}
/* Mark the handle as being used */
object->isOpen = true;
Hwi_restore(key);
/* Store the I2C parameters */
if (params == NULL) {
/* No params passed in, so use the defaults */
I2C_Params_init(&i2cParams);
params = &i2cParams;
}
/* Configure the IOs early to ensure allocation is allowed (PIN driver and IO config setup only).*/
if (I2CCC26XX_initIO(handle, params->custom)) {
/* If initialization and allocation of IOs failed, log error and return NULL pointer */
Log_print1(Diags_USER1, "I2C: Pin allocation failed, open did not succeed (baseAddr:0x%x)", hwAttrs->baseAddr);
return (NULL);
}
/* Save parameters */
object->transferMode = params->transferMode;
object->transferCallbackFxn = params->transferCallbackFxn;
object->bitRate = params->bitRate;
/* Create Hwi object for this I2C peripheral */
Hwi_Params_init(¶msUnion.hwiParams);
paramsUnion.hwiParams.arg = (UArg)handle;
Hwi_construct(&(object->hwi), hwAttrs->intNum, I2CCC26XX_hwiFxn,
¶msUnion.hwiParams, NULL);
/*
* Create thread safe handles for this I2C peripheral
* Semaphore to provide exclusive access to the I2C peripheral
*/
Semaphore_Params_init(¶msUnion.semParams);
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->mutex), 1, ¶msUnion.semParams);
/*
* Store a callback function that posts the transfer complete
* semaphore for synchronous mode
*/
if (object->transferMode == I2C_MODE_BLOCKING) {
/*
* Semaphore to cause the waiting task to block for the I2C
* to finish
*/
Semaphore_construct(&(object->transferComplete), 0, ¶msUnion.semParams);
/* Store internal callback function */
object->transferCallbackFxn = I2CCC26XX_blockingCallback;
}
else {
/* Check to see if a callback function was defined for async mode */
Assert_isTrue(object->transferCallbackFxn != NULL, NULL);
}
/* Specify the idle state for this I2C peripheral */
object->mode = I2CCC26XX_IDLE_MODE;
/* Clear the head pointer */
object->headPtr = NULL;
object->tailPtr = NULL;
/* Power on the I2C module */
Power_setDependency(hwAttrs->powerMngrId);
/* Initialize the I2C hardware module */
I2CCC26XX_initHw(handle);
/* Register notification functions */
Power_registerNotify(&object->i2cPostObj, Power_AWAKE_STANDBY, (Fxn)i2cPostNotify, (UInt32)handle, NULL );
Log_print1(Diags_USER1, "I2C: Object created 0x%x", hwAttrs->baseAddr);
/* Return the address of the handle */
return (handle);
}
Int SystemCfg_create(const SystemCfg_Params *params, SystemCfg_Handle *handleP)
{
Int status, bufSize;
Error_Block eb;
SystemCfg_Object * obj;
Semaphore_Params semParams;
Log_print0(Diags_ENTRY, "--> "FXNN": ()");
/* initialize local vars */
status = 0;
Error_init(&eb);
*handleP = (SystemCfg_Handle)NULL;
/* allocate the object */
obj = (SystemCfg_Handle)xdc_runtime_Memory_calloc(NULL,
sizeof(SystemCfg_Object), sizeof(Int), &eb);
if (obj == NULL) {
Log_error1(FXNN": out of memory: size=%u", sizeof(SystemCfg_Object));
status = SystemCfg_E_NOMEMORY;
goto leave;
}
/* object-specific initialization */
obj->remoteProcName = NULL;
obj->remoteProcId = MultiProc_INVALIDID;
obj->semH = NULL;
obj->rcmHeapH = NULL;
/* initialize structures to zero */
memset((Void *)&obj->semObj, 0, sizeof(Semaphore_Struct));
/* store the remote processor name */
bufSize = strlen(params->remoteProcName) + 1;
obj->remoteProcName = (String)xdc_runtime_Memory_calloc(NULL,
bufSize, sizeof(String), &eb);
if (obj == NULL) {
Log_error1(FXNN": out of memory: size=%u", bufSize);
status = SystemCfg_E_NOMEMORY;
goto leave;
}
strcpy(obj->remoteProcName, params->remoteProcName);
/* lookup the remote processor id */
obj->remoteProcId = MultiProc_getId(obj->remoteProcName);
/* create sync object used for synchronizing with remote core */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_COUNTING;
Semaphore_construct(&obj->semObj, 0, &semParams);
obj->semH = Semaphore_handle(&obj->semObj);
/* add object to module list for register hook */
List_putHead(Mod_objList, &obj->link);
/* success, return opaque pointer */
*handleP = (SystemCfg_Handle)obj;
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== Server_setup ========
*
* 1. create semaphore object
* 2. register notify callback
* 3. wait until remote core has also registered notify callback
* 4. create local & shared resources
* 5. send resource ready event
* 6. wait for remote resource ready event
* 7. open remote resources
* 8. handshake the ready event
*/
Int Server_setup(Void)
{
Int status;
UInt32 event;
Semaphore_Params semParams;
RcmServer_Params rcmServerP;
Log_print0(Diags_ENTRY | Diags_INFO, "--> Server_setup:");
/*
* 1. create semaphore object
*/
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_COUNTING;
Semaphore_construct(&Module.semS, 0, &semParams);
Module.semH = Semaphore_handle(&Module.semS);
/*
* 2. register notify callback
*/
status = Notify_registerEventSingle(Module.hostProcId, Module.lineId,
Module.eventId, Server_notifyCB, (UArg)&Module);
if (status < 0) {
goto leave;
}
/*
* 3. wait until remote core has also registered notify callback
*/
do {
status = Notify_sendEvent(Module.hostProcId, Module.lineId,
Module.eventId, App_CMD_NOP, TRUE);
if (status == Notify_E_EVTNOTREGISTERED) {
Task_sleep(200); /* ticks */
}
} while (status == Notify_E_EVTNOTREGISTERED);
if (status < 0) {
goto leave;
}
/*
* 4. create local & shared resources (to be opened by remote processor)
*/
/*
* 5. send resource ready event
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId, Module.eventId,
App_CMD_RESRDY, TRUE);
if (status < 0) {
goto leave;
}
/*
* 6. wait for remote resource ready event
*/
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_RESRDY);
/*
* 7. open remote resources
*/
/* open the rcm heap */
status = HeapBufMP_open(Global_RcmClientHeapName, &Module.heapH);
if (status < 0) {
Log_error1("Server_setup: HeapBufMP_open() returned error %d",
(IArg)status);
goto leave;
}
/* register the rcm heap with MessageQ */
status = MessageQ_registerHeap((Ptr)(Module.heapH), Global_RcmClientHeapId);
if (status < 0) {
Log_error1("Server_setup: MessageQ_restierHeap() returned error %d",
(IArg)status);
goto leave;
}
/* initialize RcmServer create params */
RcmServer_Params_init(&rcmServerP);
rcmServerP.fxns.length = Server_fxnTab.length;
rcmServerP.fxns.elem = Server_fxnTab.elem;
/* create the RcmServer instance */
status = RcmServer_create(Global_RcmServerName, &rcmServerP,
&Module.rcmServerH);
if (status < 0) {
Log_error1("Server_setup: RcmServer_create() returned error %d",
(IArg)status);
goto leave;
}
/* start the server */
RcmServer_start(Module.rcmServerH);
/*
* 8. handshake the ready event
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId, Module.eventId,
App_CMD_READY, TRUE);
if (status < 0) {
goto leave;
}
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_READY);
leave:
Log_print1(Diags_EXIT, "<-- Server_setup: %d", (IArg)status);
return(status);
}
