// 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

// Always called within exec. function.

//

	{

	TPtr8 buf(aBuf,aLen);

	TInt r=iCurrentReq->ReadRemote(&buf,iCmdInOffset);

	return r;

	}

TInt DPcCardMediaDriverAta::ReadSectorsCommand(TUint aFirstSector,TUint aBufOffset,TInt aLen)

//

// Start off a read of multiple sectors from the drive (command completed under interrupt/dfc).

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:ReadSectors F:%x Off:%x L:%x",aFirstSector,aBufOffset,aLen));

	__ASSERT_DEBUG(aBufOffset<(TUint)KAtaSectorSize,Kern::PanicCurrentThread(_L("ReadSectorsCommand"),0));

	__ASSERT_DEBUG(aLen>0,Kern::PanicCurrentThread(_L("ReadSectorsCommand"),0));

	// Sector count - allow for not starting on sector boundary by adding buffer offset.  Allow for

	// not ending on sector boundary by adding sectorsize-1. Then divide by sector size.

	TInt tferSectorCount=(aLen+aBufOffset+KAtaSectorSizeMinusOne)>>KAtaSectorShift;

	iNextSector+=tferSectorCount;

	__ASSERT_DEBUG(tferSectorCount<=KMaxSectorsPerRead,Kern::PanicCurrentThread(_L("ReadSectorsCommand"),0));

	if (!iSocket->CardIsReady())

		return(KErrNotReady);

	AtaRegister8(KAtaStatusRd8);	// Clear any pending interrupt

	iSocket->InterruptEnable(EPccdIntIReq,0); // Enable card interrupt

	TInt err=IssueAtaCommand(KAtaCmdReadSectors,aFirstSector,tferSectorCount);

	if (err!=KErrNone)

		{

		iSocket->InterruptDisable(EPccdIntIReq); // Disable card interrupt

		iCardIreqDfc.Cancel();

		return err;

		}

	iCommandError=KErrNone;

	iNotBusyTickCount=KBusyTimeOut;

	iBusyTimeout.OneShot(NKern::TimerTicks(KNotBusyTestInterval));

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::InitiateWriteCommand(TUint aFirstSector,TInt aSectorCount,TUint8 *aSectBuffer)

//

// Start off an asynchronous write to the card. If successful, it leaves with a 

// timeout(ms timer) queued and card interrupts enabled.

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:InitWrCmd F:%x C:%x",aFirstSector,aSectorCount));

	__ASSERT_DEBUG((aSectorCount>0 && aSectorCount<=KMaxSectorsPerWrite),Kern::PanicCurrentThread(_L("InitiateWriteCommand"),0));

	TInt err=IssueAtaCommand(KAtaCmdWriteSectors,aFirstSector,aSectorCount);

	if (err!=KErrNone)

		return(err);

	if (!iSocket->CardIsReady())

		return(KErrNotReady);

	if (!WaitForNotBusy())

		return(ProcessError(KErrTimedOut));

	AtaRegister8(KAtaStatusRd8);	// Clear any pending interrupt

	iSocket->InterruptEnable(EPccdIntIReq,0); // Enable card interrupt

	err=EmptySectBufferToDrive(aSectBuffer);

	if (err!=KErrNone)

		{

		iSocket->InterruptDisable(EPccdIntIReq); // Disable card interrupt

		iCardIreqDfc.Cancel();

		return(ProcessError(err));

		}

	iCommandError=KErrNone;

	iNotBusyTickCount=KBusyTimeOut;

	iBusyTimeout.OneShot(NKern::TimerTicks(KNotBusyTestInterval));

	iNextSector+=aSectorCount;

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::SectorBoundaryReadCheck(TUint aStartSector,TUint aStartSectOffset,Int64 anEndPos)

//

// Check for write request which doesn't lie entirely on a sector boundary and perform

// the appropriate sectors reads prior to writing if necessary

