// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\drivers\medata\pccd_ata.cpp

// 

//

#include "pbusmedia.h"

#include "platform.h"

#include "ata.h"

const TInt KErrBadDrqOnRead=-64;

const TInt KErrBadDrqOnWrite=-65;

const TInt KErrBadDrq=-66;

const TInt KErrAta=-67;

const TInt KErrBadPccdConfig=-68;

//const TInt KErrDriveChunkNotOpen=-69;

const TInt KAtaDriverPriority=KMediaDriverPriorityNormal;

//const TInt KAtaDriverPriority=KMediaDriverPriorityHigh;

_LIT(KPddName, "Media.Ata");

//_LIT(KPddName, "Media.Ata2");

// One of these

#define SELECT_CONTIGUOUS_IO_CONFIG

//#define SELECT_PRIMARY_IO_CONFIG

//#define SELECT_MEMORY_CONFIG

//#define FORCE_8BIT_ACCESSES

// Special debug options

//#define SHOW_CARD_ERRORS

//#define DEBUG_WITH_HW_TRIGGER

//#define COUNT_TIMEOUTS

#if (defined(SHOW_CARD_ERRORS))

#define __KTRACE_CARD_ERROR(a,p) {p;}

#elif (defined(_DEBUG))

#define __KTRACE_CARD_ERROR(a,p) {if((KDebugNum(a)))p;}

#else

#define __KTRACE_CARD_ERROR(a,p)

#endif

#include <pccard.h>

const TInt KMaxSectorsPerRead=32;

const TInt KMaxSectorsPerWrite=8;				 

const TInt KMaxSectorsPerFormat=8;				 

const TInt KMaxBytesPerRead=(KMaxSectorsPerRead<<KAtaSectorShift);

const TInt KMaxBytesPerWrite=(KMaxSectorsPerWrite<<KAtaSectorShift);

// Sector buffer size must be a multiple of sector size and at least as large

// as KMaxSectorsPerWrite.

const TInt KSectBufSizeInSectors=8;

const TInt KSectBufSizeInBytes=(KSectBufSizeInSectors<<KAtaSectorShift);

const TInt KSectBufSizeInBytesMinusOneSector=(KSectBufSizeInBytes-KAtaSectorSize);

const TInt KIdleCurrentInMilliAmps=1; 

const TInt KReadCurrentInMilliAmps=39;

const TInt KWriteCurrentInMilliAmps=46;

const TInt KNotBusySyncTimeout=5;

const TInt KNotBusySyncRetryCount=10;

const TInt KDriveReadySyncTimeout=5;

#ifdef _DEBUG

const TInt KNotBusyTestInterval=30;		// Check for not-busy once every 30ms

const TInt KBusyTimeOut=67;				// Timeout after this many tests (67*30ms=2010ms)

#else

const TInt KNotBusyTestInterval=5;		// Check for not-busy once every 5ms

const TInt KBusyTimeOut=400;			// Timeout after this many tests (400*5ms=2010ms)

#endif

class DPhysicalDeviceMediaAta : public DPhysicalDevice

	{

public:

	DPhysicalDeviceMediaAta();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aDeviceType, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Info(TInt aFunction, TAny* a1);

	};

