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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include "plat_priv.h"

#include <property.h>

#include <variant.h>

#include "pp_sdio.h" 

const TInt  KDiskSectorSize=512;

const TInt KTotalMDiskSize=0x100000; // 1MB (if changing this then also change CSD response)

// ======== Register Map ========

typedef TInt (*TAccessFunction)(TInt aTargetCard, TInt aVal, TAny* aThis, TBool aRead, TUint8& aData);

const TInt KIoMapEnd = 0xFFFFFFFF;

struct SRegisterMapInfo

	{

public:

	TUint32 iRegisterID;				// Unique ID

	const SRegisterMapInfo* iChildMapP; // Pointer to child register map

	TUint32 iAddress;					// Start Address

	TUint32 iLength;					// Register Length in Bytes

	const TAny*	iDataP;					// Data for auto-access (may be NULL)

	TAccessFunction iAccessFunction;	// Invoked when register is accessed

	TUint8 iFlags;						// Bitmap of RO(0), R/W(1) bits (8-bit only?)

	};

// ======== Card Information Structures =========

const TUint32 KCommonCisPtr = 0x1010;

const TUint32 KCommonCisLen = 0x70;

LOCAL_D const TText8 CardCommonCis[KCommonCisLen] =

	{

//	0x20,0x04,0xc0,0x12,0x00,0x00,0x21,0x02,0x0c,0x00,0x22,0x06,0x00,0x00,0x01,0x32,

//	0x00,0x00,0x91,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x15,0x32,0x01,0x00,0x48,0x41,

//	0x47,0x49,0x57,0x41,0x52,0x41,0x20,0x53,0x59,0x53,0x2d,0x43,0x4f,0x4d,0x20,0x43,

//	0x4f,0x2e,0x2c,0x4c,0x54,0x44,0x2e,0x00,0x48,0x53,0x2d,0x53,0x44,0x44,0x4b,0x2d,

//	0x30,0x30,0x32,0x20,0x56,0x65,0x72,0x2e,0x50,0x61,0x6e,0x61,0x00,0x00,0xff,0xff,

//	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

//	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff

	0x20,0x04,0xc0,0x12,0x00,0x00,0x21,0x02,0x0c,0x00,0x22,0x04,0x00,0x00,0x01,0x2A/*79*/,

	0x91,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x15,0x35,0x01,0x00,0x48,0x41,0x47,0x49,

	0x57,0x41,0x52,0x41,0x20,0x53,0x59,0x53,0x2d,0x43,0x4f,0x4d,0x20,0x43,0x4f,0x2e,

	0x2c,0x4c,0x54,0x44,0x2e,0x00,0x48,0x53,0x2d,0x53,0x44,0x44,0x4b,0x2d,0x30,0x30,

	0x32,0x20,0x56,0x65,0x72,0x2e,0x50,0x61,0x6e,0x61,0x00,0x53,0x48,0x50,0x00,0xff,

	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff

	};

const TUint32 KFn1CisPtr = 0x2000;

const TUint32 KFn1CisLen = 0x40;

LOCAL_D const TText8 Fn1Cis[KFn1CisLen] =

	{

	0x21,0x02,0x0c,0x00,0x22,0x24,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,

	0x00,0x03,0x00,0x02,0x00,0x00,0x3c,0x00,0x00,0x00,0xc8,0x00,0x00,0x00,0x00,0x00,

	0x00,0x00,0x00,0x00,0x2c,0x01,0xf4,0x01,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,

	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x0f,0xff,

	};

const TUint32 KFn2CisPtr = 0x3000;

const TUint32 KFn2CisLen = 0x40;

LOCAL_D const TText8 Fn2Cis[KFn2CisLen] =

	{

	0x21,0x02,0x0c,0x00,0x22,0x24,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,

	0x00,0x03,0x40,0x00,0x00,0x00,0x3c,0x00,0x00,0x00,0xc8,0x00,0x00,0x00,0x00,0x00,

	0x00,0x00,0x00,0x00,0xfa,0x00,0xc2,0x01,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,

	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

	};

// ======== Card Common Control Registers =========

TUint8 GCCCRRegSdioRevision			= 0x00;

TUint8 GCCCRRegSdSpec				= 0x00;

TUint8 GCCCRRegIoEnable				= 0x00;

TUint8 GCCCRRegIoReady				= 0x00;

TUint8 GCCCRRegIntEnable			= 0x00;

TUint8 GCCCRRegIntPending			= 0x00;