//

	{

	TInt err;

	TUint endSectOffset=((TUint)anEndPos&(~KAtaSectorMask));

	anEndPos-=1;

	anEndPos>>=KAtaSectorShift;

	TUint endSector=(TUint)anEndPos; // Sector number can't exceed 32bits

	TInt sectors=(endSector-aStartSector)+1;

	iLastSectorBufUsed=EFalse;

	if (aStartSectOffset||endSectOffset)

		{

		// If it requires a read of two consecutive sectors then read them in one go

		if (aStartSectOffset && endSectOffset && sectors==2)

			return(SectorRead(aStartSector,&iSectorBuf[0],2,KAtaCmdReadSectors));

		else 

			{

			// If write starts off a sector boundary or is a single sector write ending 

			// off a sector boundary then read first sector

			if (aStartSectOffset || (endSectOffset && sectors==1))

				{

				if ((err=SectorRead(aStartSector,&iSectorBuf[0]))!=KErrNone)

					return(err);

				}

			// If write doesn't end on a sector boundary then read the last sector

			if (endSectOffset && sectors>1)

				{

				TUint8* p=iSectorBuf;

				if (sectors<=KMaxSectorsPerWrite)

					p+=(sectors-1)<<KAtaSectorShift;

				else

					{

					p=iLastSectorBuf;

					iLastSectorBufUsed=ETrue;

					}

				return(SectorRead(endSector,p));

				}

			}

		}

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::SectorRead(TUint aFirstSector,TUint8 *aBuf,TInt aSectorCount,TUint8 aCmd)

//

// Read either 1 or 2 sectors into the sector buffer (synchronously)

//

	{

	TInt err;

	if ( (err=IssueAtaCommand(aCmd,aFirstSector,aSectorCount))==KErrNone)

		{

		if (

			(err=TransferSectBufferFromDrive(aBuf))!=KErrNone||

			(aSectorCount>1&&(err=TransferSectBufferFromDrive((TAny*)(aBuf+KAtaSectorSize)))!=KErrNone)||

			(err=FinishCommand())!=KErrNone

		   )

			err=ProcessError(err);

		}

	if (!iSocket->CardIsReady())

		err=KErrNotReady; // If media change - return not ready rather than anything else.

	return(err);

	}

void DPcCardMediaDriverAta::DumpIdentifyDriveInfo()

//

// Debug option to display the drive indentification info.

//

	{

#ifdef _DEBUG

	if (KDebugNum(KPBUSDRV))

		{

		for (TInt i=0;i<128;i+=8)

			{

			Kern::Printf("%02x%02x %02x%02x %02x%02x %02x%02x",iSectorBuf[i],iSectorBuf[i+1],iSectorBuf[i+2],iSectorBuf[i+3],iSectorBuf[i+4],\

						iSectorBuf[i+5],iSectorBuf[i+6],iSectorBuf[i+7]);

			}

		}

#endif 

	}

TInt DPcCardMediaDriverAta::IdentifyDrive()

//

// Get drive charateristics

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:IdentifyDrive"));

	TInt err;

	if ((err=SectorRead(0,&iSectorBuf[0],1,KAtaCmdIdentifyDrive))!=KErrNone)

		return(err);

	DumpIdentifyDriveInfo();

	TBool lba=EFalse;

	Int64 s=0;

	if (*(TUint16*)(&iSectorBuf[KAtaIdCapabilities])&KAtaIdCapLbaSupported)

		{

		// Card indicates it supports LBA

		// Media size (in sectors) - 2 x halfwords @ KAtaIdTotalSectorsInLba.

		iDriveInfo.iTotalSectorsInLba=*(TInt*)(&iSectorBuf[KAtaIdTotalSectorsInLba]);

		s=iDriveInfo.iTotalSectorsInLba;

		s<<=KAtaSectorShift;

		if (s>0)

			lba=ETrue; // Epson PC card reports LBA supported but LBA size in bytes becomes zero

		} 

	iDriveInfo.iSupportsLba = lba;

	if (!lba)

		{

		// LBA not supported

		if (*(TUint16*)(&iSectorBuf[KAtaIdTranslationParams])&KAtaIdTrParamsValid)

			{

			// Current translation parameters are valid

			iDriveInfo.iCylinders=*(TUint16*)(&iSectorBuf[KAtaIdCurrentCylinders]);

			iDriveInfo.iHeads=*(TUint16*)(&iSectorBuf[KAtaIdCurrentHeads]);

			iDriveInfo.iSectorsPerTrack=*(TUint16*)(&iSectorBuf[KAtaIdCurrentSectorsPerTrack]);

			}

		else

			{ 

			// Use defaults

			iDriveInfo.iCylinders=*(TUint16*)(&iSectorBuf[KAtaIdDefaultCylinders]);

			iDriveInfo.iHeads=*(TUint16*)(&iSectorBuf[KAtaIdDefaultHeads]);

			iDriveInfo.iSectorsPerTrack=*(TUint16*)(&iSectorBuf[KAtaIdDefaultSectorsPerTrack]);

			} 

		iDriveInfo.iSectorsPerCylinder=(iDriveInfo.iHeads*iDriveInfo.iSectorsPerTrack);

		s=iDriveInfo.iCylinders;

		s*=iDriveInfo.iSectorsPerCylinder;

		s<<=KAtaSectorShift;

		if (iDriveInfo.iSectorsPerCylinder<=0||iDriveInfo.iSectorsPerTrack<=0)

			return(KErrCorrupt);

		}

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("LBA      : %xH",iDriveInfo.iSupportsLba));

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Cylinders: %xH",iDriveInfo.iCylinders));

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Heads    : %xH",iDriveInfo.iHeads));

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Sectors  : %xH",iDriveInfo.iSectorsPerTrack));

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<Ata:IdentifyDrive (TS:%lxH)",s));

	SetTotalSizeInBytes(s);

	return(KErrNone);

	}