class DPcCardMediaDriverAta : public DMediaDriver

	{

public:

	DPcCardMediaDriverAta(TInt aMediaId);

	virtual TInt Request(TLocDrvRequest& aRequest);

	virtual TInt PartitionInfo(TPartitionInfo& anInfo);

	virtual void NotifyPowerDown();

	virtual void NotifyEmergencyPowerDown();

	virtual void Close();

public:

	enum TCardStatus {ECardIdle,ECardRead,ECardWrite,ECardFormat};

	inline TUint8 AtaRegister8(TUint aReg);

	inline void SetAtaRegister8(TUint8 aValue,TUint aReg);

	void ModifyAtaRegister8(TUint aClearMask,TUint aSetMask,TUint aReg);

	void SelectDrive(TAtaDriveSelect aDrive);

	TBool WaitForNotBusy();

	TBool DriveReadyForCommand(TInt aDrive);

	void SetLbaSectorAddress(TUint aSector);

	void SetChsSectorAddress(TUint aSector);

	TInt IssueAtaCommand(TUint8 aCmd,TUint aFirstSector,TInt aSectorCount);

	TInt EmptySectBufferToTrg(TUint8 *aSrc,TUint aTrgOffset,TInt aLen);

	TInt LoadSectBufferFromSrc(TInt aLen, TUint8* aBuf);

	TInt LoadSectBufferFromDrive(TAny *aBuf);

	TInt EmptySectBufferToDrive(TUint8 *aBuf);

	TInt TransferSectBufferFromDrive(TAny *aBuf);

	TInt FinishCommand();

	TInt CheckForError();

	TInt ProcessError(TInt anError);

	TInt SectorBoundaryReadCheck(TUint aStartSector,TUint aStartSectOffset,Int64 anEndPos);

	TInt SectorRead(TUint aFirstSector,TUint8 *aBuf,TInt aSectorCount=1,TUint8 aCmd=KAtaCmdReadSectors);

	TInt CheckDevice(TBool aCheckPower);

	TInt InitiateWriteCommand(TUint aFirstSector,TInt aSectorCount,TUint8 *aSectBuffer);

	TInt ReadSectorsCommand(TUint aFirstSector,TUint aBufOffset,TInt aLen);

	TInt IdentifyDrive();

	void DumpIdentifyDriveInfo();

	TInt ConfigAutoPowerDown();

	TInt Open();

	TInt DoOpen();

	void DoClose();

	void Reset();

	TBool CardPoweredDown();

	void IncrementSectBufPtr();

	static void CardIreqDfcFunction(TAny* aPtr);

	static void TimerDfcFunction(TAny* aPtr);

	static void AsyncBusyTimerCallBack(TAny* aMediaDriver);

	static void SyncBusyTimerCallBack(TAny* aBusyFlag);

	static void CardIntCallBack(TAny* aPtr, TInt anId);

	TBool DoCardNotBusy(TInt &anErr);

	TBool CmdDfc();

	TBool DoCmdDfc(TInt &anErr);

	void Complete(TInt anError);

	TInt Caps(TLocalDriveCapsV6& anInfo);

	TInt DoRead();

	TInt DoWrite();

	TInt DoFormat();

	TInt InitiateAsyncRead();

	TInt InitiateAsyncWrite();

public:

	DPcCardSocket* iSocket;

	TLocDrvRequest* iCurrentReq;

	TPBusCallBack iCardIntCallBack;

	RPccdWindow iDriveChunk;

	TPccdMemType iMemoryType;

	TDriveParameters iDriveInfo;

	NTimer iBusyTimeout;

	TDfc iCardIreqDfc;

	TDfc iTimerDfc;

	TInt iNotBusyTickCount;

	TInt iCommandError;

	TCardStatus iCardStatus;

	TUint iCmdInOffset; 	// Progress counter for data received from src device

	TUint iCmdOutOffset;	// Progress counter for data delivered to target device

	TUint iCmdEndOffset;	// Marks point when transfer associated with command is complete

	TUint iCmdLength;		// Transfer length remaining

	TUint iNextSector;		// Next sector to transfer

	TUint8 *iSectBufPtr;	// Progress counter for tranfering data between card and sector buffer

	TUint iSectBufOffset;	// Offset within sector buffer to start of data involved in command (Reads only)

	TBool iLastSectorBufUsed;

	TUint iHiddenSectors;

	TInt iCardFuncNum;

	TUint8 iSectorBuf[KSectBufSizeInBytes]; // Keep on 4byte boundary - put this last

	TUint8 iLastSectorBuf[KAtaSectorSize];	// Holds last sector data for unaligned write

#if (defined(_DEBUG) || defined(SHOW_CARD_ERRORS))

	TInt iDbgLastError;

	TInt iDbgPos;

	TInt iDbgLen;

#endif

#ifdef COUNT_TIMEOUTS

	TInt iInts;

	TInt iTimeouts;

	TInt iImmediateNotBusy;

	TInt iChainedReads;

	TInt iChainedWrites;

	TBool iNewTimeOut;

	TInt iIndex;

	TInt iInfo[8];

#endif

	};

