wmxscaledmacontext.c

WM9713 audio codec driver for WinCE 5.0

	/* No matching channel found */
	WM_TRACE( hDevice, ( "WMDMAGetChannelDetails - No channel details found for channel %d",
			             APIChannel
			           ) 
			);
	return ((const DMA_CHANNEL_DETAILS *)NULL);
}

/*-----------------------------------------------------------------------------
 * Function:    private_AllocateDMAMemory
 *
 * Allocates memory for the buffers and descriptors.
 *
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *      pDMAContext pointer to the DMA context
 *
 * Returns:     WMSTATUS
 *		see WMStatus.h
 *---------------------------------------------------------------------------*/
static WMSTATUS private_AllocateDMAMemory( WM_DEVICE_HANDLE hDevice,
                                           DMAContext *pDMAContext 
                                         )
{
    WMSTATUS                    status;
    void                        *pDMABuffers_Virtual;
    void                        *pDMABuffers_Physical;
    XLLP_DMAC_DESCRIPTOR_T      *pDMADescriptors_Virtual;
    XLLP_DMAC_DESCRIPTOR_T      *pDMADescriptors_Physical;
    ChannelDef                  *pDMAChannels;


    /*
     * Reserve and map the memory for our DMA buffers.
     */
    pDMABuffers_Virtual = ALLOC_OR_MAP_BUFFER( hDevice,
                                               void,
                                               WMDMA_BUFFER_BASE_PHYSICAL,
                                               WMAUDIO_MAX_BUFFER_SIZE * WMAUDIO_MAX_BUFFERS, 
                                               &pDMABuffers_Physical,
                                               "WMInitDMA: DMA buffers"
                                             );
    if ( !pDMABuffers_Virtual )
    {
        status = WMS_RESOURCE_FAIL;
        pDMABuffers_Physical = NULL;
        goto error0;
    }

    pDMAContext->pDMABuffers_Virtual = pDMABuffers_Virtual;
    pDMAContext->pDMABuffers_Physical = pDMABuffers_Physical;

    /*
     * Now do the same for the descriptors.
     */
    pDMADescriptors_Virtual = ALLOC_OR_MAP_BUFFER( hDevice,
                                                   XLLP_DMAC_DESCRIPTOR_T,
                                                   WMDMA_DESCRIPTOR_BASE_PHYSICAL,
                                                   WMAUDIO_DMA_DESC_SIZE * WMAUDIO_MAX_BUFFERS, 
                                                   &pDMADescriptors_Physical,
                                                   "WMInitDMA: DMA descriptors"
                                                 );
    if ( !pDMADescriptors_Virtual )
    {
        status = WMS_RESOURCE_FAIL;
        pDMADescriptors_Physical = NULL;
        goto error1;
    }

    pDMAContext->pDMADescriptors_Virtual = pDMADescriptors_Virtual;
    pDMAContext->pDMADescriptors_Physical = pDMADescriptors_Physical;

    /*
     * Allocate memory for our DMA Channel Structures.
     */
    pDMAChannels = ALLOC_MEMORY( void,
                                 sizeof( ChannelDef ) * WM_AVAILABLE_DMA_CHANNELS
                               );
    if ( !pDMAChannels )
    {
        status = WMS_RESOURCE_FAIL;
        goto error2;
    }

    pDMAContext->pDMAChannels = pDMAChannels;
    
    /*
     * Clean our channel block.
     */
    memset( pDMAContext->pDMAChannels,
            0,
            sizeof( ChannelDef ) * WM_AVAILABLE_DMA_CHANNELS
          );
    
    return WMS_SUCCESS;

    /*
     * Error handling.
     */
error2:
    FREE_BUFFER_MEMORY( pDMADescriptors_Virtual,
    					pDMADescriptors_Physical,
    					WMAUDIO_DMA_DESC_SIZE * WMAUDIO_MAX_BUFFERS
    				  );
	pDMAContext->pDMADescriptors_Virtual = NULL;
	pDMAContext->pDMADescriptors_Physical = NULL;
    
error1:
    FREE_BUFFER_MEMORY( pDMABuffers_Virtual,
                        pDMABuffers_Physical,
                        WMAUDIO_MAX_BUFFER_SIZE * WMAUDIO_MAX_BUFFERS
                      );
	pDMAContext->pDMABuffers_Virtual = NULL;
	pDMAContext->pDMABuffers_Physical = NULL;

error0:
	pDMAContext->initialised = FALSE;

    return status;
}

/*-----------------------------------------------------------------------------
 * Function:    private_InitialiseDMAMemory
 *
 * Sets up the context to point at the buffers and descriptors.
 *
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *      pDMAContext pointer to the DMA context
 *
 * Returns:     void
 *---------------------------------------------------------------------------*/