TUint8 GCCCRRegIoAbort				= 0x00;

TUint8 GCCCRRegBusInterfaceControl	= 0x00;

TUint8 GCCCRRegCardCapability		= 0x00;

TUint8 GCCCRRegCisPtrLo				= (KCommonCisPtr & 0x0000FF);

TUint8 GCCCRRegCisPtrMid			= (KCommonCisPtr & 0x00FF00) >> 8;

TUint8 GCCCRRegCisPtrHi				= (KCommonCisPtr & 0xFF0000) >> 16;

TUint8 GCCCRRegBusSuspend			= 0x00;

TUint8 GCCCRRegFunctionSelect		= 0x00;

TUint8 GCCCRRegExecFlags			= 0x00;

TUint8 GCCCRRegReadyFlags			= 0x00;

TUint8 GCCCRRegFN0BlockSizeLo		= 0x00;	// Initialises with 0x0000

TUint8 GCCCRRegFN0BlockSizeHi		= 0x00;	// Initialises with 0x0000

TUint8 GFunctionToEnable = 0x00;

LOCAL_D const SRegisterMapInfo IoMapCCCR[] =

	{

		{KCCCRRegSdioRevision,		  NULL, 0x00, 0x01, &GCCCRRegSdioRevision,		  NULL, 0x00},

		{KCCCRRegSdSpec,			  NULL, 0x01, 0x01, &GCCCRRegSdSpec,			  NULL, 0x00},

		{KCCCRRegIoEnable,			  NULL, 0x02, 0x01, NULL, DWinsSDIOStack::AccessIoEnable, 0x00},

		{KCCCRRegIoReady,			  NULL, 0x03, 0x01, &GCCCRRegIoReady,			  NULL, 0x00},

		{KCCCRRegIntEnable,			  NULL, 0x04, 0x01, &GCCCRRegIntEnable,			  NULL, 0xFF},

		{KCCCRRegIntPending,		  NULL, 0x05, 0x01, &GCCCRRegIntPending,		  NULL, 0x00},

		{KCCCRRegIoAbort,			  NULL, 0x06, 0x01, &GCCCRRegIoAbort,			  NULL, 0xFF},

		{KCCCRRegBusInterfaceControl, NULL, 0x07, 0x01, &GCCCRRegBusInterfaceControl, NULL, 0xFF},

		{KCCCRRegCardCapability,	  NULL, 0x08, 0x01, &GCCCRRegCardCapability,	  NULL, 0x00},

		{KCCCRRegCisPtrLo,			  NULL, 0x09, 0x01, &GCCCRRegCisPtrLo,			  NULL, 0x00},

		{KCCCRRegCisPtrMid,			  NULL, 0x0a, 0x01, &GCCCRRegCisPtrMid,			  NULL, 0x00},

		{KCCCRRegCisPtrHi,			  NULL, 0x0b, 0x01, &GCCCRRegCisPtrHi,			  NULL, 0x00},

		{KCCCRRegBusSuspend,		  NULL, 0x0c, 0x01, &GCCCRRegBusSuspend,		  NULL, 0xFF},

		{KCCCRRegFunctionSelect,	  NULL, 0x0d, 0x01, &GCCCRRegFunctionSelect,	  NULL, 0xFF},

		{KCCCRRegExecFlags,			  NULL, 0x0e, 0x01, &GCCCRRegExecFlags,			  NULL, 0x00},

		{KCCCRRegReadyFlags,		  NULL, 0x0f, 0x01, &GCCCRRegReadyFlags,		  NULL, 0x00},

		{KCCCRRegFN0BlockSizeLo,	  NULL, 0x10, 0x01, &GCCCRRegFN0BlockSizeLo,	  NULL, 0x00},

		{KCCCRRegFN0BlockSizeHi,	  NULL, 0x11, 0x01, &GCCCRRegFN0BlockSizeHi,	  NULL, 0x00},

		{KIoMapEnd,					  NULL, 0,	  0,	NULL,						  NULL, 0xFF}

	};

// ======== Function Basic Register 1 =========

TUint8 GFBR1RegInterfaceCode = KFBRRegSupportsCSA;

TUint8 GFBR1RegExtendedCode  = 0x00;

TUint8 GFBR1RegPowerFlags	 = 0x00;

TUint8 GFBR1RegCisPtrLo		 = (KFn1CisPtr & 0x0000FF);