void DPcCardMediaDriverAta::Complete(TInt anError)

	{

	__KTRACE_OPT(KFAIL,Kern::Printf("mdrqc %08x %d",iCurrentReq,anError));

#ifdef COUNT_TIMEOUTS

	if (iNewTimeOut)

		{

		iNewTimeOut=EFalse;

		Kern::Printf("I=%d T=%d M=%d CR=%d CW=%d",iInts,iTimeouts,iImmediateNotBusy,iChainedReads,iChainedWrites);

		TInt i;

		for (i=0; i<iIndex; i+=2)

			Kern::Printf("%d: %08x %08x",i,iInfo[i],iInfo[i+1]);

		iIndex=0;

		}

#endif

	TLocDrvRequest* pR=iCurrentReq;

	if (pR)

		{

		iCurrentReq=NULL;

		DMediaDriver::Complete(*pR,anError);

		}

	}

inline TUint8 DPcCardMediaDriverAta::AtaRegister8(TUint aReg)

//

// Read from an 8 bit ATA register

//

	{

	return iDriveChunk.Read8(aReg);

	}

inline void DPcCardMediaDriverAta::SetAtaRegister8(TUint8 aValue,TUint aReg)

//

// Write to an 8 bit ATA register

//

	{

	iDriveChunk.Write8(aReg,aValue);

	}

void DPcCardMediaDriverAta::ModifyAtaRegister8(TUint aClearMask,TUint aSetMask,TUint aReg)

//

// Modify an 8 bit ATA register

//

	{

	SetAtaRegister8((TUint8)((AtaRegister8(aReg)&(~aClearMask))|aSetMask),aReg);

	}

void DPcCardMediaDriverAta::SelectDrive(TAtaDriveSelect aDrive)

//

// Modify an 8 bit ATA register

//

	{

	ModifyAtaRegister8(KAtaDrvHeadDrive1,(0xA0|aDrive),KAtaSelectDriveHeadRdWr8);

	}

TBool DPcCardMediaDriverAta::WaitForNotBusy()

//

// Poll busy flag (while card accesses the data buffer and command register). 

// 8mS timeout.

//

	{

	// Before we start a timed loop, just check it isn't already not busy

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("WfnB"));

	if (!(AtaRegister8(KAtaStatusRd8)&KAtaStatusBusy))

		return(ETrue);

#if (defined(_DEBUG) || defined(SHOW_CARD_ERRORS))

	TUint c=NKern::TickCount();

#endif

	volatile TBool timedOut=EFalse;

	NTimer busyTimeout(SyncBusyTimerCallBack,(TAny*)&timedOut);

	busyTimeout.OneShot(NKern::TimerTicks(KNotBusySyncTimeout));

	FOREVER

		{

		if (!(AtaRegister8(KAtaStatusRd8)&KAtaStatusBusy)||timedOut)

			break;

		}

	if (!timedOut)

		busyTimeout.Cancel();

	else

		{

		TInt retry=KNotBusySyncRetryCount;

		while ((AtaRegister8(KAtaStatusRd8)&KAtaStatusBusy) && retry)

			{

			NKern::Sleep(1);

			retry--;

			}

		}

	TBool ret=(AtaRegister8(KAtaStatusRd8) & KAtaStatusBusy);

#if (defined(_DEBUG) || defined(SHOW_CARD_ERRORS))

	c=NKern::TickCount()-c;

	if (ret)

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("<Ata:WaitForNotBusy-timeout(%xH) %d ms",AtaRegister8(KAtaStatusRd8),c));

 		}

	else

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("<Ata:WaitForNotBusy-OK %d ms",c));

		}

#endif

	return(!ret);

	}

TBool DPcCardMediaDriverAta::DriveReadyForCommand(TInt aDrive)

//

// Wait until selected drive is able to accept a command (5ms timeout).

//					

	{

	// Select the drive were waiting on 

	SelectDrive((aDrive==1)?ESelectDrive1:ESelectDrive0);

	if (!WaitForNotBusy())

		return(EFalse);

	volatile TBool timedOut=EFalse;

	NTimer busyTimeout(SyncBusyTimerCallBack,(TAny*)&timedOut);

	busyTimeout.OneShot(NKern::TimerTicks(KDriveReadySyncTimeout));

	FOREVER

		{

		if (AtaRegister8(KAtaStatusRd8)&KAtaStatusRdy||timedOut)

			break;

		}

	if (!timedOut)

		busyTimeout.Cancel();

	TBool ret=(AtaRegister8(KAtaStatusRd8) & KAtaStatusRdy);

#if (defined(_DEBUG) || defined(SHOW_CARD_ERRORS))

	if (!ret)

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("<Ata:DriveReadyForCommand-Fail(%xH)",AtaRegister8(KAtaStatusRd8)));

