// ----------------------------------------------------------------------------- //! \brief This routine writes copies buffer addr to the transport layer. //! //! \param[in] len - Number of bytes to write. //! //! \return uint8 - number of bytes written to transport // ----------------------------------------------------------------------------- uint16 NPITLUART_writeTransport(uint16 len) { ICall_CSState key; key = ICall_enterCriticalSection(); TransportTxLen = len; #ifdef POWER_SAVING TxActive = TRUE; // Start reading prior to impending write transaction // We can only call UART_write() once MRDY has been signaled from Master // device NPITLUART_readTransport(); #else // Check to see if transport is successful. If not, reset TxLen to allow // another write to be processed if(UART_write(uartHandle, TransportTxBuf, TransportTxLen) == UART_ERROR ) { TransportTxLen = 0; } #endif //POWER_SAVING ICall_leaveCriticalSection(key); return TransportTxLen; }
// ----------------------------------------------------------------------------- //! \brief This routine initializes the transport layer and opens the port //! of the device. //! //! \param[in] tRxBuf - pointer to NPI TL Tx Buffer //! \param[in] tTxBuf - pointer to NPI TL Rx Buffer //! \param[in] npiCBack - NPI TL call back function to be invoked at the end of //! a UART transaction //! //! \return void // ----------------------------------------------------------------------------- void NPITLUART_initializeTransport(Char *tRxBuf, Char *tTxBuf, npiCB_t npiCBack) { UART_Params params; TransportRxBuf = tRxBuf; TransportTxBuf = tTxBuf; npiTransmitCB = npiCBack; // Configure UART parameters. UART_Params_init(¶ms); params.baudRate = NPI_UART_BR; params.readDataMode = UART_DATA_BINARY; params.writeDataMode = UART_DATA_BINARY; params.dataLength = UART_LEN_8; params.stopBits = UART_STOP_ONE; params.readMode = UART_MODE_CALLBACK; params.writeMode = UART_MODE_CALLBACK; params.readEcho = UART_ECHO_OFF; params.readCallback = NPITLUART_readCallBack; params.writeCallback = NPITLUART_writeCallBack; // Open / power on the UART. uartHandle = UART_open(Board_UART, ¶ms); //Enable Partial Reads on all subsequent UART_read() UART_control(uartHandle, UARTCC26XX_CMD_RETURN_PARTIAL_ENABLE, NULL); #ifndef POWER_SAVING // This call will start repeated Uart Reads when Power Savings is disabled NPITLUART_readTransport(); #endif //!POWER_SAVING return; }
// ----------------------------------------------------------------------------- //! \brief This routine is called from the application context when REM RDY //! is de-asserted //! //! \return void // ----------------------------------------------------------------------------- void NPITLUART_handleRemRdyEvent(void) { _npiCSKey_t key; key = NPIUtil_EnterCS(); remRdy_flag = 0; // If we haven't already begun reading, now is the time before Master // potentially starts to send data // The !TxActive condition is because we will call UART_npiRead() prior to setting // TxActive true. There is the possibility that REM RDY gets set high which // clears RxActive prior to us getting to this event. This will cause us to // read twice per transaction which will cause the transaction to never // complete if (!RxActive && !TxActive) { NPITLUART_readTransport(); } // If we have something to write, then the Master has signalled it is ready // to receive. Time to write. if (TxActive) { // Check to see if transport is successful. If not, reset TxLen to allow // another write to be processed if (UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR) { TxActive = FALSE; TransportTxLen = 0; } } NPIUtil_ExitCS(key); }
// ----------------------------------------------------------------------------- //! \brief This routine writes copies buffer addr to the transport layer. //! //! \param[in] len - Number of bytes to write. //! //! \return uint16_t - number of bytes written to transport // ----------------------------------------------------------------------------- uint16_t NPITLUART_writeTransport(uint16_t len) { _npiCSKey_t key; key = NPIUtil_EnterCS(); npiTxBuf[NPI_UART_MSG_SOF_IDX] = NPI_UART_MSG_SOF; npiTxBuf[len + 1] = NPITLUART_calcFCS((uint8_t *)&npiTxBuf[1],len); TransportTxLen = len + 2; #ifdef POWER_SAVING TxActive = TRUE; // Start reading prior to impending write transaction // We can only call UART_write() once REM RDY has been signaled from Master // device NPITLUART_readTransport(); #else // Check to see if transport is successful. If not, reset TxLen to allow // another write to be processed if(UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR) { TransportTxLen = NPI_BUSY; } #endif //POWER_SAVING NPIUtil_ExitCS(key); return len; }
// ----------------------------------------------------------------------------- //! \brief This routine is called from the application context when REM RDY //! is de-asserted //! //! \return void // ----------------------------------------------------------------------------- void NPITLUART_handleRemRdyEvent(void) { _npiCSKey_t key; key = NPIUtil_EnterCS(); // If read has not yet been started, now is the time before Master // potentially starts to send data // There is the possibility that MRDY gets set high which // clears RxActive prior to us getting to this event. This will cause us to // read twice per transaction which will cause the transaction to never // complete if (!RxActive && !TxActive) { NPITLUART_readTransport(); } // If write has already been initialized then kick off the driver write // now that Master has signalled it is ready if (TxActive) { // Check to see if transport is successful. If not, reset TxLen to allow // another write to be processed if (UART_write(uartHandle, npiTxBuf, TransportTxLen) == UART_ERROR) { TxActive = FALSE; TransportTxLen = 0; } } NPIUtil_ExitCS(key); }