adi_audioezextender.c

audio talktrough code. platform bf533 + audio card.

#endif
    
    // configure the AD1938 dataflow method to circular(autobuffer) mode (FIXED)
    Result = adi_dev_Control(pAUDIOEZEXTENDER->AD1938Handle, ADI_DEV_CMD_SET_DATAFLOW_METHOD, (void*)ADI_DEV_MODE_CIRCULAR);
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

}

/*********************************************************************
*
*	Function:		adi_pdd_Open
*
*	Description:	Opens the Audio EZ-Extender device for use
*
*********************************************************************/

static u32 adi_pdd_Open(
	ADI_DEV_MANAGER_HANDLE	ManagerHandle,			// device manager handle
	u32 					DeviceNumber,			// device number
	ADI_DEV_DEVICE_HANDLE	DMHandle,				// device handle
	ADI_DEV_PDD_HANDLE 		*pPDDHandle,			// pointer to PDD handle location
	ADI_DEV_DIRECTION 		Direction,				// data direction
	void					*pEnterCriticalArg,		// enter critical region parameter
	ADI_DMA_MANAGER_HANDLE	DMAHandle,				// handle to the DMA manager
	ADI_DCB_HANDLE			DCBHandle,				// callback handle
	ADI_DCB_CALLBACK_FN		DMCallback				// client callback function
) {

	// default return code
	u32 Result = ADI_DEV_RESULT_SUCCESS;
	ADI_AUDIOEZEXTENDER *pAUDIOEZEXTENDER;		// pointer to the Audio EZ-Extender device we're working on
	void *pExitCriticalArg;		// exit critical region parameter

	// Check for a valid device number 
#ifdef ADI_DEV_DEBUG
	if (DeviceNumber >= ADI_AUDIOEZEXTENDER_NUM_DEVICES) return (ADI_DEV_RESULT_BAD_DEVICE_NUMBER);
#endif

	// assign the pointer to the device instance
	pAUDIOEZEXTENDER = &Device[DeviceNumber];
	// and store the Manager handle
	pAUDIOEZEXTENDER->ManagerHandle = ManagerHandle;
	// and store the Device Manager handle
	pAUDIOEZEXTENDER->DMHandle = DMHandle;
	// and store the DMA Manager handle
	pAUDIOEZEXTENDER->DMAHandle = DMAHandle;
	// and store the DCallback Manager handle
	pAUDIOEZEXTENDER->DCBHandle = DCBHandle;
	// and callback function
	pAUDIOEZEXTENDER->DMCallback = DMCallback;

	// Check that this device instance is not already in use. If not,
	// assign flag to indicate that it is now.
	pExitCriticalArg = adi_int_EnterCriticalRegion(pEnterCriticalArg);
	if (pAUDIOEZEXTENDER->InUseFlag == FALSE) {
		pAUDIOEZEXTENDER->InUseFlag = TRUE;
		Result = ADI_DEV_RESULT_SUCCESS;
	}
    adi_int_ExitCriticalRegion(pExitCriticalArg);
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

	// save the physical device handle in the client supplied location
	*pPDDHandle = (ADI_DEV_PDD_HANDLE *)pAUDIOEZEXTENDER;
	
    // open AD1938 CODEC A&B physical driver
    Result = adi_dev_Open(ManagerHandle,
                    &ADIAD1938EntryPoint,               // entry point for the instance API
                    0,                                  // device instance index (CODEC A&B)
                    pAUDIOEZEXTENDER,                   // client handle callback identifier
                    &pAUDIOEZEXTENDER->AD1938Handle,    // device handle for AD1938
                    ADI_DEV_DIRECTION_BIDIRECTIONAL,    // direction for AD1938A&B
                    DMAHandle,                          // DMA handle for SPORT
                    NULL,                               // Doesn't use deferred callback handle
                    AudioEZExtenderCallbackFunction);   // client's callback function
#ifdef ADI_DEV_DEBUG
    if (result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif
#if (ADAV801_SUPPORT)
    // open ADAV801 CODEC physical driver
    Result = adi_dev_Open(ManagerHandle,
                    &ADIADAV801EntryPoint,              // entry point for the instance API
                    0,                                  // device instance index
                    pAUDIOEZEXTENDER,                   // client handle callback identifier
                    &pAUDIOEZEXTENDER->ADAV801Handle,   // device handle for ADAV801
                    ADI_DEV_DIRECTION_BIDIRECTIONAL,    // direction for ADAV801
                    DMAHandle,                          // DMA handle for SPORT
                    NULL,                               // Doesn't use deferred callback handle
                    AudioEZExtenderCallbackFunction);   // client's callback function
#ifdef ADI_DEV_DEBUG
    if (result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif
#endif

    // Open dependent devices SPI
    Result = adi_dev_Control(pAUDIOEZEXTENDER->AD1938Handle, ADI_AD1938_CMD_OPEN_SPI, (void*)0);
#ifdef ADI_DEV_DEBUG
    if (result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif
    
    // Open dependent device SPORT1 for AD1938 codec.
    Result = adi_dev_Control(pAUDIOEZEXTENDER->AD1938Handle, 
                ADI_AD1938_CMD_OPEN_SPORT, 
                (void*)(pAUDIOEZEXTENDER->SportSelect == 0 ? 1 : 0));  // fixed
#ifdef ADI_DEV_DEBUG
    if (result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

#if (ADAV801_SUPPORT)
    // Open dependent device SPORT0 for ADAV801 codec.
    Result = adi_dev_Control(pAUDIOEZEXTENDER->ADAV801Handle, ADI_ADAV801_CMD_OPEN_SPORT, (void*)0);  // fixed
#ifdef ADI_DEV_DEBUG
    if (result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif
#endif

	// return after successful completion
	return(Result);
}


/*********************************************************************
*
*	Function:		adi_pdd_Close
*
*	Description:	Closes the associated devices
*
*********************************************************************/
static u32 adi_pdd_Close(		// Closes a device
	ADI_DEV_PDD_HANDLE PDDHandle	// PDD handle
) {
	u32 Result;		// return value
	ADI_AUDIOEZEXTENDER *pAUDIOEZEXTENDER = (ADI_AUDIOEZEXTENDER *)PDDHandle;

	// check for errors if required
#if defined(ADI_DEV_DEBUG)
	if ((Result = ValidatePDDHandle(PDDHandle)) != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

	// close AD1938 driver
	Result = adi_dev_Close(pAUDIOEZEXTENDER->AD1938Handle);
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

#if (ADAV801_SUPPORT)
	// close ADAV801 driver
	Result = adi_dev_Close(pAUDIOEZEXTENDER->ADAV801Handle);
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif
#endif
	// mark the device as closed
	pAUDIOEZEXTENDER->InUseFlag = FALSE;

	return(Result);
}


/*********************************************************************
*
*	Function:		adi_pdd_Read
*
*	Description:	Never called as SPI uses DMA
*
*********************************************************************/


static u32 adi_pdd_Read(		// Reads data or queues an inbound buffer to a device
	ADI_DEV_PDD_HANDLE 	PDDHandle,	// PDD handle
	ADI_DEV_BUFFER_TYPE	BufferType,	// buffer type
	ADI_DEV_BUFFER 		*pBuffer	// pointer to buffer
){
	// check for errors if required
	u32 Result = ADI_DEV_RESULT_SUCCESS;
#if defined(ADI_DEV_DEBUG)
	if ((Result = ValidatePDDHandle(PDDHandle)) != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

    // Simply pass the request on
	ADI_AUDIOEZEXTENDER *pAUDIOEZEXTENDER = (ADI_AUDIOEZEXTENDER *)PDDHandle;
	
    if (pAUDIOEZEXTENDER->SelectedDevice == ADI_AD1938)
    {
        Result = adi_dev_Read(pAUDIOEZEXTENDER->AD1938Handle, BufferType, pBuffer);
    }
#if (ADAV801_SUPPORT)
    else
    {
        Result = adi_dev_Read(pAUDIOEZEXTENDER->ADAV801Handle, BufferType, pBuffer);
    }
#endif
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

	return(Result);
}

/*********************************************************************
*
*	Function:		adi_pdd_Write
*
*	Description:	Never called as SPI uses DMA
*
*********************************************************************/


static u32 adi_pdd_Write(		// Writes data or queues an outbound buffer to a device
	ADI_DEV_PDD_HANDLE 	PDDHandle,	// PDD handle
	ADI_DEV_BUFFER_TYPE	BufferType,	// buffer type
	ADI_DEV_BUFFER 		*pBuffer	// pointer to buffer
){
	// check for errors if required
	u32 Result = ADI_DEV_RESULT_SUCCESS;
#if defined(ADI_DEV_DEBUG)
	if ((Result = ValidatePDDHandle(PDDHandle)) != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

	// Simply pass the request on
	ADI_AUDIOEZEXTENDER *pAUDIOEZEXTENDER = (ADI_AUDIOEZEXTENDER *)PDDHandle;

    if (pAUDIOEZEXTENDER->SelectedDevice == ADI_AD1938)
    {
        Result = adi_dev_Write(pAUDIOEZEXTENDER->AD1938Handle, BufferType, pBuffer);
    }
#if (ADAV801_SUPPORT)
    else
    {
        Result = adi_dev_Write(pAUDIOEZEXTENDER->ADAV801Handle, BufferType, pBuffer);
    }
#endif
#ifdef ADI_DEV_DEBUG
	if (Result != ADI_DEV_RESULT_SUCCESS) return (Result);
#endif

	return(Result);
}


/*********************************************************************
*
*	Function:		adi_pdd_Control
*
*	Description:	Configures device
*
*********************************************************************/

static u32 adi_pdd_Control(		// Sets or senses a device specific parameter
	ADI_DEV_PDD_HANDLE 	PDDHandle,	// PDD handle
	u32 				Command,	// command ID
	void 				*Value		// command specific value
) {

	ADI_AUDIOEZEXTENDER     *pAUDIOEZEXTENDER;	// pointer to the device we're working on

	u32 			Result;		// return value
	u32				u32Value;	// u32 type to avoid casts/warnings etc.
	u16				u16Value;	// u16 type to avoid casts/warnings etc.
	u8				u8Value;	// u8 type to avoid casts/warnings etc.
    u8              *pu8Value; // pointer for get set 8 bit data
	// avoid casts
	pAUDIOEZEXTENDER = (ADI_AUDIOEZEXTENDER *)PDDHandle; // Pointer to Audio EZ-Extender device driver instance
    // assign 16 and 32 bit values for the Value argument
	u32Value = (u32)Value;
    	u16Value = ((u16)((u32)Value));
    	u8Value = ((u8)(u16Value));
		pu8Value = &u8Value;	
	
	// assume we're going to be successful
	Result = ADI_DEV_RESULT_SUCCESS;

	switch (Command)
	{
        // CASE (query for DMA support)		
        case (ADI_DEV_CMD_GET_PERIPHERAL_DMA_SUPPORT):
            // no, we do not support it at this level (it is delegated down to SPORT driver)
            *((u32 *)Value) = FALSE;
            break;
        
        case (ADI_AUDIOEZEXTENDER_CMD_SET_OPERATION_MODE):
        {
            // upper 16bit of 32bit value is analog mode index, lower 16bit is digital mode index
            pAUDIOEZEXTENDER->AnalogMode = (u32Value >> 16);
            pAUDIOEZEXTENDER->DigitalMode = (u32Value & 0x0FFFF);
            setAudioMode(pAUDIOEZEXTENDER);
            break;
        }
        
        case (ADI_AUDIOEZEXTENDER_CMD_SET_ANALOG_OPERATION_MODE):
        {
            // change analog mode only
            pAUDIOEZEXTENDER->AnalogMode = u32Value;
            setAudioMode(pAUDIOEZEXTENDER);
            break;
        }
        
        case (ADI_AUDIOEZEXTENDER_CMD_SET_DIGITAL_OPERATION_MODE):
        {
            // change digital mode only
            pAUDIOEZEXTENDER->DigitalMode = u32Value;
            setAudioMode(pAUDIOEZEXTENDER);
            break;
        }
        
        case (ADI_AUDIOEZEXTENDER_CMD_DEVICE_SELECT):
#if defined(ADI_DEV_DEBUG)
            // validate the device number
            if ((u32Value < 0) || (u32Value > 1)) return(ADI_AUDIOEZEXTENDER_RESULT_BAD_DEVICE_NUMBER);
#endif
            // select target device for read/write function
            pAUDIOEZEXTENDER->SelectedDevice = (AUDIOEZEXTENDER_CODEC_SELECTION)u32Value;
            break;
        
        default:
            // pass anything we don't specifically handle to the dependent drivers
            Result = adi_dev_Control(pAUDIOEZEXTENDER->AD1938Handle, Command, Value);
#if (ADAV801_SUPPORT)
            Result = adi_dev_Control(pAUDIOEZEXTENDER->ADAV801Handle, Command, Value);
#endif
            break;
	}

	return(Result);
}

/*********************************************************************

	Function:		AudioEZExtenderCallbackFunction

	Description:	invokes the callback function from the SPORT Driver

*********************************************************************/

static void AudioEZExtenderCallbackFunction(void* DeviceHandle, u32 Event, void* pArg)
{
	ADI_AUDIOEZEXTENDER *pAUDIOEZEXTENDER = (ADI_AUDIOEZEXTENDER *)DeviceHandle;
#if defined(ADI_DEV_DEBUG)
	if (ValidatePDDHandle(DeviceHandle) != ADI_DEV_RESULT_SUCCESS) {  	// verify the DM handle
		return;
	}
#endif
	// simply pass the callback along to the Device Manager Callback without interpretation
	(pAUDIOEZEXTENDER->DMCallback)(pAUDIOEZEXTENDER->DMHandle, Event, pArg);
}


/*********************************************************************

Entry point for device manager

*********************************************************************/

ADI_DEV_PDD_ENTRY_POINT ADIAudioEZExtenderEntryPoint = {
	adi_pdd_Open,
	adi_pdd_Close,
	adi_pdd_Read,
	adi_pdd_Write,
	adi_pdd_Control
};