TUint8 GFBR1RegCisPtrMid	 = (KFn1CisPtr & 0x00FF00) >> 8;

TUint8 GFBR1RegCisPtrHi		 = (KFn1CisPtr & 0xFF0000) >> 16;

TUint8 GFBR1RegIoBlockSizeLo = 0x00;

TUint8 GFBR1RegIoBlockSizeHi = 0x00;

TUint32 GFBR1RegCsaPtr = 0x00000000;

LOCAL_D const SRegisterMapInfo IoMapFBR1[] =

	{

		{KFBRRegInterfaceCode, NULL, 0x100, 0x01, &GFBR1RegInterfaceCode, NULL, 0x00},

		{KFBRRegExtendedCode,  NULL, 0x101, 0x01, &GFBR1RegExtendedCode,  NULL, 0x00},

		{KFBRRegPowerFlags,	   NULL, 0x102, 0x01, &GFBR1RegPowerFlags,	  NULL, 0x00},

		{KFBRRegCisPtrLo,	   NULL, 0x109, 0x01, &GFBR1RegCisPtrLo,	  NULL, 0x00},

		{KFBRRegCisPtrMid,	   NULL, 0x10a, 0x01, &GFBR1RegCisPtrMid,	  NULL, 0x00},

		{KFBRRegCisPtrHi,	   NULL, 0x10b, 0x01, &GFBR1RegCisPtrHi,	  NULL, 0x00},

		{KFBRRegCsaPtrLo,	   NULL, 0x10c, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaPtrMid,	   NULL, 0x10d, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaPtrHi,	   NULL, 0x10e, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaWindow,	   NULL, 0x10f, 0x01, NULL, DWinsSDIOStack::AccessCsaWindow,  0xFF},

		{KFBRRegIoBlockSizeLo, NULL, 0x110, 0x01, &GFBR1RegIoBlockSizeLo, NULL, 0xFF},

		{KFBRRegIoBlockSizeHi, NULL, 0x111, 0x01, &GFBR1RegIoBlockSizeHi, NULL, 0xFF},

		{KIoMapEnd,			   NULL, 0,	    0,	  NULL,					  NULL, 0x00}

	};

// ======== Function Basic Register 2 ========

TUint8 GFBR2RegInterfaceCode = KFBRRegSupportsCSA | ESdioFunctionTypeUART;

TUint8 GFBR2RegExtendedCode  = 0x00;

TUint8 GFBR2RegPowerFlags	 = 0x00;

TUint8 GFBR2RegCisPtrLo		 = (KFn2CisPtr & 0x0000FF);

TUint8 GFBR2RegCisPtrMid	 = (KFn2CisPtr & 0x00FF00) >> 8;

TUint8 GFBR2RegCisPtrHi		 = (KFn2CisPtr & 0xFF0000) >> 16;

TUint8 GFBR2RegIoBlockSizeLo = 0x00;

TUint8 GFBR2RegIoBlockSizeHi = 0x00;

TUint32 GFBR2RegCsaPtr = 0x00000000;

LOCAL_D const SRegisterMapInfo IoMapFBR2[] =

	{

		{KFBRRegInterfaceCode, NULL, 0x200, 0x01, &GFBR2RegInterfaceCode, NULL, 0x00},

		{KFBRRegExtendedCode,  NULL, 0x201, 0x01, &GFBR2RegExtendedCode,  NULL, 0x00},

		{KFBRRegPowerFlags,	   NULL, 0x202, 0x01, &GFBR2RegPowerFlags,	  NULL, 0x00},

		{KFBRRegCisPtrLo,	   NULL, 0x209, 0x01, &GFBR2RegCisPtrLo,	  NULL, 0x00},

		{KFBRRegCisPtrMid,	   NULL, 0x20a, 0x01, &GFBR2RegCisPtrMid,	  NULL, 0x00},

		{KFBRRegCisPtrHi,	   NULL, 0x20b, 0x01, &GFBR2RegCisPtrHi,	  NULL, 0x00},

		{KFBRRegCsaPtrLo,	   NULL, 0x20c, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaPtrMid,	   NULL, 0x20d, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaPtrHi,	   NULL, 0x20e, 0x01, NULL, DWinsSDIOStack::AccessCsaPointer, 0xFF},

		{KFBRRegCsaWindow,	   NULL, 0x20f, 0x01, NULL, DWinsSDIOStack::AccessCsaWindow,  0xFF},

		{KFBRRegIoBlockSizeLo, NULL, 0x210, 0x01, &GFBR2RegIoBlockSizeLo, NULL, 0xFF},

		{KFBRRegIoBlockSizeHi, NULL, 0x211, 0x01, &GFBR2RegIoBlockSizeHi, NULL, 0xFF},

		{KIoMapEnd,			   NULL, 0,	    0,	  NULL,					  NULL, 0x00}

	};