#endif

	return(ret);

	}

void DPcCardMediaDriverAta::SetLbaSectorAddress(TUint aSector)

//

// Setup the sector address ATA registers (LBA mode)

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:SetLbaSectorAddress (LBA: %xH)",aSector));

	SetAtaRegister8((TUint8)aSector,KAtaLba7_0RdWr8);

	SetAtaRegister8((TUint8)(aSector>>8),KAtaLba15_8RdWr8);

	SetAtaRegister8((TUint8)(aSector>>16),KAtaLba23_16RdWr8);

	TUint8 lba27_24=(TUint8)((aSector>>24)&0x0F);

	ModifyAtaRegister8(KAtaDrvHeadLba27_24,(KAtaDrvHeadLbaOn|lba27_24),KAtaSelectDriveHeadRdWr8);

	}

void DPcCardMediaDriverAta::SetChsSectorAddress(TUint aSector)

//

// Setup the sector address ATA registers (CHS mode)

//

	{

	TUint cylinder=0,head=0,sector=1;

	if (iDriveInfo.iSectorsPerCylinder>0&&iDriveInfo.iSectorsPerTrack>0)

		{

		cylinder=aSector/iDriveInfo.iSectorsPerCylinder;

		TUint remainder=aSector%iDriveInfo.iSectorsPerCylinder;

		head=remainder/iDriveInfo.iSectorsPerTrack;

		sector=(remainder%iDriveInfo.iSectorsPerTrack)+1;

		}

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:SetChsSectorAddress (C: %xH H: %xH S: %xH)",cylinder,head,sector));

	SetAtaRegister8((TUint8)sector,KAtaSectorNoRdWr8);

	SetAtaRegister8((TUint8)cylinder,KAtaCylinderLowRdWr8);

	SetAtaRegister8((TUint8)(cylinder>>8),KAtaCylinderHighRdWr8);

	ModifyAtaRegister8((KAtaDrvHeadLbaOn|KAtaDrvHeadLba27_24),((TUint8)(head&0x0F)),KAtaSelectDriveHeadRdWr8);

	}

TInt DPcCardMediaDriverAta::IssueAtaCommand(TUint8 aCmd,TUint aFirstSector,TInt aSectorCount)

//

// Issue an ATA command (Drive 0 only for now).

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:IssueAtaCommand(C:%x, FS:%x, SC:%x)",aCmd,aFirstSector,aSectorCount));

	__KTRACE_OPT(KFAIL,Kern::Printf("A%02x,%d",aCmd,aSectorCount));

	if (!WaitForNotBusy())

		return(KErrTimedOut);

	if (!DriveReadyForCommand(0))

		return KErrTimedOut;

	if (aSectorCount==KMaxSectorsPerCmd)

		aSectorCount=0;

	SetAtaRegister8((TUint8)aSectorCount,KAtaSectorCountRdWr8);

	if (iDriveInfo.iSupportsLba)

		SetLbaSectorAddress(aFirstSector);

	else

		SetChsSectorAddress(aFirstSector);

	__TRACE_TIMING(0x103);

	SetAtaRegister8(aCmd,KAtaCommandWr8);	// Issue the command

	Kern::NanoWait(400);					// Busy flag not asserted for 400ns

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<Ata:IssueAtaCommand"));

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::LoadSectBufferFromDrive(TAny *aBuf)

//

// Read a sector from the ATA card

//

	{

	if (!(AtaRegister8(KAtaStatusRd8)&KAtaStatusDrq))

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf(">Ata:LoadSectBufferFromDrive-Bad drq(%xH)",AtaRegister8(KAtaStatusRd8)));

		return KErrBadDrqOnRead;

		}

	if (__IS_COMMON_MEM(iMemoryType))

		iDriveChunk.Read(KAtaDataRdWrWinBase16,aBuf,KAtaSectorSize); // Use 1K window

	else if (iMemoryType==EPccdIo16Mem)

		iDriveChunk.ReadHWordMultiple(KAtaDataRdWr16,aBuf,(KAtaSectorSize>>1));

	else

		iDriveChunk.ReadByteMultiple(KAtaDataRdWr8,aBuf,KAtaSectorSize); // Must be EPccdIo8Mem

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::TransferSectBufferFromDrive(TAny *aBuf)

