/*++
Copyright (c) 2004  BSQUARE Corporation.  All rights reserved.

Module Name:

    psc_i2s.c

Module Description:

    This module contains the platform dependent code
    of I2S audio driver for the Au1550

Author:

    Ian Rae  January 2004

Revision History:

--*/
#include <windows.h>
#include <bceddk.h>
#include "gpio.h"
#include "psc_i2s.h"

#include <wavedbg.h>

//#undef  DEBUGMSG
//#define DEBUGMSG(cond, msg)  RETAILMSG(1,msg)

#define ZONE_I2S_ERROR 1 
#define ZONE_I2S_FUNC  1
#define ZONE_I2S_DMA   1 
#define ZONE_I2S_INTR  1

ULONG gIntrAudio = SYSINTR_NOP;

extern HANDLE hAudioInterrupt;
extern PWAVE_DEVICE_INSTANCE WaveDevice;

BOOL
SMBusWriteReg(
    IN HANDLE hSMBus,
    IN UCHAR  Reg,
    IN USHORT Value
    )
{
	SMBUS_TRANSFER Transfer;

	Transfer.Address = SMBUS_ADDR_WM8731;
	Transfer.Register = (Reg << 1) | ((Value & 0x100) >> 8);
	Transfer.Data[0] = Value & 0xFF;
	Transfer.DataSize = 1;

	return SMBus_WriteData(hSMBus, &Transfer);
}    

VOID
ShutdownDma(
    IN PWAVE_RESOURCE WaveResource
    )
{
    DEBUGMSG(ZONE_I2S_FUNC, (TEXT("+ShutdownDma\r\n")));

	HalStopDMA(WaveResource->DMAChannel);

   	EnterCriticalSection(&WaveResource->CriticalSection);

    if(WaveResource->WaveDirection==WAPI_OUT) {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->pI2S->pcr, PSC_I2S_PCR_TP);
    } else {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->pI2S->pcr, PSC_I2S_PCR_RP);
    }

	WaveResource->DmaRunning = FALSE;
    
	LeaveCriticalSection(&WaveResource->CriticalSection);

	DEBUGMSG(ZONE_I2S_FUNC, (TEXT("-ShutdownDma\r\n")));

}

VOID
StartDma(
    IN PWAVE_RESOURCE WaveResource
    )
{
    DEBUGMSG(ZONE_I2S_FUNC, (TEXT("+StartDma\r\n")));

    EnterCriticalSection(&WaveResource->CriticalSection);
    
    if(WaveResource->WaveDirection==WAPI_OUT) {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->pI2S->pcr, PSC_I2S_PCR_TS);
    } else {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->pI2S->pcr, PSC_I2S_PCR_RS);
    }
    
	HalStartDMA(WaveResource->DMAChannel);
    
	WaveResource->DmaRunning = TRUE;
    LeaveCriticalSection(&WaveResource->CriticalSection);

    DEBUGMSG(ZONE_I2S_FUNC, (TEXT("-StartDma \r\n")));

}

BOOL
InitializeInterrupt(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
	ULONG HwIntr;

    DEBUGMSG(ZONE_I2S_FUNC,(L"+Initialize Interrupt\r\n"));

    HwIntr = HalGetDMAHwIntr(WaveDevice->DMAChannelOutput);
	HwIntr |= HalGetDMAHwIntr(WaveDevice->DMAChannelInput) << 8;

	gIntrAudio = InterruptConnect(Internal, 0, HwIntr, 0);

	if (gIntrAudio == SYSINTR_NOP)
	{
		RETAILMSG(1,(L"Can not allocate SYSINTR\r\n"));
		goto ErrorReturn;
	}

	DEBUGMSG(ZONE_I2S_FUNC,(L"-Initialize Interrupt\r\n"));
	return TRUE;
ErrorReturn:
	DEBUGMSG(ZONE_I2S_FUNC,(L"-Initialize Interrupt failed\r\n"));
	return FALSE;
}