TInt DPcCardMediaDriverAta::ConfigAutoPowerDown()

//

// Set auto power down period to something sensible

//

	{

	TInt err;

	if ( (err=IssueAtaCommand(KAtaCmdIdle,0,200))==KErrNone) // 200x5mS=1S (aFirstSector doesn't matter).

		{

		if ((err=FinishCommand())!=KErrNone)

			err=ProcessError(err);

		}

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<Ata:ConfigAutoPowerDown-%d",err));

	return(err);

	}

TInt DPcCardMediaDriverAta::DoOpen()

//

// Open the media driver.

//

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:DoOpen"));

	iCardIreqDfc.SetDfcQ(&iSocket->iDfcQ);

	iTimerDfc.SetDfcQ(&iSocket->iDfcQ);

	// Card ought to be ready but check we haven't had media change (this causes creation of card functions).

	TInt err=iSocket->CardIsReadyAndVerified();	// this may also fail with OOM or corrupt

	if (err!=KErrNone)

		return err;

	// Perform CIS validation - get back info. on card functions present. 

	TPccdType pt;

	if (iSocket->VerifyCard(pt)!=KErrNone)

		return(KErrUnknown);

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-Check for ATA function, FuncCount=%d",pt.iFuncCount));

	// Check for ATA fixed disk function.

	TCisReader cisRd; 

	TInt f;

	TBool isAta=EFalse;

	for (f=0;f<pt.iFuncCount;f++)

		{

		if (pt.iFuncType[f]==EFixedDiskCard)

			{

			// Fixed disk function - check its an ATA. 

			TBuf8<KLargeTplBufSize> tpl;

			cisRd.SelectCis(iSocket->iSocketNumber,f);

			// Must start just after FuncId tuple.

			if (cisRd.FindReadTuple(KCisTplFuncId,tpl)!=KErrNone)

				continue;

			while (cisRd.FindReadTuple(KCisTplFunce,tpl)==KErrNone)

				{

				if (tpl[2]==0x01 && tpl[3]==0x01)	// Interface type - ATA

					isAta=ETrue;

				}

			if (isAta)

				break;

			}

		}

	if (!isAta)

		return(KErrUnknown);

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-Is ATA"));

	// Determine best card configuration

	cisRd.Restart();

	TPcCardConfig cf;

	TInt opt=KInvalidConfOpt;

	while(cisRd.FindReadConfig(cf)==KErrNone)

		{

		if (

			 cf.IsMachineCompatible(iSocket->iSocketNumber,KPccdCompatNoVccCheck) && // Hitachi card has no 3.3V config entry

#if defined (SELECT_MEMORY_CONFIG)

			 (cf.iValidChunks==1 && __IS_COMMON_MEM(cf.iChnk[0].iMemType) && cf.iChnk[0].iMemLen==0x800)

#elif defined (SELECT_PRIMARY_IO_CONFIG)

			 (cf.iValidChunks==2 && __IS_IO_MEM(cf.iChnk[0].iMemType) && __IS_IO_MEM(cf.iChnk[1].iMemType) && cf.iChnk[0].iMemBaseAddr==0x1F0)

#else

			 // Choose 16 byte -  contiguous i/o option

			 (cf.iValidChunks==1 && __IS_IO_MEM(cf.iChnk[0].iMemType) && cf.iChnk[0].iMemLen==0x10)

#endif

		   ) 

			{

			opt=cf.iConfigOption;

			break;

			}

		}

	if (opt==KInvalidConfOpt)

		return(KErrNotSupported);

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-ConfigOpt(%d)",opt));

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-Pulsed Ints-%d",(cf.iInterruptInfo&KPccdIntPulse)));

	// Now configure the card. First configure it to memory mode. 

	cf.iConfigOption=0;

	err=iSocket->RequestConfig(f,this,cf,0);

	if (err!=KErrNone)

		return(err);

	if (cf.iRegPresent&KConfigAndStatusRegM)

		iSocket->WriteConfigReg(f,KConfigAndStatusReg,0); 

	if (cf.iRegPresent&KSocketAndCopyRegM)

		iSocket->WriteConfigReg(f,KSocketAndCopyReg,0);	// No twin cards

	iSocket->ReleaseConfig(f,this);

	cf.iConfigOption=(cf.iInterruptInfo&KPccdIntPulse)?opt:(opt|KConfOptLevIReqM);

