Mity CPU Platforms » MityDSP-L138 (ARM9 Based Platforms)

/**

 * 	\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 <stdint.h>

#include <std.h>

#include <mbx.h>

#include <sem.h>

#include <tsk.h>

#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