// ======== Function Basic Register 1 =========

const TInt KIoMapCCCR	   = 0;

const TInt KIoMapFBR1	   = 1;

const TInt KIoMapFBR2	   = 2;

const TInt KIoMapCommonCis = 3;

const TInt KIoMapFn1Cis	   = 4;

const TInt KIoMapFn2Cis	   = 5;

LOCAL_D const SRegisterMapInfo IoMapTop[] =

	{

		{KIoMapCCCR,	  IoMapCCCR, 0x00,			0xFF,		   NULL,		  NULL, 0x00},

		{KIoMapFBR1,	  IoMapFBR1, 0x100,			0xFF,		   NULL,		  NULL, 0x00},		

		{KIoMapFBR2,	  IoMapFBR2, 0x200,			0xFF,		   NULL,		  NULL, 0x00},

		{KIoMapCommonCis, NULL,		 KCommonCisPtr, KCommonCisLen, CardCommonCis, NULL, 0x00},

		{KIoMapFn1Cis,	  NULL,		 KFn1CisPtr,	KFn1CisLen,	   Fn1Cis,		  NULL, 0x00},

		{KIoMapFn2Cis,	  NULL,		 KFn2CisPtr,	KFn2CisLen,	   Fn2Cis,		  NULL, 0x00},

		{KIoMapEnd,		  NULL,		 0,				0,			   NULL,		  NULL, 0x00}

	};

const SRegisterMapInfo* FindIoEntryFromID(const SRegisterMapInfo* aIoMapP, TUint32 aID)

	{

	const SRegisterMapInfo* foundEntry = NULL;

	TInt currentEntry = 0;

	while((aIoMapP[currentEntry].iRegisterID != KIoMapEnd) && (foundEntry == NULL))

		{

		if(aIoMapP[currentEntry].iRegisterID == aID)

			{

			foundEntry = aIoMapP+currentEntry;

			}

		currentEntry++;

		}

	return(foundEntry);

	}

const SRegisterMapInfo* FindIoEntryFromAddress(const SRegisterMapInfo* aIoMapP, TUint32 aAddr)

	{

	const SRegisterMapInfo* foundEntry = NULL;

	TInt currentEntry = 0;

	while((aIoMapP[currentEntry].iRegisterID != KIoMapEnd) && (foundEntry == NULL))

		{

		const TUint32 startAddr = aIoMapP[currentEntry].iAddress;

		const TUint32 endAddr   = startAddr + aIoMapP[currentEntry].iLength - 1;

		if((aAddr >= startAddr) && (aAddr <= endAddr))

			{

			if(aIoMapP[currentEntry].iChildMapP)

				{

				foundEntry = FindIoEntryFromAddress(aIoMapP[currentEntry].iChildMapP, aAddr);

				}

			else

				{

				foundEntry = aIoMapP+currentEntry;

				}

			}

		currentEntry++;

		}

	return(foundEntry);

	}

// ======== error code conversion ========

GLDEF_C TInt MapLastErrorEpoc()

//

// map an Win32 error code to Epoc32 value

//

	{

	TInt res=KErrGeneral;

	switch (GetLastError())

		{

		case ERROR_SHARING_VIOLATION : res=KErrAccessDenied; break;

		case ERROR_LOCK_VIOLATION : res=KErrLocked; break;

		case ERROR_FILE_NOT_FOUND: res=KErrNotFound; break;

		case ERROR_PATH_NOT_FOUND: res=KErrPathNotFound; break;

		case ERROR_ALREADY_EXISTS:

		case ERROR_FILE_EXISTS:

			res=KErrAlreadyExists;

			break;

		case ERROR_NOT_READY: res=KErrNotReady; break;

		case ERROR_UNRECOGNIZED_VOLUME:

		case ERROR_NOT_DOS_DISK:

			res=KErrUnknown;

			break;

		case ERROR_UNRECOGNIZED_MEDIA: res=KErrCorrupt; break;

		case ERROR_INVALID_NAME: res=KErrBadName; break;

		case ERROR_NO_MORE_FILES: res=KErrEof; break;

		}

	return(res);

	}