BOOL
InitializeRegisters(PSC_I2S *pI2S)
{
	ULONG timeout;
	BOOL  status = TRUE;

	// Reset and configure the PSC for I2S
	WRITE_REGISTER_ULONG((PULONG)&pI2S->psc.sel, PSC_SEL_PS_I2S | PSC_SEL_CLK_OFFCHIP);

	// Enable the PSC
	WRITE_REGISTER_ULONG((PULONG)&pI2S->psc.ctl, PSC_CTL_CE);
	WRITE_REGISTER_ULONG((PULONG)&pI2S->psc.ctl, PSC_CTL_CE |PSC_CTL_EN);

	// wait for clock detect
	timeout = 50;
	while (timeout && !(READ_REGISTER_ULONG((PULONG)&pI2S->sts) & PSC_I2S_STS_SR)) {
		HalStallExecution(1000);
		timeout--;
	}

	if (!timeout) {
		RETAILMSG(1,(TEXT("Failed waiting for SR\r\n")));
		status = FALSE;
		goto ErrorReturn;
	}

	// Configure the PSC
	WRITE_REGISTER_ULONG((PULONG)&pI2S->cfg, PSC_I2S_CFG_WS_N(63) |
									         PSC_I2S_CFG_BI |
									         PSC_I2S_CFG_XM |
									         PSC_I2S_CFG_LEN_N(15) |
									         PSC_I2S_CFG_TBS_N(3) |
									         PSC_I2S_CFG_RBS_N(3) |
									         PSC_I2S_CFG_DE );

	// mask all interrupts
	WRITE_REGISTER_ULONG((PULONG)&pI2S->msk,0xffffffff);

	// wait unti the device is ready
	timeout = 50;
	while (timeout && !(READ_REGISTER_ULONG((PULONG)&pI2S->sts) & PSC_I2S_STS_DR)) {
		HalStallExecution(1000);
		timeout--;
	}

	if (!timeout) {
		RETAILMSG(1,(TEXT("Failed waiting for DR\r\n")));
		status = FALSE;
		goto ErrorReturn;
	}

ErrorReturn:
	return status;
}

BOOL
InitializePlatform(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
	PHYSICAL_ADDRESS PhyAdd;
	HANDLE           hGPIO = NULL;

	RETAILMSG(ZONE_I2S_FUNC,(TEXT("+PSC_I2S InitializePlatform\r\n")));

#if (PLATFORM_I2S_PSC==0)
	PhyAdd.QuadPart = PSC0_PHYS_ADDR;
#elif (PLATFORM_I2S_PSC==1)
	PhyAdd.QuadPart = PSC1_PHYS_ADDR;
#elif (PLATFORM_I2S_PSC==2)
	PhyAdd.QuadPart = PSC2_PHYS_ADDR;
#elif (PLATFORM_I2S_PSC==3)
	PhyAdd.QuadPart = PSC3_PHYS_ADDR;
#else
#error PLATFORM_I2S_PSC must be defined in the range 0 to 3
#endif

	RETAILMSG(1,(L"Initializing PSC%d for I2S operation\r\n",PLATFORM_I2S_PSC));

	WaveDevice->pI2S = MmMapIoSpace(PhyAdd,
								    sizeof(WaveDevice->pI2S),
								    FALSE);
	if(WaveDevice->pI2S==NULL) {
		DEBUGMSG(ZONE_I2S_ERROR,(L"Can not map I2S Control registers\r\n"));
		goto ErrorReturn;
	}

    hGPIO = GPIO_Init();
    if(hGPIO==INVALID_HANDLE_VALUE) {
        DEBUGMSG(ZONE_I2S_ERROR,(L"I2S: Can not open GPIO device\r\n"));
        goto ErrorReturn;
    }

	// CPU dependent GPIO pin functionality
#if defined(CPU_AU1200) && (PLATFORM_I2S_PSC==0)
    if(!GPIO_ClearPinFunction(hGPIO,SYS_PINFUNC_P0A | SYS_PINFUNC_P0B)) {
        DEBUGMSG(ZONE_I2S_ERROR,(L"I2S: Can not set pinfunc for I2S\r\n"));
        goto ErrorReturn;
    }
#elif defined(CPU_AU1200) && (PLATFORM_I2S_PSC==1)
    if(!GPIO_ClearPinFunction(hGPIO,SYS_PINFUNC_P1A | SYS_PINFUNC_P1B)) {
        DEBUGMSG(ZONE_I2S_ERROR,(L"I2S: Can not set pinfunc for I2S\r\n"));
        goto ErrorReturn;
    }
#endif

	// Handle any platform specific initialization, GPIO handle available if needed
#if defined(PLATFORM_I2S_PSC_INIT_CODE)
	PLATFORM_I2S_PSC_INIT_CODE
#endif

	// we are done with GPIO now
	CloseHandle(hGPIO);

	// Get a handle to the SMBus
	WaveDevice->hSMBus = SMBus_Initialize();

	// Reset external codec
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_RR, RR_RESET);

	// Configure external codec
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_DAPC, DAPC_DEEMP_44);
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_SC, SC_SR_N(8));	// set for 44.1 DAC and ADC
	                                                            // with the Pb1550s 12MHz this will
																// be ~6% fast
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_DAIF, DAIF_FORMAT_I2S |
	                                               DAIF_IWL_16 |
												   DAIF_LRP );
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_AAPC, AAPC_INSEL | AAPC_MICBOOST |
	                                               AAPC_DACSEL);
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_AC, AC_ACTIVE);
	SMBusWriteReg(WaveDevice->hSMBus, WM8731_PDC, 0x00);	

	InitializeRegisters(WaveDevice->pI2S);

	DEBUGMSG(ZONE_I2S_FUNC,(L"-Initialize Platform\r\n"));
    return TRUE;


