/* * ======== MSP_EXP432P401R_initDMA ======== */ void MSP_EXP432P401R_initDMA(void) { HwiP_Params hwiParams; HwiP_Handle dmaErrorHwiHandle; if (!dmaInitialized) { HwiP_Params_init(&hwiParams); dmaErrorHwiHandle = HwiP_create(INT_DMA_ERR, dmaErrorHwi, &hwiParams); if (dmaErrorHwiHandle == NULL) { DebugP_log0("Failed to create DMA error Hwi!!\n"); while (1); } MAP_DMA_enableModule(); MAP_DMA_setControlBase(dmaControlTable); dmaInitialized = true; } }
/* * ======== WatchdogMSP432_open ======== */ Watchdog_Handle WatchdogMSP432_open(Watchdog_Handle handle, Watchdog_Params *params) { uintptr_t key; HwiP_Params hwiParams; WatchdogMSP432_Object *object = handle->object; WatchdogMSP432_HWAttrs const *hwAttrs = handle->hwAttrs; /* If params are NULL use defaults. */ if (params == NULL) { params = (Watchdog_Params *) &Watchdog_defaultParams; } /* Ensure a callbackFxn is specified if using watchdog in interval mode */ DebugP_assert((params->resetMode == Watchdog_RESET_ON) || (params->callbackFxn != NULL)); /* Don't allow preemption */ key = HwiP_disable(); /* Check if the Watchdog is open already with the HWAttrs */ if (object->isOpen) { HwiP_restore(key); DebugP_log1("Watchdog: Handle %x already in use.", (uintptr_t) handle); return (NULL); } object->isOpen = true; HwiP_restore(key); /* * Add power management support - Disable performance transitions while * opening the driver. */ Power_setConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); if (params->resetMode == Watchdog_RESET_ON || hwAttrs->clockSource == WDT_A_CLOCKSOURCE_SMCLK || hwAttrs->clockSource == WDT_A_CLOCKSOURCE_ACLK) { /* * Do not support power modes lower than LPM0 if in watchdog mode or * in interval mode and using SMCLK or ACLK as clock sources. * Additionally, LPM3.5 cannot be reached. */ Power_setConstraint(PowerMSP432_DISALLOW_DEEPSLEEP_0); Power_setConstraint(PowerMSP432_DISALLOW_SHUTDOWN_0); } else { /* * Interval mode and not using SMCLK and ACLK as clock sources. Can * be configured as a LPM3.5 wake up source, so we do not set the * SHUTDOWN_0 constraint. */ Power_setConstraint(PowerMSP432_DISALLOW_DEEPSLEEP_1); } /* SHUTDOWN_1 (LPM4.5) not supported while driver is open */ Power_setConstraint(PowerMSP432_DISALLOW_SHUTDOWN_1); /* Construct Hwi object for watchdog */ if (params->callbackFxn) { HwiP_Params_init(&hwiParams); hwiParams.arg = (uintptr_t) handle; hwiParams.priority = hwAttrs->intPriority; object->hwiHandle = HwiP_create(hwAttrs->intNum, params->callbackFxn, &hwiParams); if (!object->hwiHandle) { DebugP_log0("Watchdog: HwiP_create() failed"); Power_releaseConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); WatchdogMSP432_close(handle); return (NULL); } } /* Configure and initialize WDT */ object->resetMode = params->resetMode; if (object->resetMode == Watchdog_RESET_ON) { MAP_WDT_A_initWatchdogTimer(hwAttrs->clockSource, hwAttrs->clockDivider); } else { MAP_WDT_A_initIntervalTimer(hwAttrs->clockSource, hwAttrs->clockDivider); } MAP_WDT_A_startTimer(); /* Allow performance level changes */ Power_releaseConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); DebugP_log1("Watchdog: (0x%x) opened and enabled.", (uintptr_t) handle); /* Return handle of the Watchdog object */ return (handle); }
/* * ======== CameraCC3200DMA_open ======== */ Camera_Handle CameraCC3200DMA_open(Camera_Handle handle, Camera_Params *params) { uintptr_t key; CameraCC3200DMA_Object *object = handle->object; CameraCC3200DMA_HWAttrs const *hwAttrs = handle->hwAttrs; unsigned long hSyncPolarityConfig; unsigned long vSyncPolarityConfig; unsigned long byteOrderConfig; unsigned long interfaceSync; unsigned long pixelClkConfig; HwiP_Params hwiParams; SemaphoreP_Params semParams; /* If params are NULL use defaults. */ if (params == NULL) { params = (Camera_Params *) &Camera_defaultParams; } /* Timeouts cannot be 0 */ DebugP_assert((params->captureTimeout != 0)); /* Check that a callback is set */ DebugP_assert((params->captureMode != Camera_MODE_CALLBACK) || (params->captureCallback != NULL)); /* Disable preemption while checking if the Camera is open. */ key = HwiP_disable(); /* Check if the Camera is open already with the base addr. */ if (object->opened == true) { HwiP_restore(key); DebugP_log1("Camera:(%p) already in use.", hwAttrs->baseAddr); return (NULL); } object->opened = true; HwiP_restore(key); object->operationMode = params->captureMode; object->captureCallback = params->captureCallback; object->captureTimeout = params->captureTimeout; /* Set Camera variables to defaults. */ object->captureBuf = NULL; object->bufferlength = 0; object->frameLength = 0; object->inUse = 0; /* * Register power dependency. Keeps the clock running in SLP * and DSLP modes. */ Power_setDependency(PowerCC3200_PERIPH_CAMERA); Power_setDependency(PowerCC3200_PERIPH_UDMA); /* Disable the Camera interrupt. */ MAP_CameraIntDisable(hwAttrs->baseAddr, (CAM_INT_FE | CAM_INT_DMA)); HwiP_clearInterrupt(hwAttrs->intNum); /* Create Hwi object for the Camera peripheral. */ /* Register the interrupt for this Camera peripheral. */ HwiP_Params_init(&hwiParams); hwiParams.arg = (uintptr_t)handle; hwiParams.priority = hwAttrs->intPriority; object->hwiHandle = HwiP_create(hwAttrs->intNum, CameraCC3200DMA_hwiIntFxn, &hwiParams); if (object->hwiHandle == NULL) { CameraCC3200DMA_close(handle); return (NULL); } MAP_IntEnable(INT_CAMERA); SemaphoreP_Params_init(&semParams); semParams.mode = SemaphoreP_Mode_BINARY; /* If capture is blocking create a semaphore and set callback. */ if (object->operationMode == Camera_MODE_BLOCKING) { object->captureSem = SemaphoreP_create(0, &semParams); if (object->captureSem) { CameraCC3200DMA_close(handle); return (NULL); } object->captureCallback = &captureSemCallback; } MAP_CameraReset(hwAttrs->baseAddr); if (params->hsyncPolarity == Camera_HSYNC_POLARITY_HIGH) { hSyncPolarityConfig = CAM_HS_POL_HI; } else { hSyncPolarityConfig = CAM_HS_POL_LO; } if (params->vsyncPolarity == Camera_VSYNC_POLARITY_HIGH) { vSyncPolarityConfig = CAM_VS_POL_HI; } else { vSyncPolarityConfig = CAM_VS_POL_LO; } if (params->byteOrder == Camera_BYTE_ORDER_SWAP) { byteOrderConfig = CAM_ORDERCAM_SWAP; } else { byteOrderConfig = 0; } if (params->interfaceSync == Camera_INTERFACE_SYNC_OFF) { interfaceSync = CAM_NOBT_SYNCHRO; } else { interfaceSync = CAM_NOBT_SYNCHRO | CAM_IF_SYNCHRO | CAM_BT_CORRECT_EN; } if (params->pixelClkConfig == Camera_PCLK_CONFIG_RISING_EDGE) { pixelClkConfig = CAM_PCLK_RISE_EDGE; } else { pixelClkConfig = CAM_PCLK_FALL_EDGE; } MAP_CameraParamsConfig(hwAttrs->baseAddr, hSyncPolarityConfig, vSyncPolarityConfig, byteOrderConfig | interfaceSync | pixelClkConfig); /*Set the clock divider based on the output clock */ MAP_CameraXClkConfig(hwAttrs->baseAddr, PRCMPeripheralClockGet(PRCM_CAMERA), params->outputClock); /*Setting the FIFO threshold for a DMA request */ MAP_CameraThresholdSet(hwAttrs->baseAddr, 8); MAP_CameraIntEnable(hwAttrs->baseAddr, (CAM_INT_FE | CAM_INT_DMA)); MAP_CameraDMAEnable(hwAttrs->baseAddr); DebugP_log1("Camera:(%p) opened", hwAttrs->baseAddr); /* Return the handle */ return (handle); }
/* * ======== SPICC3200DMA_open ======== * @pre Function assumes that the handle is not NULL */ SPI_Handle SPICC3200DMA_open(SPI_Handle handle, SPI_Params *params) { uintptr_t key; SPICC3200DMA_Object *object = handle->object; SPICC3200DMA_HWAttrs const *hwAttrs = handle->hwAttrs; SemaphoreP_Params semParams; HwiP_Params hwiParams; key = HwiP_disable(); if(object->isOpen == true) { HwiP_restore(key); return (NULL); } object->isOpen = true; HwiP_restore(key); if (params == NULL) { params = (SPI_Params *) &SPI_defaultParams; } DebugP_assert((params->dataSize >= 4) && (params->dataSize <= 32)); /* Determine if we need to use an 8, 16 or 32-bit frameSize for the DMA */ if (params->dataSize <= 8) { object->frameSize = SPICC3200DMA_8bit; } else if (params->dataSize <= 16) { object->frameSize = SPICC3200DMA_16bit; } else { object->frameSize = SPICC3200DMA_32bit; } /* Store SPI mode of operation */ object->spiMode = params->mode; object->transferMode = params->transferMode; object->transaction = NULL; object->rxFifoTrigger = (1 << object->frameSize); object->txFifoTrigger = (1 << object->frameSize); object->bitRate = params->bitRate; object->frameFormat = params->frameFormat; object->dataSize = params->dataSize; /* Register power dependency - i.e. power up and enable clock for SPI. */ Power_setDependency(getPowerMgrId(hwAttrs->baseAddr)); Power_setDependency(PowerCC3200_PERIPH_UDMA); Power_registerNotify(&(object->notifyObj), PowerCC3200_AWAKE_LPDS, SPICC3200DMA_postNotify, (uintptr_t)handle); HwiP_Params_init(&hwiParams); hwiParams.arg = (uintptr_t)handle; hwiParams.priority = hwAttrs->intPriority; object->hwiHandle = HwiP_create(hwAttrs->intNum, SPICC3200DMA_hwiFxn, &hwiParams); if (object->hwiHandle == NULL) { SPICC3200DMA_close(handle); return (NULL); } if (object->transferMode == SPI_MODE_BLOCKING) { DebugP_log1("SPI:(%p) in SPI_MODE_BLOCKING mode", hwAttrs->baseAddr); SemaphoreP_Params_init(&semParams); semParams.mode = SemaphoreP_Mode_BINARY; object->transferComplete = SemaphoreP_create(0, &semParams); if (object->transferComplete == NULL) { SPICC3200DMA_close(handle); return (NULL); } object->transferCallbackFxn = SPICC3200DMA_transferCallback; } else { DebugP_log1("SPI:(%p) in SPI_MODE_CALLBACK mode", hwAttrs->baseAddr); DebugP_assert(params->transferCallbackFxn != NULL); object->transferCallbackFxn = params->transferCallbackFxn; } if (uDMAControlBase == NULL) { uDMAControlBase = MAP_uDMAControlBaseGet(); } SPICC3200DMA_initHw(handle); DebugP_log3("SPI:(%p) CPU freq: %d; SPI freq to %d", hwAttrs->baseAddr, PRCMPeripheralClockGet(hwAttrs->spiPRCM), params->bitRate); DebugP_log1("SPI:(%p) opened", hwAttrs->baseAddr); return (handle); }
/* * ======== UARTMSP432_open ======== */ UART_Handle UARTMSP432_open(UART_Handle handle, UART_Params *params) { unsigned int i; uintptr_t key; uint32_t clockFreq; uint8_t numPerfLevels; int32_t baudrateIndex; union { ClockP_Params clockParams; HwiP_Params hwiParams; SemaphoreP_Params semParams; } portsParams; PowerMSP432_Freqs powerFreqs; UARTMSP432_Object *object = handle->object; UARTMSP432_HWAttrs const *hwAttrs = handle->hwAttrs; if (params == NULL) { params = (UART_Params *) &UART_defaultParams; } /* Check that a callback is set */ DebugP_assert((params->readMode != UART_MODE_CALLBACK) || (params->readCallback != NULL)); DebugP_assert((params->writeMode != UART_MODE_CALLBACK) || (params->writeCallback != NULL)); key = HwiP_disable(); if (object->state.opened) { HwiP_restore(key); DebugP_log1("UART:(%p) already in use.", hwAttrs->baseAddr); return (NULL); } object->state.opened = true; HwiP_restore(key); /* Ensure a supported clock source is used */ if (hwAttrs->clockSource != EUSCI_A_UART_CLOCKSOURCE_ACLK && hwAttrs->clockSource != EUSCI_A_UART_CLOCKSOURCE_SMCLK) { DebugP_log1("UART:(%p) Error! Using unsupported clock source.", hwAttrs->baseAddr); object->state.opened = false; return (NULL); } /* * Add power management support - Disable performance transitions while * opening the driver is open. This constraint remains active until a * UART_control() disables receive interrupts. Afterwards performance * levels can be changed by the application. A UART_control() call can * enable RX interrupts again and set the pertinent constraints. */ Power_setConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); /* * Verify that the driver can be opened at current performance level and * set constraints for other performance levels. */ numPerfLevels = PowerMSP432_getNumPerfLevels(); PowerMSP432_getFreqs(Power_getPerformanceLevel(), &powerFreqs); if (hwAttrs->clockSource == EUSCI_A_UART_CLOCKSOURCE_ACLK) { /* * Verify if driver can be opened with ACLK; ACLK does not change * in any performance level. */ baudrateIndex = findBaudDividerIndex(hwAttrs->baudrateLUT, hwAttrs->numBaudrateEntries, params->baudRate, powerFreqs.ACLK); if (baudrateIndex == -1) { DebugP_log3("UART:(%p) unable to find a valid buadrate %d " "configuration at clock input clock freq %d", hwAttrs->baseAddr, params->baudRate, powerFreqs.ACLK); Power_releaseConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); object->state.opened = false; return (NULL); } clockFreq = powerFreqs.ACLK; } else { /* hwAttrs->clockSource == EUSCI_A_UART_CLOCKSOURCE_SMCLK */ baudrateIndex = findBaudDividerIndex(hwAttrs->baudrateLUT, hwAttrs->numBaudrateEntries, params->baudRate, powerFreqs.SMCLK); if (baudrateIndex == -1) { DebugP_log3("UART:(%p) unable to find a valid buadrate %d " "configuration at clock input clock freq %d", hwAttrs->baseAddr, params->baudRate, powerFreqs.SMCLK); Power_releaseConstraint(PowerMSP432_DISALLOW_PERF_CHANGES); object->state.opened = false; return (NULL); } clockFreq = powerFreqs.SMCLK; /* * SMCLK changes with performance levels. Set constraints for * unsupported performance levels. */ for (i = 0; i < numPerfLevels; i++) { PowerMSP432_getFreqs(i, &powerFreqs); baudrateIndex = findBaudDividerIndex(hwAttrs->baudrateLUT, hwAttrs->numBaudrateEntries, params->baudRate, powerFreqs.SMCLK); if (baudrateIndex == -1) { /* Set constraint and keep track of it in perfConstraintMask */ object->perfConstraintMask |= (1 << i); Power_setConstraint(PowerMSP432_DISALLOW_PERFLEVEL_0 + i); } } } /* * Shutdown not supported while driver is open. The DEEPSLEEP_0 constraint * keeps stops the device from going into LPM3 or higher. This is done * to keep the UART peripheral receiving in the background and storing data * in the internal ring buff. */ Power_setConstraint(PowerMSP432_DISALLOW_DEEPSLEEP_0); Power_setConstraint(PowerMSP432_DISALLOW_SHUTDOWN_0); Power_setConstraint(PowerMSP432_DISALLOW_SHUTDOWN_1); /* Register function to reconfigure peripheral on perf level changes */ Power_registerNotify(&object->perfChangeNotify, PowerMSP432_START_CHANGE_PERF_LEVEL | PowerMSP432_DONE_CHANGE_PERF_LEVEL, perfChangeNotifyFxn, (uintptr_t) handle); /* Create the Hwi for this UART peripheral */ HwiP_Params_init(&(portsParams.hwiParams)); portsParams.hwiParams.arg = (uintptr_t) handle; portsParams.hwiParams.priority = hwAttrs->intPriority; object->hwiHandle = HwiP_create(hwAttrs->intNum, UARTMSP432_hwiIntFxn, &(portsParams.hwiParams)); if (object->hwiHandle == NULL) { DebugP_log1("UART:(%p) HwiP_create() failed", hwAttrs->baseAddr); UARTMSP432_close(handle); return (NULL); } SemaphoreP_Params_init(&(portsParams.semParams)); portsParams.semParams.mode = SemaphoreP_Mode_BINARY; if (params->writeMode == UART_MODE_BLOCKING) { /* If write mode is blocking create a semaphore and set callback. */ object->writeSem = SemaphoreP_create(0, &(portsParams.semParams)); if (object->writeSem == NULL) { DebugP_log1("UART:(%p) SemaphoreP_create() failed.", hwAttrs->baseAddr); UARTMSP432_close(handle); return (NULL); } object->writeCallback = &writeSemCallback; } else { /* UART_MODE_CALLBACK - Store application callback */ object->writeCallback = params->writeCallback; } if (params->readMode == UART_MODE_BLOCKING) { /* If read mode is blocking create a semaphore and set callback. */ object->readSem = SemaphoreP_create(0, &(portsParams.semParams)); if (object->readSem == NULL) { DebugP_log1("UART:(%p) SemaphoreP_create() failed.", hwAttrs->baseAddr); UARTMSP432_close(handle); return (NULL); } object->readCallback = &readSemCallback; ClockP_Params_init(&(portsParams.clockParams)); portsParams.clockParams.arg = (uintptr_t) handle; object->timeoutClk = ClockP_create((ClockP_Fxn) &readBlockingTimeout, &(portsParams.clockParams)); if (object->timeoutClk == NULL) { DebugP_log1("UART:(%p) ClockP_create() failed.", hwAttrs->baseAddr); UARTMSP432_close(handle); return (NULL); } } else { object->state.drainByISR = false; object->readCallback = params->readCallback; } /* * Initialize UART read buffer - will store received bytes until * UART_read is invoked. */ RingBuf_construct(&object->ringBuffer, hwAttrs->ringBufPtr, hwAttrs->ringBufSize); /* * Store UART parameters & initialize peripheral. These are used to * re/initialize the peripheral when opened or changing performance level. */ object->state.readMode = params->readMode; object->state.writeMode = params->writeMode; object->state.readReturnMode = params->readReturnMode; object->state.readDataMode = params->readDataMode; object->state.writeDataMode = params->writeDataMode; object->state.readEcho = params->readEcho; object->readTimeout = params->readTimeout; object->writeTimeout = params->writeTimeout; object->baudRate = params->baudRate; object->stopBits = params->stopBits; object->parityType = params->parityType; object->readFxns = staticFxnTable[object->state.readMode][object->state.readDataMode]; object->writeBuf = NULL; object->readBuf = NULL; object->writeCount = 0; object->readCount = 0; object->writeSize = 0; object->readSize = 0; object->state.writeCR = false; object->state.txEnabled = false; object->state.rxEnabled = true; initHw(object, hwAttrs, clockFreq); DebugP_log1("UART:(%p) opened", hwAttrs->baseAddr); /* Return the handle */ return (handle); }