GLDEF_C TMMCErr MapLastErrorMmc()

//

// map Win32 error to a TMMCErr error.

//

	{

	DWORD r=GetLastError();

	TInt res=KErrGeneral;

	switch (r)

		{

		case ERROR_SHARING_VIOLATION:

		case ERROR_LOCK_VIOLATION:

			res=KMMCErrLocked;			// KErrLocked

			break;

		case ERROR_FILE_NOT_FOUND:

		case ERROR_PATH_NOT_FOUND:

			res=KMMCErrNotFound;		// KErrNotFound

			break;

		case ERROR_ALREADY_EXISTS:

		case ERROR_FILE_EXISTS:

			res=KMMCErrAlreadyExists;	// KErrAlreadyExists

			break;

		case ERROR_NOT_READY: res=KMMCErrNoCard; break;

		case ERROR_UNRECOGNIZED_VOLUME:

		case ERROR_NOT_DOS_DISK:

			res=KMMCErrGeneral;			// KErrGeneral

			break;

		case ERROR_UNRECOGNIZED_MEDIA:

		case ERROR_INVALID_NAME:

		case ERROR_NO_MORE_FILES:

			res=KMMCErrResponseCRC; 	// KErrCorrupt

			break;

		}

	return(res);

	}

// ======== DWinsSDIOStack ========

DWinsSDIOStack::DWinsSDIOStack(TInt aBus, DMMCSocket* aSocket)

  : DSDIOStack(aBus, aSocket),

	iEnableTimer(&DWinsSDIOStack::EnableTimerCallback,this)

	{	

	iAddressedCard=KBroadcastToAllCards;

//	iCMD42Failed=EFalse;

	}

TInt DWinsSDIOStack::Init()

//

// Allocate any resources. Only created once on kernel initialization so dont

// worry about cleanup if it leaves.

//

	{

	if((iCardArray = new TSDIOCardArray(this)) == NULL)

		return KErrNoMemory;

	TInt r=DMMCStack::Init();

	if(r!=KErrNone)

		return r;

	DMediaChangeBase* pMCBase = MMCSocket()->iMediaChange;

	static_cast<DWinsMMCMediaChange*>(pMCBase)->SetStackP(this);

	Wins::SetMediaChangeCallBackPtr(DWinsMMCMediaChange::MediaChangeCallBack, (TAny*)pMCBase);

	//

	// Over time memory can become fragmented, and so it is not possible to

	// allocate physically contiguous pages.  Therefore, the buffers for IO

	// are allocated at startup.

	//

	// block and erase sector size characteristics depend on the specific

	// card model, and so the initial values are estimates based on a typical

	// card.  If these do not match the actual card's block size (or erase

	// size, for SD,) then the media driver just gets a reduced or increased

	// buffer area, and its efficiency varies accordingly.

	//

	// For the WINS implementation, fragmentation does not matter because

	// DMA is not used.  The memory must still be allocated here so MEDMMC is

	// able to use it.

	//

	// The constant calculations could be folded, but this illustrates how the

	// values are derived.

	//

	// MMC - values from Hitachi 16Mb card, datasheet HB288016MM1

	// minor buffer must contain enough space for MBR or block

	const TUint mmcBlkSzLog2 = 9;				// READ_BLK_LEN and WRITE_BLK_LEN

	const TUint mmcBlkSz = 1 << mmcBlkSzLog2;

	const TInt mmcMinorBufLen = Max(KDiskSectorSize, mmcBlkSz);

	const TInt KMinMMCBlocksInBuffer = 8;

	const TInt mmcCchBufLen = KMinMMCBlocksInBuffer << mmcBlkSzLog2;

	const TInt mmcTotalBufLen = mmcMinorBufLen + mmcCchBufLen;

	// SDCard - values from 64Mb Panasonic RP-SD064

	const TUint sdBlkSzLog2 = 9;				// READ_BL_LEN and WRITE_BLK_LEN

	const TUint sdBlkSz = 1 << sdBlkSzLog2;

	const TInt sdMinorBufLen = Max(KDiskSectorSize, sdBlkSz);

	const TUint ss = 0x1f;						// SECTOR_SIZE, add 1 for sector count

	const TInt KMinSDBlocksInBuffer = 8;

	const TInt sdCchBufLen = Max(KMinSDBlocksInBuffer, ss + 1) << sdBlkSzLog2;

	const TInt sdTotalBufLen = sdMinorBufLen + sdCchBufLen;

	const TInt totalBufLen = Max(mmcTotalBufLen, sdTotalBufLen);

	iMDBuf = reinterpret_cast<TUint8*>(Kern::Alloc(totalBufLen));

	iMDBufLen = totalBufLen;

	// initialize each card on the stack

	TInt i;

	for (i = 0; i < KTotalWinsCards; ++i)

		{

		TInt r = SetupSimulatedCard(i);

		if (r != KErrNone)

			return r;

		}

	// initialize pointers to currently present cards

	// Slot zero can toggle between no card; card 0 and card 1.  The current state is

	// determined by *Wins::CurrentPBusDevicePtr() and toggled by pressing F4 when F5

	// (door open) is held down.  Because this function is only executed at startup,

	// assume start with card zero.

	iCardInfo[0] = iCardPool[0];

	for (i = 1; i < KTotalWinsCardSlots; ++i)

		{

		iCardInfo[i]=iCardPool[i+1];

		}

	return KErrNone;

	}