ErrorReturn:
	if(WaveDevice->pI2S) {
		MmUnmapIoSpace((PVOID)WaveDevice->pI2S, sizeof(*WaveDevice->pI2S));
	}

	if(WaveDevice->hSMBus) {
		CloseHandle(WaveDevice->hSMBus);
	}

	if(hGPIO) {
		CloseHandle(hGPIO);
	}

	DEBUGMSG(ZONE_I2S_FUNC,(L"-Initialize Platform failed\r\n"));
	return FALSE;
}
  
BOOL
InitializeDMA(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
    DEBUGMSG(ZONE_I2S_FUNC,(L"+InitializeDMA\r\n"));

    WaveDevice->DMAChannelOutput = HalAllocateDMAChannel();

    if(WaveDevice->DMAChannelOutput==NULL) {
        DEBUGMSG(ZONE_I2S_ERROR,(L"Can not allocate output DMA Channel\r\n"));
        goto ErrorReturn;
    } else {
        DEBUGMSG(1,(L"Using DMA channel for I2S output\r\n"));
    }
    
    HalInitDmaChannel(WaveDevice->DMAChannelOutput,
	                  DMA_I2S_TX,
	                  WaveDevice->DmaBufferSize,
					  TRUE);

    WaveDevice->DMAChannelInput = HalAllocateDMAChannel();

    if(WaveDevice->DMAChannelInput==NULL) {
        DEBUGMSG(ZONE_I2S_ERROR,(L"Can not allocate input DMA Channel\r\n"));
        goto ErrorReturn;
    } else {
        DEBUGMSG(1,(L"Using DMA channel for I2S input\r\n"));
    }

    HalInitDmaChannel(WaveDevice->DMAChannelInput,
	                  DMA_I2S_RX,
	                  WaveDevice->DmaBufferSize,
					  TRUE);

    DEBUGMSG(ZONE_I2S_FUNC,(L"-InitializeDMA\r\n"));    
    return TRUE;

  ErrorReturn:

    DEBUGMSG(ZONE_I2S_FUNC,(L"-InitializeDMA failed\r\n"));    
    return FALSE;
}