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

Module Name:

    psc_ac97.c

Module Description:

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

Author:

    Ian Rae  January 2004

Revision History:

--*/
#include <windows.h>
#include <bceddk.h>
#include <gpio.h>
#include "ac97.h"
#include "au1kac97.h"
#include "ac97aud.h"

#include <wavedbg.h>

#define ZONE_HACK 0

#define ZONE_AC97_ERROR ZONE_HACK
#define ZONE_AC97_FUNC  ZONE_HACK
#define ZONE_AC97_DMA   ZONE_HACK
#define ZONE_AC97_INTR  ZONE_HACK

ULONG gIntrAudio = SYSINTR_NOP;

extern HANDLE hAudioInterrupt;
extern PWAVE_DEVICE_INSTANCE WaveDevice;

BOOL
AC97ReadReg(
    IN PSC_AC97 *pAC97,
    IN ULONG    InReg,
    OUT ULONG   *Result
    )
{
    ULONG Data;
    ULONG Timeout=TIMEOUT*10;

	Data  = PSC_AC97_CDC_INDX_N(InReg);
	Data |= PSC_AC97_CDC_RD;

    WRITE_REGISTER_ULONG((PULONG)&pAC97->cdc, Data);

    while(Timeout) {
        if(READ_REGISTER_ULONG((PULONG)&pAC97->evnt)&PSC_AC97_EVNT_CD) break;
        Timeout--;
    }
	// Clear Command Done flag
	WRITE_REGISTER_ULONG((PULONG)&pAC97->evnt,PSC_AC97_EVNT_CD);


    if(Timeout) {
        Data = READ_REGISTER_ULONG((PULONG)&pAC97->cdc);
        Data &= PSC_AC97_CDC_DATA;
        *Result = Data;
        DEBUGMSG(ZONE_AC97_FUNC,(L"-Ac97ReadReg 0x%X\r\n",Data));
        return TRUE;
    }

    DEBUGMSG(ZONE_AC97_FUNC,(L"-Ac97ReadReg timeout\r\n"));
    return FALSE;
}    

BOOL
AC97WriteReg(
    IN PSC_AC97 *pAC97,
    IN ULONG    Reg,
    IN ULONG    Value
    )
{
    ULONG Data;
    ULONG Timeout=TIMEOUT*10;

    Data  = PSC_AC97_CDC_DATA_N(Value);
	Data |= PSC_AC97_CDC_INDX_N(Reg);
    
    WRITE_REGISTER_ULONG((PULONG)&pAC97->cdc, Data);

    while(Timeout) {
        if(READ_REGISTER_ULONG((PULONG)&pAC97->evnt)&PSC_AC97_EVNT_CD) break;
        Timeout--;
    }

	// Clear Command Done flag
	WRITE_REGISTER_ULONG((PULONG)&pAC97->evnt,PSC_AC97_EVNT_CD);

    if(Timeout) {
        return TRUE;
    }

    return FALSE;
}    

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

	HalStopDMA(WaveResource->DMAChannel);

   	EnterCriticalSection(&WaveResource->CriticalSection);

    if(WaveResource->WaveDirection==WAPI_OUT) {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->AC97Ctrl->pcr, PSC_AC97_PCR_TP);
    } else {
        WRITE_REGISTER_ULONG((PULONG)&WaveResource->AC97Ctrl->pcr, PSC_AC97_PCR_RP);
    }

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

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

}

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

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

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

}

DWORD
FindMicVolume(    
	IN PWAVE_DEVICE_INSTANCE WaveDevice
)
{
    HKEY    hkey;
    LONG Status;
    DWORD Value = AC97_DEFAULT_MICVOLUME;    
    DWORD Size = sizeof(Value);

	// Examine Mic Volume in registry
    //
    Status = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        AUDIO_REGKEY,
        0,
        0,
        &hkey);
    
    
    if (ERROR_SUCCESS == Status) {
        Status = RegQueryValueEx(hkey,
                                (TEXT("MicVolume")),
                                NULL,
                                NULL,
                                (PUCHAR)&Value,
                                &Size
                                );
    }

    if (hkey) {
        RegCloseKey(hkey);
    }

	return Value;
}