void DWinsSDIOStack::MachineInfo(TMMCMachineInfo& aMachineInfo)

	{

	aMachineInfo.iTotalSockets=KTotalWinsCardSlots;

	aMachineInfo.iTotalMediaChanges=0;  		// Not used at present

	aMachineInfo.iTotalPrimarySupplies=0;		// Not used at present

	aMachineInfo.iSPIMode=EFalse;

    aMachineInfo.iBaseBusNumber=0;

	__ASSERT_DEBUG(aMachineInfo.iTotalSockets<=KMaxMMCardsPerStack,

					DWinsSDIOStack::Panic(DWinsSDIOStack::EWinsMMCBadMachineInfo));

	}

void DWinsSDIOStack::AdjustPartialRead(

#ifdef _DEBUG

	const TMMCard* aCard,

#else

	const TMMCard* /*aCard*/,

#endif

	TUint32 aStart, TUint32 aEnd, TUint32* aPhysStart, TUint32* aPhysEnd) const

	{

#ifdef _DEBUG

	const TUint32 blkLen = aCard->CSD().ReadBlockLength();

	const TUint32 blkMsk = blkLen - 1;

	__ASSERT_DEBUG(aCard->CSD().ReadBlPartial(), Panic(EWinsMMCAPRNotSupp));

	__ASSERT_DEBUG(aEnd - aStart <= blkLen, Panic(EWinsMMCAPRRange));

	__ASSERT_DEBUG((aEnd & ~blkMsk) > (aStart & ~blkMsk), Panic(EWinsMMCAPRBoundary));

#endif

	*aPhysStart = aStart & ~0x3;

	*aPhysEnd = (aEnd + 0x3) & ~0x3;

	}

void DWinsSDIOStack::GetBufferInfo(TUint8** aMDBuf, TInt* aMDBufLen)

	{

	*aMDBuf = iMDBuf;

	*aMDBufLen = iMDBufLen;

	}

void DWinsSDIOStack::Panic(TWinsMMCPanic aPanic)

	{

	_LIT(KPncNm,"PBUS-MMCSD-WINS");

	Kern::PanicCurrentThread(KPncNm,aPanic);

	}

TInt DWinsSDIOStack::SetupSimulatedCard(TInt aCardNum)

//

// allocate individual card with Win32 file.  Only called at bootup, so no cleanup if fails.

//

	{

	TWinsCardInfo* cip = new TWinsCardInfo;

	if (cip == 0)

		return KErrNoMemory;

	TUint8 cid[KMMCCIDLength];

	cid[0] = 'C';

	cid[1] = 'I';

	cid[2] = 'D';

	cid[3] = TUint8('0' + aCardNum);

	TInt j;

	for (j = 4; j < KMMCCIDLength - 1; ++j)

		cid[j] = 'c';

	cid[KMMCCIDLength - 1] = '#';				// '#' = 0x23, bit zero must be 1

	cip->iCID=cid;

	cip->iPWD = new TMediaPassword;

	if (! cip->iPWD)

		{

		delete cip;

		return KErrNoMemory;

		}

	// cards in slot zero are SD

	TInt mediaAreas;

	if (aCardNum <= 1)

		{

		cip->iIsSDCard = ETrue;

		mediaAreas = 3;	// +1 for SDIO area

		}

	else

		{

		cip->iIsSDCard = EFalse;

		mediaAreas = 1;

		}

	cip->iState=ECardStateIdle;