//	cf.iConfigOption=(opt|KConfOptLevIReqM); // Force level mode interrupts

#if defined (FORCE_8BIT_ACCESSES)

#if defined (SELECT_MEMORY_CONFIG)

	cf.iChnk[0].iMemType=EPccdCommon8Mem;	// Force it to 8bit Common.

#else

	cf.iChnk[0].iMemType=EPccdIo8Mem;		// Force it to 8bit I/O.

#endif

#endif

	if ((err=iSocket->RequestConfig(f,this,cf,0))!=KErrNone)

		return(err);

	// Read back the config option register to verify it has been setup

	TUint8 v;

	if ((err=iSocket->ReadConfigReg(f,0,v))!=KErrNone||v!=(TUint8)cf.iConfigOption)

		return KErrBadPccdConfig;

	iCardFuncNum=f;

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-Configured(%1xH) OK",v));

	TUint flag=(cf.iActiveSignals&KSigWaitRequired)?KPccdRequestWait:0;

	err=iDriveChunk.Create(iSocket,cf.iChnk[0],cf.iAccessSpeed,flag);

	if (err!=KErrNone)

		return(err);

	iDriveChunk.SetupChunkHw();

	iMemoryType=cf.iChnk[0].iMemType;

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("Ata:DoOpen-Requested Mem OK"));

	iSocket->InterruptDisable(EPccdIntIReq);

	iCardIntCallBack.iSocket=iSocket;

	iCardIntCallBack.Add();

	SetAtaRegister8(0,KAtaDeviceCtlWr8);	// Enable interrupts

	SetCurrentConsumption(KIdleCurrentInMilliAmps);

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<Ata:DoOpen-OK"));

	return(KErrNone);

	}