BOOL
InitializeInterrupt(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
	ULONG HwIntr;

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

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

	RETAILMSG(1,(TEXT("Hooking HWINTR %08X\r\n"),HwIntr));

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

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

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

BOOL InitializeRegisters(PSC_AC97 *pAC)
{
	int timeout;
	BOOL status = TRUE;
	ULONG tmp;

	// Handle any platform specific initialization
#if defined(PLATFORM_AC97_PSC_INIT_CODE)
	PLATFORM_AC97_PSC_INIT_CODE
#endif

	// We seem to need this to be able to resume more than once
	// still working on explaining exactly why that is...
	tmp = READ_REGISTER_ULONG((PULONG)&pAC->cfg);

	// Reset and configure the PSC for AC97
	WRITE_REGISTER_ULONG((PULONG)&pAC->psc.sel, PSC_SEL_PS_AC97 | PSC_SEL_CLK_SERIAL);
	
	// Reset external codec
	WRITE_REGISTER_ULONG((PULONG)&pAC->rst, PSC_AC97_RST_RST);
	HalStallExecution(10000);
	WRITE_REGISTER_ULONG((PULONG)&pAC->rst, 0);

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

	// wait for clock detect
	timeout = 1000;
	while (timeout && !((tmp=READ_REGISTER_ULONG((PULONG)&pAC->sts)) & PSC_AC97_STS_SR)) {
		HalStallExecution(1000);
		timeout--;
	}

	if (!timeout) {
		status = FALSE;
		goto ErrorReturn;
	}

	// configure the AC97 controller
	tmp = PSC_AC97_CFG_TRD_N(3) | 
	      PSC_AC97_CFG_RRD_N(3) | 
          PSC_AC97_CFG_LEN_N(7) | 
		  PSC_AC97_CFG_TXSLOT_N(3) | 
		  PSC_AC97_CFG_RXSLOT_N(3) | 
		  PSC_AC97_CFG_DE;

	WRITE_REGISTER_ULONG((PULONG)&pAC->cfg, tmp );

	// wait until the device is ready
	timeout = 1000;
	while (timeout && !((tmp=READ_REGISTER_ULONG((PULONG)&pAC->sts)) & PSC_AC97_STS_DR)) {
		HalStallExecution(1000);
		timeout--;
	}

	if (!timeout) {
		status = FALSE;
		goto ErrorReturn;
	}

	// mask all interrupts
	WRITE_REGISTER_ULONG((PULONG)&pAC->msk,0xFFFFFFFF);

ErrorReturn:
	return status;
}

BOOL
InitializePlatform(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
    PSC_AC97         *pAC;
	PHYSICAL_ADDRESS PhyAdd;
	BOOL             status = TRUE;
	HANDLE           hGPIO = NULL;

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

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

	WaveDevice->AC97Ctrl = MmMapIoSpace(PhyAdd,
								        sizeof(WaveDevice->AC97Ctrl),
								        FALSE);

	if(WaveDevice->AC97Ctrl==NULL) {
		DEBUGMSG(ZONE_AC97_ERROR,(L"Can not map AC97 Control registers\r\n"));
		goto ErrorReturn;
	}

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

	// CPU dependent GPIO pin functionality
#if defined(CPU_AU1550)
    if(!GPIO_SetPinFunction(hGPIO,SYS_PINFUNC_S1)) {
        DEBUGMSG(ZONE_ERROR,(L"AC97: Can not set pinfunc for AC97\r\n"));
        goto ErrorReturn;
    }
#elif defined(CPU_AU1200) && (PLATFORM_AC97_PSC==0)
    if(!GPIO_ClearPinFunction(hGPIO,SYS_PINFUNC_P0B | (1<<18))) {
        DEBUGMSG(ZONE_ERROR,(L"SPI: Can not set pinfunc for AC97 \r\n"));
        goto ErrorReturn;
    }
    if(!GPIO_SetPinFunction(hGPIO,(1<<17))) {
        DEBUGMSG(ZONE_ERROR,(L"SPI: Can not set pinfunc for AC97 \r\n"));
        goto ErrorReturn;
    }
#elif defined(CPU_AU1200) && (PLATFORM_AC97_PSC==1)
    if(!GPIO_ClearPinFunction(hGPIO,SYS_PINFUNC_P1A)) {
        DEBUGMSG(ZONE_ERROR,(L"AC97: Can not set pinfunc for AC97\r\n"));
        goto ErrorReturn;
    }
    if(!GPIO_SetPinFunction(hGPIO,SYS_PINFUNC_P1C)) {
        DEBUGMSG(ZONE_AC97_ERROR,(L"AC97: Can not set pinfunc for AC97\r\n"));
        goto ErrorReturn;
    }
#endif

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

	// find a Mic Volume
	WaveDevice->MicVolume = FindMicVolume(WaveDevice);

	pAC = WaveDevice->AC97Ctrl;
	
	status = InitializeRegisters(pAC);

	DEBUGMSG(ZONE_AC97_FUNC,(L"-Initialize Platform\r\n"));
    return status;

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

	if(hGPIO) {
		CloseHandle(hGPIO);
	}

	DEBUGMSG(ZONE_AC97_FUNC,(L"-Initialize Platform failed\r\n"));
	return FALSE;
}
  
BOOLEAN
InitializeCodec(
    IN OUT PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
    ULONG i;
    
    //
    //  Mute all channels 
    //
    for (i=AC97_ALT_LINE_LEVEL_OUT_VOLUME;i<=AC97_RECORD_GAIN;i+=2) {
        AC97WriteReg(WaveDevice->AC97Ctrl,i,VOLUME_MUTE);
    }

    //
    // Set True Stereo Line Out as 0dB
    //
    AC97WriteReg(WaveDevice->AC97Ctrl,AC97_ALT_LINE_LEVEL_OUT_VOLUME,0);
    AC97WriteReg(WaveDevice->AC97Ctrl,AC97_RECORD_GAIN,0x0f0f);

	// Set Mic Volume
    //
    AC97WriteReg(WaveDevice->AC97Ctrl,AC97_MIC_VOLUME,WaveDevice->MicVolume);

    //  Set PCM channel to default
    //
    AC97SetPCMOutVolume(WaveDevice->AC97Ctrl,  DEFAULT_PCM_VOLUME,   DEFAULT_PCM_VOLUME);

    return TRUE;
}


BOOL
InitializeDMA(
    IN PWAVE_DEVICE_INSTANCE WaveDevice
    )
{
    DEBUGMSG(ZONE_AC97_FUNC,(L"+InitializeDMA\r\n"));

    WaveDevice->DMAChannelOutput = HalAllocateDMAChannel();

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

    WaveDevice->DMAChannelInput = HalAllocateDMAChannel();

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

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

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

ErrorReturn:

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