//

// Read a sector from the ATA card

//

	{

	if (!WaitForNotBusy())

		return(KErrTimedOut);

	return(LoadSectBufferFromDrive(aBuf));

	}

TInt DPcCardMediaDriverAta::EmptySectBufferToDrive(TUint8 *aBuf)

//

// Write a sector to the ATA card.

//

	{

	if (!(AtaRegister8(KAtaStatusRd8)&KAtaStatusDrq))

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf(">Ata:EmptySectBufferToDrive-Bad drq(%xH)",AtaRegister8(KAtaStatusRd8)));

		return KErrBadDrqOnWrite;

		}

	if (__IS_COMMON_MEM(iMemoryType))

		iDriveChunk.Write(KAtaDataRdWrWinBase16,aBuf,KAtaSectorSize); // Use 1K window

	else if (iMemoryType==EPccdIo16Mem)

		iDriveChunk.WriteHWordMultiple(KAtaDataRdWr16,aBuf,(KAtaSectorSize>>1));

	else

		iDriveChunk.WriteByteMultiple(KAtaDataRdWr8,aBuf,KAtaSectorSize); // Must be EPccdIo8Mem

	return(KErrNone); 

	}

TInt DPcCardMediaDriverAta::FinishCommand()

//

// Called each time a command has been issued to check if an error occured.

//

	{

	if (!WaitForNotBusy())

		return(KErrTimedOut);

	return(CheckForError());

	}

TInt DPcCardMediaDriverAta::CheckForError()

//

// Called each time a command has been issued to check if an error occured.

//

	{

	TUint8 status=AtaRegister8(KAtaStatusRd8);

	if (status&KAtaStatusDrq)

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("Ata:CheckForError-DRQ fail"));

		return KErrBadDrq;

		}

	if (status&KAtaStatusDwf)

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("Ata:CheckForError-DWF fail"));

		return(KErrWrite);	

		}

	if (status&KAtaStatusErr)

		{

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("Ata:CheckForError-ERR fail"));

		return KErrAta;

		}

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::ProcessError(TInt anError)

//

// An error has occured - lets get more information

//

	{

	if (anError==KErrAta&&AtaRegister8(KAtaStatusRd8)&KAtaStatusErr)

		{

		TUint8 basic=AtaRegister8(KAtaErrorRd8);

#if (defined(__EPOC32__) && (defined(_DEBUG) || defined(SHOW_CARD_ERRORS)))

		TUint8 extended=0xFF;		// invalid

		SetAtaRegister8(KAtaCmdRequestSense,KAtaCommandWr8);	// Issue command - request sense

		Kern::NanoWait(400);					// Busy flag not asserted for 400ns

		WaitForNotBusy();

		if (!(AtaRegister8(KAtaStatusRd8)&KAtaStatusErr))

			extended=AtaRegister8(KAtaErrorRd8);

		__KTRACE_CARD_ERROR(KPBUSDRV,Kern::Printf("Ata:ProcessError-Basic:%xH Ext:%xH)",basic,extended));

#endif 

		if (basic&KAtaErrorUnc)

			return(KErrDied);

		else if (basic&(KAtaErrorBbk|KAtaErrorIdnf))

			return(KErrCorrupt);

		else if (basic&KAtaErrorAbort)

			return(KErrCancel);

		else

			return(KErrUnknown);

		}

	else

		return(anError);

	}

TInt DPcCardMediaDriverAta::EmptySectBufferToTrg(TUint8 *aSrc,TUint aTrgOffset,TInt aLen)

//

// Empty data from sector buffer (at specified offset within buffer) into

// destination descriptor.

//

	{

	TPtrC8 buf(aSrc,aLen);

	return iCurrentReq->WriteRemote(&buf,aTrgOffset);

	}

TInt DPcCardMediaDriverAta::LoadSectBufferFromSrc(TInt aLen, TUint8* aBuf)

//

// Load data from source descriptor into sector buffer