TBool DPcCardMediaDriverAta::CardPoweredDown()

//

// Returns EFalse as long as card hasn't received power down (emergency or normal).

//

	{

	// Emergency power down may result in card being powered down before PC Card

	// Controller status is updated - check for EPD as well as PC Card Contoller.

	return(!Kern::PowerGood() || !iSocket->CardIsReady());

	}

void DPcCardMediaDriverAta::IncrementSectBufPtr()

//

//

//

	{

	iSectBufPtr+=KAtaSectorSize;

	if ((iSectBufPtr-&iSectorBuf[0])>=KSectBufSizeInBytes)

		iSectBufPtr=&iSectorBuf[0];

	}

TInt DPcCardMediaDriverAta::Request(TLocDrvRequest& m)

	{

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Ata:Req %08x id %d",&m,m.Id()));

	TInt r=KErrNotSupported;

	TInt id=m.Id();

	if (id==DLocalDrive::ECaps)

		{

		TLocalDriveCapsV6& c=*(TLocalDriveCapsV6*)m.RemoteDes();

		r=Caps(c);

		c.iSize=m.Drive()->iPartitionLen;

		c.iPartitionType=m.Drive()->iPartitionType;

		return r;

		}

	if (iCurrentReq)

		{

		// a request is already in progress, so hold on to this one

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Ata:Req %08x ret 1",&m));

		return KMediaDriverDeferRequest;

		}

	iCurrentReq=&m;

	switch (id)

		{

		case DLocalDrive::ERead:

			r=DoRead();

			break;

		case DLocalDrive::EWrite:

			r=DoWrite();

			break;

		case DLocalDrive::EFormat:

			r=DoFormat();

			break;

		case DLocalDrive::EEnlarge:

		case DLocalDrive::EReduce:

		default:

			r=KErrNotSupported;

			break;

		}

	__KTRACE_OPT(KLOCDRV,Kern::Printf("Ata:Req %08x cmp %d",&m,r));

	if (r!=KErrNone)

		iCurrentReq=NULL;

	return r;

	}

void DPcCardMediaDriverAta::NotifyPowerDown()

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:NotifyPowerDown"));

	Complete(KErrNotReady);

	Reset();

	}

void DPcCardMediaDriverAta::NotifyEmergencyPowerDown()

	{

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">Ata:NotifyEmergencyPowerDown"));

	TInt r=KErrNotReady;

	if (iCritical)

		r=KErrAbort;

	EndInCritical();

	Complete(r);

	Reset();

	}

void DPcCardMediaDriverAta::TimerDfcFunction(TAny* aPtr)

//

// DFC callback from not-busy timer

//

	{

	DPcCardMediaDriverAta &md=*(DPcCardMediaDriverAta*)aPtr;

	__KTRACE_OPT2(KPBUSDRV,KFAIL,Kern::Printf(">Ata:TimerDfcFunction TC:%d",md.iNotBusyTickCount));

	TInt r=1;

	if (!md.CardPoweredDown())

		{

		md.iDriveChunk.SetupChunkHw();

		TUint8 status=md.AtaRegister8(KAtaStatusRd8); // Clears interrupt

		if (!(status&KAtaStatusBusy))

			{

			// It is not-busy so process it as we would from an interrupt

			__KTRACE_OPT2(KPBUSDRV,KFAIL,Kern::Printf("Card not busy"));

			r=KErrNone;

#ifdef COUNT_TIMEOUTS

			++md.iTimeouts;

			md.iNewTimeOut=ETrue;

			if (md.iIndex<=6)

				{