/** * \file tcDspUpp.h * * \brief DSP uPP driver header file * * o 0 * | / Copyright (c) 2005-2011 * (CL)---o Critical Link, LLC * \ * O */ //TODO: // -Think about interleave mode... #ifndef _DSPUPP_H_ #define _DSPUPP_H_ #include #include #include #include #include #include "regs_upp.h" namespace MityDSP { class tcDspUpp { public: // Enumerations for uPP channels. enum teUppChan { eeChanA, eeChanB }; // Channel data transfer directionality. enum teChanDir { eeTransmit, eeReceive, eeDisabled }; // Channel data bit width. enum teChanBitWidth { ee8Bit = 0, ee9Bit = 1, ee10Bit = 2, ee11Bit = 3, ee12Bit = 4, ee13Bit = 5, ee14Bit = 6, ee15Bit = 7, ee16Bit = 8 }; // Read/Transmit threshold for UPTCR register bits enum teThreshold { ee64Bytes = 0, ee128Bytes = 1, ee256Bytes = 3 }; // uPP Transmit clock selection options enum teTxClockSel { eeUPP_2xTXCLK = 0, //!< External Tx clock source eePLL0_SYSCLK2 = 1, //!< Same as uPP Module clock. Runs at //!< 1/2 CPU speed eePLL1_SYSCLK2 = 2 //!< PLL1_SYSCLK2 }; // Structure for configuring the uPP device. struct tsDspUppConfig { uint32_t nHWInterruptLevel; //!< Interrupt level. Must be //!< between 4 and 15. uint32_t nTskPriorityChanA; //!< Priority for thread handling //!< DMA programming for Channel A. uint32_t nTskPriorityChanB; //!< Priority for thread handling //!< DMA programming for Channel B. teChanDir eChanADir; //!< Directionality of Channel A. teChanDir eChanBDir; //!< Directionality of Channel B. teChanBitWidth eChanBitWidthA; //!< Chan A data bit width. teChanBitWidth eChanBitWidthB; //!< Chan B data bit width. bool bChanAUseXData; //!< Use XData[7:0] for ChanA[15:8] //!< even if ChanB is disabled. See Table 3 in uPP //!< User's Guide for details. uint32_t nMbxLenA; //!< Size of MBX for Channel A. uint32_t nMbxLenB; //!< Size of MBX for Channel B. uint8_t nChanAClkDiv; //!< Clock divider for Channel A //!< (only in transmit mode). See Section 2.1.1 in uPP //!< User's Guide for details. Value must be between 0 //!< and 15. uint8_t nChanBClkDiv; //!< Clock divider for Channel B //!< (only in transmit mode). See Section 2.1.1 in uPP //!< User's Guide for details. Value must be between 0 //!< and 15. teThreshold eThresholdTxA; //!< Chan A Transmit Thresh. teThreshold eThresholdRxA; //!< Chan A Receive Thresh. teThreshold eThresholdTxB; //!< Chan B Transmit Thresh. teThreshold eThresholdRxB; //!< Chan B Receive Thresh. bool bChanAUseStart; //!< Use start signal for Chan A. bool bChanBUseStart; //!< Use start signal for Chan B. teTxClockSel eTxClockSel; //!< Select transmit clock source. //!< Only used if Chan A or Chan B is set to transmit. uint8_t nDmaMasterPriority; //!< Set the DMA master priority //!< for uPP. Valid number, range 0-7. 0 is highest //!< priority. // Chan A single/double data rate? // Chan B single/double data rate? // Multiplexing/interleaving mode options? // Chan A data packing format? // Chan B data packing format? }; // MBX message structure. struct tsMbxMsg { uint8_t* pBufPtr; //!< Pointer to filled/emptied buffer. uint16_t nByteCnt; //!< # bytes per line DMAed to/from buf. uint16_t nLineCnt; //!< DMA line count. uint16_t nLineOffset; //!< DMA offset between lines. void* pOptArg; //!< Pointer to optional additional arguments. }; // Typdef for error callback function typedef int (*tfErrorCallback)(uint32_t anErrNum); /** * Get instance of tcDspUpp. * * \return Poiner to the tcDspUpp object or NULL on failure. */ static tcDspUpp* getInstance(); /** * Perform software reset of the uPP. * * @return None. */ void reset(); /** * Intiailize the uPP device. * * \param apDspUppConfig Specifies configuration options. * * \return 0 on success, negative on failure. */ int initialize(tsDspUppConfig const* apDspUppConfig); /** * Get handle to mailbox for associated channel where info on * processed buffers are stored. * * \param aeChan The uPP channel. * * \return Handle to the channel's mailbox or NULL on failure. */ MBX_Handle getMBX(teUppChan aeChan); /** * Queue transmit of given data buffer. Use getMBX() to get * corresponding mailbox where pointer info will be posted once data * has been tramsmitted. * * \param aeChan The uPP channel to transmit on. Note: If the given * channel is not configured for transmit, function call * will fail. * \param apXmitData Pointer to transmit data. (note: Address must be * be 64-bit aligned). * \param anByteCnte Number of bytes in a line to DMA. (must be even). * \param anLineCnt (Optional) Set the number of lines in the DMA * channel window. If set > 1 and anLineOffset = 0, * apXmitData will tranmist anLineCnt times. * \param anLineOffset (Optional) Set the offset address between lines * within DMA channel. (must be 64-bit aligned). * * \return 0 on succes, negative on failure. */ int transmit(teUppChan aeChan, const uint8_t* apXmitData, uint16_t anByteCnt, uint16_t anLineCnt = 1, uint16_t anLineOffset = 0); /** * Add buffer to receive queue. Use getMBX() to get corresponding * mailbox where pointer info will be posted once data has been * received. * * \param aeChan The uPP channel to receive on. Note: If the given * channel is not configured for receive, function call * will fail. * \param apRcvData Pointer to location where to store receive data. * (note: Address must be 64-bit aligned). * \param anByteCnte Number of bytes in a line to DMA. (must be even). * \param anLineCnt (Optional) Set the number of lines in the DMA * channel window. * \param anLineOffset (Optional) Set the offset address between lines * within DMA channel. (must be 64-bit aligned). * * \return 0 on succes, negative on failure. */ int receive(teUppChan aeChan, uint8_t* apRcvData, uint16_t anByteCnt, uint16_t anLineCnt = 1, uint16_t anLineOffset = 0); /** * Register an error callback function. * * \param afErrorCallback The error callback function. * * return None. */ void registerErrorCallback(tfErrorCallback afErrorCallback); private: /** * Thread for programming the DMA for the specified channel. * * \param apDspUpp Pointer to singleton. * \param aeChan The specified channel. * * \return None. */ static void programDMA(tcDspUpp* apDspUpp, teUppChan aeChan); /** * Handle any uPP related interrupts that might occur. * * \param apDspUpp Pointer to singleton. * * \return 0 on success, negative on failure. */ static int isr(tcDspUpp* acDspUpp); /** * Private constructor. */ tcDspUpp(); /** * Private destructor. */ ~tcDspUpp(); /** * Private Copy Constructor to enforce use of getInstance(). */ tcDspUpp(tcDspUpp const&); // Note implemented. /** * Private assignment operator to enforce use of getInstance(). */ tcDspUpp& operator=(tcDspUpp const&); // Not implemented tfErrorCallback mpErrorCallback; //!< Callback function for errors. volatile tsUppRegs* const mpUppRegs; //!< Constant pointer to uPP Control Regs. static tcDspUpp* mpDspUpp; //!< Singleton object. static SEM_Handle mhGetInstSem; //!< Static semaphore to be used in //!< getInstance method so that we do not accidentally //!< instantiate too many objects. bool mbFirstInit; //!< True if we have not been initialized before. teChanDir meChanADir; //!< Directionality of Channel A. teChanDir meChanBDir; //!< Directionality of Channel B. TSK_Handle mhDmaTskA; //!< Task for programming Channel A DMA. TSK_Handle mhDmaTskB; //!< Task for programming Channel B DMA. MBX_Handle mhMbxDoneA; //!< MBX for eeChanA or eeInterleave to store //!< pointers than have been filled or transmitted. MBX_Handle mhMbxDoneB; //!< MBX for eeChanB to store pointers that //!< have been filled or transmitted. MBX_Handle mhMbxIntA; //!< Intermdiate MBX holding info on pointers //!< that have been sent for DMAing on Chan A. MBX_Handle mhMbxIntB; //!< Intermdiate MBX holding info on pointers //!< that have been sent for DMAing on Chan B. MBX_Handle mhMbxQueueA; //!< Queue of pointers to be transmitted or //!< filled by eeChanA or eeInterleave. MBX_Handle mhMbxQueueB; //!< Queue of pointers to be transmitted or //!< filled by eeChanB. }; } #endif