static void private_InitialiseDMAMemory( WM_DEVICE_HANDLE hDevice, 
                                         DMAContext *pDMAContext
                                       )
{
	int nDMAChannel = -1;	/* This index will be incremented before each use */

#if WM_AC97
	/* 
	 * WMAUDIO_AC97_STEREO_OUT:
	 *  - Channel IDs 
	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_AC97_STEREO_OUT;

	/* 
	 * WMAUDIO_AC97_STEREO_IN:
	 * - Channel IDs
	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_AC97_STEREO_IN;
#endif /* WM_AC97 */

#if WM_I2S
	/* 
	 * WMAUDIO_I2S_STEREO_OUT:
	 * - Set up channel IDs
	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_I2S_STEREO_OUT;

	/* 
	 * WMAUDIO_I2S_STEREO_IN:
	 *  - Set up channel IDs
`	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_I2S_STEREO_IN;
#endif /* WM_I2S */

#if WM_VOICE
	/*
	 * WMAUDIO_VOICE_OUT:
	 * - Set up channel IDs
	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel  = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel  = WMAUDIO_VOICE_OUT;

	/*
	 * WMAUDIO_VOICE_IN:
	 * - Set up channel IDs
	 */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
	pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
	pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_VOICE_IN;
#endif /* WM_VOICE */

#if WM_MONODAC
    /* 
     * WMAUDIO_AC97_MONO_OUT:
     *  - Channel IDs 
     */
    ++nDMAChannel;
    WM_ASSERT( hDevice, nDMAChannel < (signed) WM_AVAILABLE_DMA_CHANNELS );
    pDMAContext->pDMAChannels[nDMAChannel].DMAChannel = UNKNOWN_DMA_CHANNEL;
    pDMAContext->pDMAChannels[nDMAChannel].APIChannel = WMAUDIO_AC97_MONO_OUT;
#endif /* WM_MONODAC */

    /*
     * Now assign the memory for the Buffers and Descriptors.
     */
    private_AssignDMAMemory( hDevice, pDMAContext, nDMAChannel );
}

/*-----------------------------------------------------------------------------
 * Function:    private_AssignDMAMemory
 *
 * Sets up the context to point at the buffers and descriptors.
 *
 * Parameters:
 *      hDevice         handle to the device (from WMOpenDevice)
 *      pDMAContext     pointer to the DMA context
 *      DMAChannels     the number of DMA channel to assign.
 *
 * Returns:     void
 *---------------------------------------------------------------------------*/
static void private_AssignDMAMemory( WM_DEVICE_HANDLE hDevice,
                                     DMAContext *pDMAContext,
                                     int DMAChannels
                                   )
{
    int DMAloop;
    int buffer1Offset = 0;
    int buffer2Offset = WMAUDIO_MAX_BUFFER_SIZE;
    int desc1Offset = 0;
    int desc2Offset = WMAUDIO_DMA_DESC_SIZE;

    for( DMAloop = 0; DMAloop <= DMAChannels; DMAloop++ )
    {
        /*  - DMA buffers - virtual. */
        pDMAContext->pDMAChannels[DMAloop].buffer1 =
            (void *)((unsigned long)
            pDMAContext->pDMABuffers_Virtual + buffer1Offset);

        pDMAContext->pDMAChannels[DMAloop].buffer2 =
            (void *)((unsigned long)
            pDMAContext->pDMABuffers_Virtual + buffer2Offset);

        /* - DMA buffers - physical. */
        pDMAContext->pDMAChannels[DMAloop].buffer1Physical =
            (void *)((unsigned long)
            pDMAContext->pDMABuffers_Physical + buffer1Offset);

        pDMAContext->pDMAChannels[DMAloop].buffer2Physical =
            (void *)((unsigned long)
            pDMAContext->pDMABuffers_Physical + buffer2Offset);

        buffer1Offset += WMAUDIO_MAX_BUFFER_SIZE * 2;
        buffer2Offset = buffer1Offset + WMAUDIO_MAX_BUFFER_SIZE;

        /* - DMA descriptors - virtual. */
        pDMAContext->pDMAChannels[DMAloop].desc1 =
            (XLLP_DMAC_DESCRIPTOR_T *)((unsigned long)
            pDMAContext->pDMADescriptors_Virtual + desc1Offset);

        pDMAContext->pDMAChannels[DMAloop].desc2 =
            (XLLP_DMAC_DESCRIPTOR_T *)((unsigned long)
            pDMAContext->pDMADescriptors_Virtual + desc2Offset);

        /* - DMA descriptors - physical. */
        pDMAContext->pDMAChannels[DMAloop].desc1Physical =
            (XLLP_DMAC_DESCRIPTOR_T *)((unsigned long)
            pDMAContext->pDMADescriptors_Physical + desc1Offset);

        pDMAContext->pDMAChannels[DMAloop].desc2Physical =
            (XLLP_DMAC_DESCRIPTOR_T *)((unsigned long)
            pDMAContext->pDMADescriptors_Physical + desc2Offset);

        desc1Offset += WMAUDIO_DMA_DESC_SIZE * 2;
        desc2Offset = desc1Offset + WMAUDIO_DMA_DESC_SIZE;
    }
}

/*-----------------------------------------------------------------------------
 * Function:    private_PrepareDeviceMapping
 *
 * Sets up the Device to DMA channel mapping.
 *
 * Parameters:
 *      hDevice     handle to the device (from WMOpenDevice)
 *      pDMAContext pointer to the DMA Context
 *
 * Returns:     void
 *---------------------------------------------------------------------------*/
static void private_PrepareDeviceMapping( WM_DEVICE_HANDLE hDevice,
                                          DMAContext *pDMAContext
                                        )
{
    /*
     * Check our tables.
     */
    WM_ASSERT( hDevice, WM_AVAILABLE_DMA_CHANNELS == 
									( WM_ARRAY_COUNT( s_ChannelDetails ) -1 ));

    pDMAContext->pChannelDetails = s_ChannelDetails;
}

#endif  /* WM_AUDIO_STREAM */

/*------------------------------ END OF FILE ---------------------------------*/