Bug 1996 - Contribution for West Bridge Astoria Symbian Storage Driver
this storage driver is for the West Bridge Astoria chipset. This device
has a USB, SD and processor port for communication with a baseband processor.
In our port, we connected this device DVK to the Beagleboard through the SPI
interface of the OMAP3. After driver installation, the Symbian OS can see an
external device or D: drive represented by the SD card. In this driver, the USB
interface is not used directly, though this may be the subject of future
contributions. The appropriate way to test the driver is to access the external
volume and do file read and write to it, pretty much the same way you would
test a thumb drive on your PC
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/medwb/bld.inf Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,17 @@
+// ===========================
+//
+// Copyright Cypress Semiconductor Corporation, 2006-2009,
+// All Rights Reserved
+// UNPUBLISHED, LICENSED SOFTWARE.
+//
+// CONFIDENTIAL AND PROPRIETARY INFORMATION
+// WHICH IS THE PROPERTY OF CYPRESS.
+//
+// ===========================
+
+
+PRJ_PLATFORMS
+ARMV5
+
+PRJ_MMPFILES
+medwb
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/medwb/medwb.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1149 @@
+/* Cypress West Bridge API source file
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "locmedia.h"
+#include "platform.h"
+//#include "variantmediadef.h"
+#include <assp\omap3530_assp\CyAsSymbianStorageDriver.h>
+
+//#define REGIST_MEDIA_USE_MMC
+#define _MEDWB_DEBUG_1_
+//#define _MEDWB_DEBUG_2_
+
+//#define INTERVAL_FOR_WB 15 // 15 -- OK
+#define WB_BUFFER_SIZE 2*(65536 + 512)
+#define WB_RETRY_COUNT 2
+
+//const TInt KStackNumber = 0;
+const TInt KDiskSectorSize=512;
+const TInt KDiskSectorShift=9;
+//const TInt KIdleCurrentInMilliAmps = 1;
+
+const TInt KMBRFirstPartitionEntry=0x1BE;
+
+TUint8 ptrWBBuffer[WB_BUFFER_SIZE];
+
+
+template <class T>
+inline T UMin(T aLeft,T aRight)
+ {return(aLeft<aRight ? aLeft : aRight);}
+
+
+class DPhysicalDeviceMediaWB : public DPhysicalDevice
+ {
+public:
+ DPhysicalDeviceMediaWB();
+
+ virtual TInt Install();
+ virtual void GetCaps(TDes8& aDes) const;
+ virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* aInfo, const TVersion& aVer);
+ virtual TInt Validate(TInt aDeviceType, const TDesC8* aInfo, const TVersion& aVer);
+ virtual TInt Info(TInt aFunction, TAny* a1);
+ };
+
+
+class DMediaDriverWB : public DMediaDriver
+ {
+public:
+ DMediaDriverWB(TInt aMediaId);
+ ~DMediaDriverWB();
+ // ...from DMediaDriver
+ virtual void Close();
+ // replacing pure virtual
+ virtual void Disconnect(DLocalDrive* aLocalDrive, TThreadMessage*);
+ virtual TInt Request(TLocDrvRequest& aRequest);
+ virtual TInt PartitionInfo(TPartitionInfo& anInfo);
+ virtual void NotifyPowerDown();
+ virtual void NotifyEmergencyPowerDown();
+ // For creation by DPhysicalDeviceMediaMmcFlash
+ TInt DoCreate(TInt aMediaId);
+
+private:
+
+private:
+ // MMC device specific stuff
+ TInt DoRead(TLocDrvRequest&);
+ TInt DoWrite(TLocDrvRequest&);
+ TInt DoFormat(TLocDrvRequest&);
+ TInt Caps(TLocDrv& aDrive, TLocalDriveCapsV6& aInfo);
+
+
+ TInt DecodePartitionInfo();
+ TInt WritePartitionInfo();
+ TInt GetDefaultPartitionInfo(TMBRPartitionEntry& aPartitionEntry);
+ TInt CreateDefaultPartition();
+
+
+
+ static void SetPartitionEntry(TPartitionEntry* aEntry, TUint aFirstSector, TUint aNumSectors);
+
+ TInt CheckDevice(int aReqType);
+
+ void Reset();
+
+private:
+ TInt iMediaId;
+ TPartitionInfo* iPartitionInfo;
+ TBool iMbrMissing;
+ TUint iHiddenSectors; // bootup / password
+
+ TUint8* ptrWriteBuf; // start of current buffer region
+ TUint8* ptrReadBuf; // start of current buffer region
+ TInt read_size;
+ TInt read_pos;
+
+ TInt iUnitSize;
+ TInt iBlockSize;
+ };
+
+// ======== DPhysicalDeviceMediaMmcFlash ========
+
+
+DPhysicalDeviceMediaWB::DPhysicalDeviceMediaWB()
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:ctr");
+ #endif
+ iUnitsMask = 0x01;
+ iVersion = TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
+ }
+
+
+TInt DPhysicalDeviceMediaWB::Install()
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:ins");
+ #endif
+ _LIT(KDrvNm, "Media.WB");
+ return SetName(&KDrvNm);
+ }
+
+
+void DPhysicalDeviceMediaWB::GetCaps(TDes8& /* aDes */) const
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:cap");
+ #endif
+ }
+
+
+TInt DPhysicalDeviceMediaWB::Info(TInt aFunction, TAny* /*a1*/)
+//
+// Return the priority of this media driver
+//
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:info");
+ #endif
+ if (aFunction==EPriority)
+ return KMediaDriverPriorityNormal;
+ // Don't close media driver when peripheral bus powers down. This avoids the need for Caps() to power up the stack.
+ if (aFunction==EMediaDriverPersistent)
+ return KErrNone;
+ return KErrNotSupported;
+ }
+
+TInt DPhysicalDeviceMediaWB::Validate(TInt aDeviceType, const TDesC8* /*aInfo*/, const TVersion& aVer)
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:validate aDeviceType %d\n", aDeviceType);
+ #endif
+ if (!Kern::QueryVersionSupported(iVersion,aVer))
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("Validate -> KErrNotSupported\n");
+ #endif
+ return KErrNotSupported;
+ }
+ if (aDeviceType!=MEDIA_DEVICE_MMC)
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("Validate -> Wrong DeviceType\n");
+ #endif
+ return KErrNotSupported;
+ }
+ return KErrNone;
+ }
+
+
+TInt DPhysicalDeviceMediaWB::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /*aInfo*/, const TVersion& aVer)
+//
+// Create an MMC Card media driver.
+//
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:crt");
+ #endif
+ if (!Kern::QueryVersionSupported(iVersion,aVer))
+ return KErrNotSupported;
+
+ DMediaDriverWB* pD = new DMediaDriverWB(aMediaId);
+ aChannel=pD;
+
+ TInt r=KErrNoMemory;
+ if (pD)
+ r=pD->DoCreate(aMediaId);
+
+ #ifdef REGIST_MEDIA_USE_MMC
+ if (r==KErrNone)
+ pD->OpenMediaDriverComplete(KErrNone);
+ #endif
+ __KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:mdf"));
+ return r;
+ }
+
+
+
+// Helper
+template <class T>
+inline T* KernAlloc(const TUint32 n)
+ { return static_cast<T*>(Kern::Alloc(n * sizeof(T))); }
+
+// ---- ctor, open, close, dtor ----
+
+#pragma warning( disable : 4355 ) // this used in initializer list
+DMediaDriverWB::DMediaDriverWB(TInt aMediaId)
+ :DMediaDriver(aMediaId),
+ iMediaId(iPrimaryMedia->iNextMediaId)
+ {
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("=mmd:wb");
+ // NB aMedia Id = the media ID of the primary media, iMediaId = the media ID of this media
+ Kern::Printf("DMediaDriverWB(), iMediaId %d, aMediaId %d\n", iMediaId, aMediaId);
+ #endif
+ }
+
+#pragma warning( default : 4355 )
+TInt DMediaDriverWB::DoCreate(TInt /*aMediaId*/)
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">mmd:opn");
+ #endif
+ iUnitSize = CyAsSymbianStorageDriver::GetUnitSize();
+ iBlockSize = CyAsSymbianStorageDriver::GetBlockSize();
+ if( iBlockSize == 0 )
+ iBlockSize = 1;
+
+ read_pos = 0x7FFFFFFF;
+ read_size = 0;
+
+ // get card characteristics
+ SetTotalSizeInBytes(CyAsSymbianStorageDriver::GetMediaSize());
+
+ // get buffer memory from EPBUS
+ ptrReadBuf = ptrWBBuffer;
+ ptrWriteBuf = &ptrWBBuffer[65536+512];
+
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("<mmd:opn");
+ #endif
+ return(KErrNone);
+ }
+
+void DMediaDriverWB::Close()
+//
+// Close the media driver - also called on media change
+//
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("=mmd:cls");
+ #endif
+ EndInCritical();
+ //CompleteRequest(KErrNotReady);
+ DMediaDriver::Close();
+ }
+
+
+DMediaDriverWB::~DMediaDriverWB()
+ {
+
+ }
+
+
+// ---- media access ----
+
+TInt DMediaDriverWB::DoRead(TLocDrvRequest& iCurrentReq)
+//
+// set up iReqStart, iReqEnd and iReqCur and launch first read. Subsequent reads
+// will be launched from the callback DFC.
+//
+ {
+ Int64 pos=iCurrentReq.Pos();
+ Int64 length=iCurrentReq.Length();
+ TInt r;
+ if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+ return KErrGeneral;
+ TInt p=(TInt)pos;
+ TInt l=(TInt)length;
+
+ if (p+l>CyAsSymbianStorageDriver::GetMediaSize())
+ return KErrGeneral;
+
+ TInt pos_block = p / iBlockSize;
+ TInt pos_offset = p % iBlockSize;
+ TInt size_block = l / iBlockSize;
+ TInt size_offset = l % iBlockSize;
+
+ TUint buf_offset = 0;
+ TInt local_pos;
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("WB::Read> real (%d@%d)", l, p);
+ Kern::Printf("WB::Read> pos_block - %d", pos_block) ;
+ Kern::Printf("WB::Read> pos_offset - %d", pos_offset) ;
+ Kern::Printf("WB::Read> size_block - %d", size_block) ;
+ Kern::Printf("WB::Read> size_offset - %d", size_offset) ;
+ #endif
+
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ if( pos_block == read_pos )
+ {
+ if( read_size < l )
+ {
+ buf_offset = read_size;
+ size_block = (l-read_size) / iBlockSize;
+ size_offset = (l-read_size) % iBlockSize;
+
+ local_pos = pos_block + (read_size /iBlockSize);
+ }
+ else
+ {
+ TPtrC8 des((ptrReadBuf+pos_offset), l);
+
+ r = iCurrentReq.WriteRemote(&des, 0);
+
+ return r;
+ }
+ }
+ #if 0
+ else if( (read_pos + (read_size/iBlockSize)) > pos_block )
+ {
+ TInt adjust_offset;
+ TInt adjust_size;
+ adjust_offset = (read_pos - pos_block) * iBlockSize;
+ adjust_size = read_size - adjust_offset;
+
+ memcpy(ptrReadBuf, &ptrReadBuf[adjust_offset], adjust_size );
+
+ read_pos = pos_block;
+ read_size = adjust_size;
+
+ if( read_size < l )
+ {
+ buf_offset = read_size;
+ size_block = (l-read_size) / iBlockSize;
+ size_offset = (l-read_size) % iBlockSize;
+
+ local_pos = pos_block + (read_size /iBlockSize);
+ }
+ else
+ {
+ TPtrC8 des((ptrReadBuf+pos_offset), l);
+
+ r = iCurrentReq.WriteRemote(&des, 0);
+
+ return r;
+ }
+ }
+ #endif
+ else
+ local_pos = read_pos = pos_block;
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("WB::Read> local_pos - %d", local_pos) ;
+ Kern::Printf("WB::Read> buf_offset - %d", buf_offset) ;
+ #endif
+
+
+ if( size_block )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrReadBuf+buf_offset));
+ local_pos += size_block;
+ buf_offset += (size_block*iBlockSize);
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ if( pos_offset || size_offset )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, 1, (void *)(ptrReadBuf+buf_offset) );
+ local_pos += size_block;
+ buf_offset += iBlockSize;
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ read_size = buf_offset;
+
+ TPtrC8 des((ptrReadBuf+pos_offset), l);
+
+ r = iCurrentReq.WriteRemote(&des, 0);
+
+ return r;
+ }
+
+
+TInt DMediaDriverWB::DoWrite(TLocDrvRequest& iCurrentReq)
+//
+// set up iReqStart, iReqEnd, and iReqCur, and launch first write. Any subsequent
+// writes are launched from the session end DFC. LaunchWrite() handles pre-reading
+// any sectors that are only partially modified.
+//
+ {
+ Int64 pos = iCurrentReq.Pos();
+ Int64 length = iCurrentReq.Length();
+ TInt r;
+ if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+ return KErrGeneral;
+ TInt p=(TInt)pos;
+ TInt l=(TInt)length;
+
+ if (p+l>CyAsSymbianStorageDriver::GetMediaSize())
+ return KErrGeneral;
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("WB::Write> (%d@%d)", l, p);
+ #endif
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+
+ TInt pos_block = p / iBlockSize;
+ TInt pos_offset = p % iBlockSize;
+ TInt size_block = l / iBlockSize;
+ TInt size_offset = l % iBlockSize;
+
+ TUint buf_offset = 0;
+ TInt local_pos;
+ TInt w_block_size = 0;
+
+ local_pos = pos_block;
+
+ if( size_block )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrWriteBuf+buf_offset));
+ local_pos += size_block;
+ buf_offset += (size_block*iBlockSize);
+ w_block_size += size_block;
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ if( pos_offset || size_offset )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, 1, (void *)(ptrWriteBuf+buf_offset) );
+ local_pos += size_block;
+ buf_offset += iBlockSize;
+ w_block_size ++;
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("WB::Write> pos_block - %d", pos_block) ;
+ Kern::Printf("WB::Write> pos_offset - %d", pos_offset) ;
+ Kern::Printf("WB::Write> size_block - %d", size_block) ;
+ Kern::Printf("WB::Write> size_offset - %d", size_offset) ;
+ #endif
+
+ TPtr8 des((ptrWriteBuf+pos_offset), l);
+
+ if ( (r = iCurrentReq.ReadRemote(&des,0)) !=KErrNone)
+ {
+ return r;
+ }
+
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("WB::Write> local_pos - %d", local_pos) ;
+ Kern::Printf("WB::Write> w_block_size - %d", w_block_size) ;
+ #endif
+
+ CyAsSymbianStorageDriver::Write(local_pos, w_block_size, ptrWriteBuf);
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ return r;
+ }
+
+
+TInt DMediaDriverWB::DoFormat(TLocDrvRequest& iCurrentReq)
+ {
+ Int64 pos = iCurrentReq.Pos();
+ Int64 length = iCurrentReq.Length();
+ TInt r;
+ if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+ return KErrGeneral;
+ TInt p=(TInt)pos;
+ TInt l=(TInt)length;
+
+ if (p+l>CyAsSymbianStorageDriver::GetMediaSize())
+ return KErrGeneral;
+
+ #ifdef _MEDWB_DEBUG_1_
+ Kern::Printf("WB::Format> (%d@%d)", l, p);
+ #endif
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ TInt pos_block = p / iBlockSize;
+ TInt pos_offset = p % iBlockSize;
+ TInt size_block = l / iBlockSize;
+ TInt size_offset = l % iBlockSize;
+
+ TUint buf_offset = 0;
+ TInt local_pos;
+ TInt w_block_size = 0;
+
+ local_pos = pos_block;
+
+ if( size_block )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, size_block, (void *)(ptrWriteBuf+buf_offset));
+ local_pos += size_block;
+ buf_offset += (size_block*iBlockSize);
+ w_block_size += size_block;
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ if( pos_offset || size_offset )
+ {
+ CyAsSymbianStorageDriver::Read(local_pos, 1, (void *)(ptrWriteBuf+buf_offset) );
+ local_pos += size_block;
+ buf_offset += iBlockSize;
+ w_block_size ++;
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ }
+
+ memclr(ptrWriteBuf + pos_offset, l);
+
+ CyAsSymbianStorageDriver::Write(local_pos, w_block_size, ptrWriteBuf);
+ #ifdef INTERVAL_FOR_WB
+ NKern::Sleep(INTERVAL_FOR_WB);
+ #endif
+ return r;
+ }
+
+
+TInt DMediaDriverWB::PartitionInfo(TPartitionInfo& anInfo)
+//
+// Read the partition information for the media. If the user supplied a password,
+// then unlock the card before trying to read the first sector.
+//
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">mmd:rpi");
+ #endif
+ iPartitionInfo = &anInfo;
+
+ // Assume MBR will be present or is not required
+ iMbrMissing = EFalse;
+
+ TInt r = DecodePartitionInfo();
+
+
+ if(r == KErrLocked)
+ {
+ // If the media is locked, we present a default partition entry to the local
+ // media subsystem, which will be updated when the media is finally unlocked.
+ r = CreateDefaultPartition();
+ if (r != KErrNone)
+ return r;
+ return KErrLocked;
+ }
+
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("<mmd:rpi:%d", r);
+ #endif
+ // KErrNone indicates asynchronous completion
+ return r;
+ }
+
+
+
+
+
+TInt DMediaDriverWB::DecodePartitionInfo()
+//
+// decode partition info that was read into internal buffer
+//
+ {
+ TInt partitionCount=iPartitionInfo->iPartitionCount=0;
+ TInt defaultPartitionNumber=-1;
+ TMBRPartitionEntry* pe;
+ const TUint KMBRFirstPartitionOffsetAligned = KMBRFirstPartitionOffset & ~3;
+ TInt i;
+
+ CyAsSymbianStorageDriver::Read(0, 1, (void *)ptrReadBuf);
+ read_pos = 0;
+ read_size = 512;
+ // Read of the first sector successful so check for a Master Boot Record
+ if (*(TUint16*)(&ptrReadBuf[KMBRSignatureOffset])!=0xAA55)
+ goto mbr_done;
+
+ __ASSERT_COMPILE(KMBRFirstPartitionOffsetAligned + KMBRMaxPrimaryPartitions * sizeof(TMBRPartitionEntry) <= KMBRSignatureOffset);
+
+ memmove(&ptrReadBuf[0], &ptrReadBuf[2],
+ KMBRFirstPartitionOffsetAligned + KMBRMaxPrimaryPartitions * sizeof(TMBRPartitionEntry));
+
+
+ for (i=0, pe = (TMBRPartitionEntry*)(&ptrReadBuf[KMBRFirstPartitionOffsetAligned]);
+ pe->iPartitionType != 0 && i < KMBRMaxPrimaryPartitions;i++,pe++)
+ {
+ if (pe->IsDefaultBootPartition())
+ {
+ SetPartitionEntry(&iPartitionInfo->iEntry[0],pe->iFirstSector,pe->iNumSectors);
+ defaultPartitionNumber=i;
+ partitionCount++;
+ break;
+ }
+ }
+
+ // Now add any other partitions
+ for (i=0, pe = (TMBRPartitionEntry*)(&ptrReadBuf[KMBRFirstPartitionOffsetAligned]);
+ pe->iPartitionType != 0 && i < KMBRMaxPrimaryPartitions;i++,pe++)
+ {
+ TBool validPartition = ETrue; // assume partition valid
+
+ if (defaultPartitionNumber==i)
+ {
+ // Already sorted
+ }
+
+ // FAT partition ?
+ else if (pe->IsValidDosPartition() || pe->IsValidFAT32Partition())
+ {
+ SetPartitionEntry(&iPartitionInfo->iEntry[partitionCount],pe->iFirstSector,pe->iNumSectors);
+ #ifdef _MEDWB_DEBUG_1_
+ Kern::Printf("WB: FAT partition found at sector #%u", pe->iFirstSector);
+ #endif
+ partitionCount++;
+ }
+ else
+ {
+ validPartition = EFalse;
+ }
+
+ if (validPartition && partitionCount == 1)
+ iHiddenSectors = pe->iFirstSector;
+
+ }
+
+ // Check the validity of the partition address boundaries
+ // If there is any
+ if(partitionCount > 0)
+ {
+ const TInt64 deviceSize = CyAsSymbianStorageDriver::GetMediaSize();
+ TPartitionEntry& part = iPartitionInfo->iEntry[partitionCount - 1];
+ // Check that the card address space boundary is not exceeded by the last partition
+ // In case of only 1 partition in the media check also it
+ if(part.iPartitionBaseAddr + part.iPartitionLen > deviceSize)
+ {
+ Kern::Printf("WB: MBR partition exceeds card memory space");
+ // Adjust the partition length to card address boundary
+ part.iPartitionLen = (deviceSize - part.iPartitionBaseAddr);
+
+ // Check that the base address contained valid information
+ if(part.iPartitionLen <= 0)
+ {
+ Kern::Printf("WB: Invalid base address");
+ // Invalid MBR - assume the boot sector is in the first sector
+ defaultPartitionNumber =-1;
+ partitionCount=0;
+ }
+ }
+ // More than one partition. Go through all of them
+ if (partitionCount > 0)
+ {
+ for(i=partitionCount-1; i>0; i--)
+ {
+ const TPartitionEntry& curr = iPartitionInfo->iEntry[i];
+ TPartitionEntry& prev = iPartitionInfo->iEntry[i-1];
+ // Check if partitions overlap
+ if(curr.iPartitionBaseAddr < (prev.iPartitionBaseAddr + prev.iPartitionLen))
+ {
+ Kern::Printf("WB: Overlapping partitions");
+ // Adjust the partition length to not overlap the next partition
+ prev.iPartitionLen = (curr.iPartitionBaseAddr - prev.iPartitionBaseAddr);
+
+ // Check that the base address contained valid information
+ if(prev.iPartitionLen <= 0)
+ {
+ Kern::Printf("WB: Invalid base address");
+ // Invalid MBR - assume the boot sector is in the first sector
+ defaultPartitionNumber=(-1);
+ partitionCount=0;
+ }
+ }
+ }
+ }
+ }
+
+mbr_done:
+ if (defaultPartitionNumber==(-1) && partitionCount==0)
+ {
+ Kern::Printf("WB:PartitionInfo no MBR");
+ {
+ // Assume it has no MBR, and the Boot Sector is in the 1st sector
+ SetPartitionEntry(&iPartitionInfo->iEntry[0],0,I64LOW(CyAsSymbianStorageDriver::GetMediaSize()>>KDiskSectorShift));
+ iHiddenSectors=0;
+ }
+ partitionCount=1;
+ }
+
+ iPartitionInfo->iPartitionCount=partitionCount;
+ iPartitionInfo->iMediaSizeInBytes=TotalSizeInBytes();
+ #ifdef _MEDWB_DEBUG_1_
+
+ Kern::Printf("<Mmc:PartitionInfo (C:%d)",iPartitionInfo->iPartitionCount);
+ Kern::Printf(" Partition1 (B:%xH L:%xH)",I64LOW(iPartitionInfo->iEntry[0].iPartitionBaseAddr),I64LOW(iPartitionInfo->iEntry[0].iPartitionLen));
+ Kern::Printf(" Partition2 (B:%xH L:%xH)",I64LOW(iPartitionInfo->iEntry[1].iPartitionBaseAddr),I64LOW(iPartitionInfo->iEntry[1].iPartitionLen));
+ Kern::Printf(" Partition3 (B:%xH L:%xH)",I64LOW(iPartitionInfo->iEntry[2].iPartitionBaseAddr),I64LOW(iPartitionInfo->iEntry[2].iPartitionLen));
+ Kern::Printf(" Partition4 (B:%xH L:%xH)",I64LOW(iPartitionInfo->iEntry[3].iPartitionBaseAddr),I64LOW(iPartitionInfo->iEntry[3].iPartitionLen));
+
+
+ Kern::Printf(" iMediaSizeInBytes (%d)",iPartitionInfo->iMediaSizeInBytes);
+ Kern::Printf(" iHiddenSectors (%d)",iHiddenSectors);
+ #endif
+
+ #ifdef _MEDWB_DEBUG_3_
+
+ TMBRPartitionEntry cPe;
+ if(GetDefaultPartitionInfo(cPe) == KErrNone)
+ {
+ pe = (TMBRPartitionEntry*)(&ptrReadBuf[0]);
+
+ Kern::Printf("-------------------------------------------");
+ Kern::Printf("-- Partition Entry Validation/Comparison --");
+ Kern::Printf("-------------------------------------------");
+ Kern::Printf("-- iX86BootIndicator [%02x:%02x] %c -", pe->iX86BootIndicator, cPe.iX86BootIndicator, pe->iX86BootIndicator == cPe.iX86BootIndicator ? ' ' : 'X');
+ Kern::Printf("-- iStartHead [%02x:%02x] %c -", pe->iStartHead, cPe.iStartHead, pe->iStartHead == cPe.iStartHead ? ' ' : 'X');
+ Kern::Printf("-- iStartSector [%02x:%02x] %c -", pe->iStartSector, cPe.iStartSector, pe->iStartSector == cPe.iStartSector ? ' ' : 'X');
+ Kern::Printf("-- iStartCylinder [%02x:%02x] %c -", pe->iStartCylinder, cPe.iStartCylinder, pe->iStartCylinder == cPe.iStartCylinder ? ' ' : 'X');
+ Kern::Printf("-- iPartitionType [%02x:%02x] %c -", pe->iPartitionType, cPe.iPartitionType, pe->iPartitionType == cPe.iPartitionType ? ' ' : 'X');
+ Kern::Printf("-- iEndHead [%02x:%02x] %c -", pe->iEndHead, cPe.iEndHead, pe->iEndHead == cPe.iEndHead ? ' ' : 'X');
+ Kern::Printf("-- iEndSector [%02x:%02x] %c -", pe->iEndSector, cPe.iEndSector, pe->iEndSector == cPe.iEndSector ? ' ' : 'X');
+ Kern::Printf("-- iEndCylinder [%02x:%02x] %c -", pe->iEndCylinder, cPe.iEndCylinder, pe->iEndCylinder == cPe.iEndCylinder ? ' ' : 'X');
+ Kern::Printf("-- iFirstSector [%08x:%08x] %c -", pe->iFirstSector, cPe.iFirstSector, pe->iFirstSector == cPe.iFirstSector ? ' ' : 'X');
+ Kern::Printf("-- iNumSectors [%08x:%08x] %c -", pe->iNumSectors, cPe.iNumSectors, pe->iNumSectors == cPe.iNumSectors ? ' ' : 'X');
+ Kern::Printf("-------------------------------------------");
+ }
+ #endif
+
+ return(KErrNone);
+ }
+
+
+TInt DMediaDriverWB::WritePartitionInfo()
+/**
+ Write the default partition table to freshly formatted media
+ @return Standard Symbian OS Error Code
+ */
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">mmd:wpi");
+ #endif
+ TMBRPartitionEntry partitionEntry;
+ TInt err = GetDefaultPartitionInfo(partitionEntry);
+ if(err == KErrNone)
+ {
+ TUint8 *iPartitionBuf;
+
+ iPartitionBuf = new TUint8[KDiskSectorSize];
+
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("mmd:MBR/Partition Table");
+ Kern::Printf(" Boot ID : %02xh", partitionEntry.iX86BootIndicator);
+ Kern::Printf(" Start Head : %02xh", partitionEntry.iStartHead);
+ Kern::Printf(" Start Sector : %02xh", partitionEntry.iStartSector);
+ Kern::Printf(" Start Cyclinder : %02xh", partitionEntry.iStartCylinder);
+ Kern::Printf(" System ID : %02xh", partitionEntry.iPartitionType);
+ Kern::Printf(" End Head : %02xh", partitionEntry.iEndHead);
+ Kern::Printf(" End Sector : %02xh", partitionEntry.iEndSector);
+ Kern::Printf(" End Cyclinder : %02xh", partitionEntry.iEndCylinder);
+ Kern::Printf(" Relative Sector : %08xh", partitionEntry.iFirstSector);
+ Kern::Printf(" Number of Sectors: %08xh", partitionEntry.iNumSectors);
+ #endif
+ //
+ // Clear all other partition entries and align the partition info into the minor buffer for writing...
+ //
+ memclr(iPartitionBuf, KDiskSectorSize);
+ memcpy(&iPartitionBuf[KMBRFirstPartitionEntry], &partitionEntry, sizeof(TMBRPartitionEntry));
+
+ *(TUint16*)(&iPartitionBuf[KMBRSignatureOffset]) = 0xAA55;
+
+ err = CyAsSymbianStorageDriver::Write(0, 1, iPartitionBuf);
+
+ //
+ // Write the partition table and engage the read to validate and complete the mount process
+ //
+ delete iPartitionBuf;
+ iMbrMissing = EFalse;
+ }
+
+ #ifdef _MEDWB_DEBUG_3_
+ __KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:wpi:%d", err));
+ #endif
+
+ return(err);
+ }
+
+
+TInt DMediaDriverWB::CreateDefaultPartition()
+ {
+ TMBRPartitionEntry defPartition;
+ TInt r = GetDefaultPartitionInfo(defPartition);
+ if (r == KErrNone)
+ {
+ SetPartitionEntry(&iPartitionInfo->iEntry[0], defPartition.iFirstSector, defPartition.iNumSectors);
+ iHiddenSectors = defPartition.iFirstSector;
+ iPartitionInfo->iPartitionCount = 1;
+ iPartitionInfo->iMediaSizeInBytes = TotalSizeInBytes();
+ }
+ return r;
+ }
+
+TInt DMediaDriverWB::GetDefaultPartitionInfo(TMBRPartitionEntry& aPartitionEntry)
+/**
+ Calculates the default patition information for an specific card.
+ @param aPartitionEntry The TMBRPartitionEntry to be filled in with the format parameters
+ @return Standard Symbian OS Error Code
+ */
+ {
+ memclr(&aPartitionEntry, sizeof(TMBRPartitionEntry));
+
+ const TUint32 KTotalSectors = I64LOW(CyAsSymbianStorageDriver::GetMediaSize() >> KDiskSectorShift);
+
+ aPartitionEntry.iFirstSector = (CyAsSymbianStorageDriver::GetEraseBlockSize()>> KDiskSectorShift);
+ aPartitionEntry.iNumSectors = KTotalSectors - aPartitionEntry.iFirstSector;
+ aPartitionEntry.iX86BootIndicator = 0x00;
+
+ if(aPartitionEntry.iNumSectors < 32680)
+ {
+ aPartitionEntry.iPartitionType = KPartitionTypeFAT12;
+ }
+ else if(aPartitionEntry.iNumSectors < 65536)
+ {
+ aPartitionEntry.iPartitionType = KPartitionTypeFAT16small;
+ }
+ else if (aPartitionEntry.iNumSectors < 1048576)
+ {
+ aPartitionEntry.iPartitionType = KPartitionTypeFAT16;
+ }
+ else
+ {
+ aPartitionEntry.iPartitionType = KPartitionTypeWin95FAT32;
+ }
+
+ return(KErrNone);
+ }
+
+void DMediaDriverWB::SetPartitionEntry(TPartitionEntry* aEntry, TUint aFirstSector, TUint aNumSectors)
+//
+// auxiliary static function to record partition information in TPartitionEntry object
+//
+ {
+ aEntry->iPartitionBaseAddr=aFirstSector;
+ aEntry->iPartitionBaseAddr<<=KDiskSectorShift;
+ aEntry->iPartitionLen=aNumSectors;
+ aEntry->iPartitionLen<<=KDiskSectorShift;
+ aEntry->iPartitionType=KPartitionTypeFAT12;
+ }
+
+// ---- device status, callback DFC ----
+
+TInt DMediaDriverWB::CheckDevice(int aReqType)
+//
+// Check the device before initiating a command
+//
+ {
+
+ __KTRACE_OPT(KPBUSDRV, Kern::Printf(">wb:cd:%d",aReqType));
+
+ TInt r=KErrNone;
+#if 0
+ if (!iCard->IsReady())
+ r=KErrNotReady;
+
+ // The card must be locked if attempting to unlock during RPI, and
+ // unlocked at all other times.
+ else if (aReqType!=EMReqTypeUnlockPswd && iCard->IsLocked())
+ r=KErrLocked;
+ // Don't perform Password setting for WriteProtected cards,
+ // unable to recover (ForcedErase) if password lost.
+ else if (aReqType==EMReqTypeChangePswd)
+ {
+ if (iCard->MediaType()==EMultiMediaROM)
+ {
+ r=KErrAccessDenied;
+ }
+ }
+ else if (iMbrMissing && aReqType==EMReqTypeNormalRd)
+ r=KErrCorrupt;
+
+ // Don't perform write operations when the mechanical write protect switch is set
+ else if (aReqType==EMReqTypeNormalWr && iCard->IsWriteProtected())
+ r=KErrAccessDenied;
+ // Don't perform write/format operations on MMC ROM cards
+ else if (iMediaType==EMultiMediaROM && aReqType == EMReqTypeNormalWr)
+ r=KErrAccessDenied;
+#endif
+ __KTRACE_OPT(KPBUSDRV, Kern::Printf("<wb:cd:%d", r));
+ return(r);
+ }
+
+
+// ---- request management ----
+
+TInt DMediaDriverWB::Caps(TLocDrv& aDrive, TLocalDriveCapsV6& aInfo)
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">WB::Caps ");
+ #endif
+ // Fill buffer with current media caps.
+ aInfo.iType = EMediaHardDisk;
+ aInfo.iBattery = EBatNotSupported;
+ aInfo.iDriveAtt = KDriveAttLocal;
+ aInfo.iMediaAtt = KMediaAttFormattable;
+
+ //if(CyAsSymbianStorageDriver::GetIsLocked())
+ // aInfo.iMediaAtt |= KMediaAttLockable;
+ //if (iCard->HasPassword())
+ //aInfo.iMediaAtt |= KMediaAttHasPassword;
+
+ if ( !CyAsSymbianStorageDriver::GetIsWriteable())
+ aInfo.iMediaAtt |= KMediaAttWriteProtected;
+ if (CyAsSymbianStorageDriver::GetIsLocked())
+ aInfo.iMediaAtt |= KMediaAttLocked;
+
+ aInfo.iFileSystemId = KDriveFileSysFAT;
+
+ // Format is performed in multiples of the erase sector (or multiple block) size
+ aInfo.iMaxBytesPerFormat = CyAsSymbianStorageDriver::GetBlockSize();
+
+ // Set serial number to CID
+ aInfo.iSerialNumLength = 16;
+ for (TUint i=0; i<16; i++)
+ aInfo.iSerialNum[i] = 0;
+
+ // Get block size & erase block size to allow the file system to align first usable cluster correctly
+ aInfo.iBlockSize = CyAsSymbianStorageDriver::GetBlockSize();
+ aInfo.iEraseBlockSize = CyAsSymbianStorageDriver::GetEraseBlockSize();
+
+ if ( CyAsSymbianStorageDriver::GetIsRemovable())
+ aInfo.iDriveAtt|= KDriveAttRemovable;
+
+ // Must return KErrCompletion to indicate that this
+ // is a synchronous version of the function
+ return KErrNone;
+ }
+
+
+void DMediaDriverWB::NotifyPowerDown()
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">Mmc:NotifyPowerDown");
+ #endif
+
+ EndInCritical();
+
+ //CompleteRequest(KErrNotReady);
+ }
+
+void DMediaDriverWB::NotifyEmergencyPowerDown()
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf(">Ata:NotifyEmergencyPowerDown");
+ #endif
+ //TInt r=KErrNotReady;
+ //if (iCritical)
+ // r=KErrAbort;
+ EndInCritical();
+
+ // need to cancel the session as the stack doesn't take too kindly to having the same session engaged more than once.
+
+ //CompleteRequest(r);
+ }
+
+TInt DMediaDriverWB::Request(TLocDrvRequest& aRequest)
+ {
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("MmcMd:Req %08x id %d",&aRequest,aRequest.Id());
+ #endif
+ TInt r=KErrNotSupported;
+ TInt id=aRequest.Id();
+
+ NKern::ThreadEnterCS();
+
+ TUint partitionType = aRequest.Drive()->iPartitionType;
+ TBool readOnly = (partitionType == KPartitionTypeRofs || partitionType == KPartitionTypeROM);
+
+ switch (id)
+ {
+ case DLocalDrive::ECaps:
+ {
+ TLocalDriveCapsV6& c = *(TLocalDriveCapsV6*)aRequest.RemoteDes();
+ TLocDrv& drive = *aRequest.Drive();
+ r = Caps(drive, c);
+ c.iSize = drive.iPartitionLen;
+ c.iPartitionType = drive.iPartitionType;
+ c.iHiddenSectors = (TUint) (drive.iPartitionBaseAddr >> KDiskSectorShift);
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("caps : c.iSize = %d ", c.iSize);
+ Kern::Printf("caps : c.iPartitionType = %d ", c.iPartitionType);
+ Kern::Printf("caps : c.iHiddenSectors = %d ", c.iHiddenSectors);
+ #endif
+ }
+ break;
+ case DLocalDrive::EQueryDevice:
+ Kern::Printf(">WB::EQueryDevice ");
+ r = KErrNotSupported;
+ break;
+
+ case DLocalDrive::ERead:
+ r=DoRead(aRequest);
+ break;
+ case DLocalDrive::EWrite:
+ if (readOnly)
+ return KErrNotSupported;
+ r=DoWrite(aRequest);
+ break;
+ case DLocalDrive::EFormat:
+ if (readOnly)
+ return KErrNotSupported;
+ r=DoFormat(aRequest);
+ break;
+
+
+ case DLocalDrive::EPasswordUnlock:
+ case DLocalDrive::EPasswordLock:
+ case DLocalDrive::EPasswordClear:
+ case DLocalDrive::EPasswordErase:
+ case DLocalDrive::EWritePasswordStore:
+ Kern::Printf(">WB::EPassword ");
+ break;
+ case DLocalDrive::EEnlarge:
+ case DLocalDrive::EReduce:
+ Kern::Printf(">WB::EReduce ");
+ default:
+ Kern::Printf(">WB::default ");
+ r=KErrNotSupported;
+ break;
+ }
+
+ NKern::ThreadLeaveCS();
+ #ifdef _MEDWB_DEBUG_3_
+ Kern::Printf("MmcMd:Req %08x cmp %d",&aRequest,r);
+ #endif
+ return r;
+ }
+
+void DMediaDriverWB::Disconnect(DLocalDrive* aLocalDrive, TThreadMessage* aMsg)
+ {
+ // Complete using the default implementation
+ DMediaDriver::Disconnect(aLocalDrive, aMsg);
+ }
+
+
+DECLARE_EXTENSION_PDD()
+ {
+ // NB if the media driver has been defined as a kernel extension in the .OBY/.IBY file
+ // i.e the "extension" keyword has been used rather than "device", then an instance of
+ // DPhysicalDeviceMediaMmcFlash will already have been created by InitExtension(). In this
+ // case the kernel will see that an object of the same name already exists and delete the
+ // new one.
+ return new DPhysicalDeviceMediaWB;
+ }
+#ifdef REGIST_MEDIA_USE_MMC
+DECLARE_STANDARD_EXTENSION()
+ {
+ Kern::Printf("Creating WestBridge PDD");
+
+ DPhysicalDeviceMediaWB* device = new DPhysicalDeviceMediaWB;
+
+ TInt r;
+ if (device==NULL)
+ r=KErrNoMemory;
+ else
+ r=Kern::InstallPhysicalDevice(device);
+ Kern::Printf("Installing WestBridge PDD in kernel returned %d",r);
+
+ if( CyAsSymbianStorageDriver::Open() )
+ Kern::Printf("**CyAsSymbianStorageDriver::Open() - Success");
+ else
+ Kern::Printf("**CyAsSymbianStorageDriver::Open() - Fail");
+
+ Kern::Printf("WestBridge extension entry point drive returns %d",r);
+ return r;
+ }
+
+#else
+static const TInt WBDriveNumbers[1]={1};
+_LIT(KWBDriveName,"WestBridge");
+
+DECLARE_STANDARD_EXTENSION()
+ {
+ __KTRACE_OPT(KBOOT,Kern::Printf("Registering WB drive"));
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("Registering WB drive");
+ #endif
+ TInt r=KErrNoMemory;
+ DPrimaryMediaBase* pM=new DPrimaryMediaBase;
+ if (pM)
+ {
+ r=LocDrv::RegisterMediaDevice(MEDIA_DEVICE_MMC,1,&WBDriveNumbers[0],pM,1,KWBDriveName);
+ }
+
+
+ if( CyAsSymbianStorageDriver::Open() )
+ {
+ #ifdef _MEDWB_DEBUG_1_
+ Kern::Printf("**CyAsSymbianStorageDriver::Open() - Success");
+ #endif
+ }
+ else
+ {
+ #ifdef _MEDWB_DEBUG_1_
+ Kern::Printf("**CyAsSymbianStorageDriver::Open() - Fail");
+ #endif
+ }
+
+ __KTRACE_OPT(KBOOT,Kern::Printf("Registering WB drive - return %d",r));
+ #ifdef _MEDWB_DEBUG_2_
+ Kern::Printf("Registering WB drive - return %d",r);
+ #endif
+
+ return r;
+ }
+
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/medwb/medwb.mmp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,45 @@
+// ===========================
+//
+// Copyright Cypress Semiconductor Corporation, 2006-2009,
+// All Rights Reserved
+// UNPUBLISHED, LICENSED SOFTWARE.
+//
+// CONFIDENTIAL AND PROPRIETARY INFORMATION
+// WHICH IS THE PROPERTY OF CYPRESS.
+//
+// ===========================
+
+
+#include "beagle/variant.mmh"
+#include "kernel/kern_ext.mmh"
+#include "drivers/elocd.mmh"
+
+OS_LAYER_SYSTEMINCLUDE_SYMBIAN
+USERINCLUDE ../../../../../os/kernelhwsrv/kernel/eka/include/drivers
+
+target VariantTarget(medwb,pdd)
+targettype pdd
+
+//Define this macro to create an MBR when formatting low-capacity MMC cards :
+//macro SYMBIAN_CREATE_MBR_ON_LOW_CAPACITY_MMC
+
+source medwb.cpp
+
+library elocd.lib
+//library VariantTarget(wb,lib)
+library wb.lib
+
+linkas medwb.pdd
+
+start wins
+win32_headers
+end
+
+epocallowdlldata
+
+UID 0x100039d0 0x100000d9
+VENDORID 0x70000001
+
+capability all
+
+SMPSAFE
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/hal/cyashalbeagleboard.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1306 @@
+// Copyright (c) 1994-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:
+// omap3530/beagle_drivers/wb/cyashalbeagleboard_spi.cpp
+//
+
+#include <kern_priv.h>
+#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+#include <assp/omap3530_assp/omap3530_assp_priv.h>
+#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+#include <assp/omap3530_assp/omap3530_gpio.h>
+
+#include <assp.h> // Required for definition of TIsr
+
+#include <cyasregs.h> // Astoria register definitions
+
+#ifdef __CY_ASTORIA_BEAGLEBOARD_SPI__HAL__
+
+#include "cyashalbeagleboard_spi.h"
+#include "cyaserr.h"
+#include "cyasregs.h"
+#include "cyasdma.h"
+#include "cyasintr.h"
+#ifdef FIRMWARE_NOPPORT
+
+#ifdef OVERCLOCK_SD
+#include "cyastfw_sd_mmc_rel_nopport_Ast121_68.h"
+#else
+#include "cyastfw_sd_mmc_rel_nopport.h"
+#endif
+
+#else
+
+#ifdef OVERCLOCK_SD
+#include "cyastfw_sd_mmc_rel_silicon_Ast121_68.h"
+#else
+#include "cyastfw_sd_mmc_rel_silicon.h"
+#endif
+
+#endif
+
+#include "cyasusbinit.h"
+
+/*
+ * For performance reasons, we handle storage endpoint transfers upto 4 KB
+ * within the HAL itself.
+ */
+#define CYASSTORAGE_WRITE_EP_NUM (4)
+#define CYASSTORAGE_READ_EP_NUM (8)
+#define CYASSTORAGE_MAX_XFER_SIZE (2*32768)
+
+/*#define MONITOR_THREAD 1*/
+#define INT_DE 1
+
+/* DFC queue */
+TDfc* gpDfc;
+
+/*
+ * The type of DMA operation, per endpoint
+ */
+typedef enum CyAsHalDmaType
+{
+ CyAsHalRead,
+ CyAsHalWrite,
+ CyAsHalNone
+} CyAsHalDmaType ;
+
+typedef struct CyAsHalEndpointDma
+{
+ CyBool buffer_valid ;
+ uint16_t *data_p ;
+ uint32_t size ;
+ /*struct scatterlist* sg_p ;
+ uint16_t scatter_index ;*/
+ uint32_t bytes_xfered ;
+ uint16_t transfer_cnt ;
+ CyAsHalDmaType type ;
+ CyBool pending ;
+} CyAsHalEndpointDma ;
+
+/*
+ * The list of OMAP devices (should be one)
+ */
+static CyAsOmapDevKernel *m_omap_list_p = 0 ;
+
+/*
+ * The callback to call after DMA operations are complete
+ */
+static CyAsHalDmaCompleteCallback callback = 0 ;
+
+/*
+ * Pending data size for the endpoints
+ */
+static CyAsHalEndpointDma EndPoints[16] ;
+
+/* Forward declaration */
+static void CyHandleDRQInterrupt(CyAsOmapDevKernel *dev_p) ;
+
+static volatile uint32_t Intr_Disabled = 0 ;
+static volatile CyAsHalDeviceTag gDevTag = 0 ;
+
+#define CYAS_INT_MASK (CY_AS_MEM_P0_INTR_REG_MCUINT | CY_AS_MEM_P0_INTR_REG_MBINT | \
+ CY_AS_MEM_P0_INTR_REG_PMINT | CY_AS_MEM_P0_INTR_REG_PLLLOCKINT)
+#define CYAS_DRQ_MASK (CY_AS_MEM_P0_INTR_REG_DRQINT)
+
+
+static void
+CyAstoriaISR (
+ void *dev_id)
+{
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAstoriaISR...");
+#endif
+ gpDfc->Add();
+
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("Disable interrupt");
+#endif
+ /* Disable Interrupt Here, it will be re-enabled by DFCs */
+ GPIO::DisableInterrupt(KGPIO_INT) ;
+}
+
+static void
+CyAstoriaIntHandler_DFC (
+ TAny *aPtr)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)aPtr ;
+ uint16_t read_val = 0 ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAstoriaIntHandler called...");
+#endif
+ {
+ read_val = CyAsHalReadRegister((CyAsHalDeviceTag)dev_p, CY_AS_MEM_P0_INTR_REG) ;
+ if (read_val & CYAS_INT_MASK)
+ {
+ CyAsIntrServiceInterrupt((CyAsHalDeviceTag)dev_p) ;
+ }
+
+ if (read_val & CYAS_DRQ_MASK)
+ {
+ CyHandleDRQInterrupt(dev_p) ;
+ }
+ }
+ GPIO::EnableInterrupt(KGPIO_INT) ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("Enable interrupt\n");
+#endif
+}
+
+extern TmtpAstDev * g_pAstDevice ;
+
+static int
+CyAsHalConfigureInterrupts (
+ void *dev_p,
+ void *handler)
+{
+
+ return CyAsHalBeagleBoard__SetupISR(handler, dev_p) ;
+}
+//nxz-debug
+void
+MyOmapStartIntr(CyAsHalDeviceTag tag)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+ int ret ;
+
+ const uint16_t mask = CY_AS_MEM_P0_INTR_REG_DRQINT | CY_AS_MEM_P0_INTR_REG_MBINT ;
+
+ /* Setup DFC */
+ gpDfc = new TDfc( CyAstoriaIntHandler_DFC, tag, Kern::DfcQue0(), 1 ) ;
+
+ /* Register for interrupts */
+ ret = CyAsHalConfigureInterrupts (dev_p,(void*)CyAstoriaISR) ;
+ if ( ret != 0 )
+ Kern::Printf("ERROR: CyAsHalConfigureInterrupts failed\n");
+
+ /* enable only MBox & DRQ interrupts for now */
+ CyAsHalWriteRegister((CyAsHalDeviceTag)dev_p, CY_AS_MEM_P0_INT_MASK_REG, mask) ;
+}
+
+volatile CyBool interrupt_fired = CyFalse;
+
+//This is the Diagnostics Interrupt Handler
+void
+MyIntTestHandler(
+ void *dev_id)
+{
+ CyAsOmapDevKernel * dev_tag = (CyAsOmapDevKernel*) dev_id ;
+
+ Kern::Printf("Diag: CyAsDiagIntHandler called\n");
+
+ if(interrupt_fired == CyFalse)
+ {
+ Kern::Printf("Diag: CyAsDiagIntHandler, first instance of INT# \n");
+ interrupt_fired = CyTrue;
+
+ //return INT to high state, only called for override testing
+ CyAsHalWriteRegister(dev_tag, CY_AS_MEM_P0_VM_SET, 0x0745);
+ }
+ //return INT to high state, only called for override testing
+ CyAsHalWriteRegister(dev_tag, CY_AS_MEM_P0_VM_SET, 0x0745);
+
+}
+
+
+
+/*
+* These are the functions that are not part of the HAL layer, but are required to be called
+* for this HAL.
+*/
+int StartOMAPKernel(const char *pgm, CyAsHalDeviceTag *tag, CyBool debug)
+{
+ CyAsOmapDevKernel *dev_p ;
+ CyAsHalSleepChannel channel ;
+ int i;
+
+ (void)debug ; /* No debug mode support as of now */
+
+ Kern::Printf ("<1>startOMAPKernel called\n");
+
+ /*
+ * Initialize the HAL level endpoint DMA data.
+ */
+ for(i = 0 ; i < sizeof(EndPoints)/sizeof(EndPoints[0]) ; i++)
+ {
+ EndPoints[i].data_p = 0 ;
+ EndPoints[i].pending = CyFalse ;
+ EndPoints[i].size = 0 ;
+ EndPoints[i].type = CyAsHalNone ;
+ EndPoints[i].bytes_xfered = 0 ;
+ EndPoints[i].transfer_cnt = 0 ;
+ }
+
+ dev_p = (CyAsOmapDevKernel *)CyAsHalAlloc(sizeof(CyAsOmapDevKernel)) ;
+ if (dev_p == 0)
+ {
+ Kern::Printf("<1>%s: out of memory allocating OMAP device structure\n", pgm) ;
+ return 0 ;
+ }
+ dev_p->m_sig = CY_AS_OMAP_KERNEL_HAL_SIG ;
+ dev_p->m_addr_base = 0 ;
+
+ CyAsHalBeagleBoard__ConfigureSPI();
+
+#ifdef HW_TEST
+{
+ uint16_t readVal = 0 ;
+ uint16_t timeOutCounter = 0 ;
+ uint16_t errCnt = 0 ;
+
+ Kern::Printf( "<1> Regsiter Test ------------->\n") ;
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_CM_WB_CFG_ID) ;
+ Kern::Printf("ID reg 0x%04x\n",readVal);
+ if ( readVal != 0xa200 )
+ {
+ Kern::Printf("ERROR: Wrong Antioch ID reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0xa200);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_P0_VM_SET) ;
+ Kern::Printf("P0_VM_SET 0x%04x\n",readVal);
+ if ( readVal != 0x45 )
+ {
+ Kern::Printf("ERROR: Wrong Antioch P0_VM_SET reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0x45);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_P0_RSE_ALLOCATE) ;
+ Kern::Printf("P0_RSE_ALLOCATE 0x%04x\n",readVal);
+ if ( readVal != 0x26 )
+ {
+ Kern::Printf("ERROR: Wrong Antioch P0_RSE_ALLOCATE reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0x26);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_MCU_MAILBOX0, 0x0);
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_MCU_MAILBOX1, 0xFFFF);
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_MCU_MAILBOX2, 0xAAAA);
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_MCU_MAILBOX3, 0x5555);
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_MCU_MAILBOX0) ;
+ Kern::Printf("mailbox0 0x%04x\n",readVal);
+ if ( readVal != 0x0 )
+ {
+ Kern::Printf("ERROR: Wrong Antioch MAILBOX0 reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0x0);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_MCU_MAILBOX1) ;
+ Kern::Printf("mailbox1 0x%04x\n",readVal);
+ if ( readVal != 0xffff )
+ {
+ Kern::Printf("ERROR: Wrong Antioch MAILBOX1 reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0xffff);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_MCU_MAILBOX2) ;
+ Kern::Printf("mailbox2 0x%04x\n",readVal);
+ if ( readVal != 0xaaaa )
+ {
+ Kern::Printf("ERROR: Wrong Antioch MAILBOX2 reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0xaaaa);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ readVal = CyAsHalReadRegister(dev_p, CY_AS_MEM_MCU_MAILBOX3) ;
+ Kern::Printf("mailbox3 0x%04x\n",readVal);
+ if ( readVal != 0x5555 )
+ {
+ Kern::Printf("ERROR: Wrong Antioch MAILBOX3 reg value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0x5555);
+ Kern::Printf("ERROR: Act: 0x%04x\n",readVal);
+ errCnt++;
+ }
+
+ Kern::Printf( "<1> Interrupt Test ------------->\n") ;
+ Kern::Printf("Checking that INT# can execute Procesor ISR:\n");
+
+ CyAsHalConfigureInterrupts (dev_p,(void*)MyIntTestHandler) ;
+
+ //overrid default INT# value, cause Astoria to assert INT#
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_P0_VM_SET, 0x0545);
+
+ do {
+ timeOutCounter++;
+ }while((interrupt_fired == CyFalse) && (timeOutCounter < 255));
+
+ if(interrupt_fired == CyTrue)
+ {
+ Kern::Printf("INT# fired Processor ISR\n");
+ }
+ else
+ {
+ Kern::Printf("ERROR: INT# did not fire processor ISR %i\n", interrupt_fired);
+ errCnt++;
+ }
+
+ if ( errCnt == 0 )
+ {
+ Kern::Printf("HW test passed!!\n") ;
+ }
+ else
+ Kern::Printf("HW test failed (%d)\n",errCnt) ;
+
+ Kern::Printf("Reset Astoria\n") ;
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_RST_CTRL_REG, CY_AS_MEM_RST_CTRL_REG_HARD) ;
+ return 0 ;
+}
+#endif
+
+ /*
+ * Now perform a hard reset of the device to have the new settings take
+ * effect
+ */
+ Kern::Printf("<1>West Bridge Device Enters hard reset\n") ;
+ CyAsHalWriteRegister(dev_p, CY_AS_MEM_RST_CTRL_REG, CY_AS_MEM_RST_CTRL_REG_HARD) ;
+
+ /*
+ * Sleep for 100 ms to be sure reset is complete.
+ */
+ Kern::Printf("<1>Sleep 100ms\n") ;
+ CyAsHalCreateSleepChannel (&channel) ;
+ CyAsHalSleepOn(&channel, 100) ;
+ CyAsHalDestroySleepChannel(&channel) ;
+ Kern::Printf("<1>MyOmapStartIntr\n") ;
+ MyOmapStartIntr(dev_p);
+
+ dev_p->m_next_p = m_omap_list_p ;
+ m_omap_list_p = dev_p ;
+
+ *tag = dev_p ;
+ gDevTag = dev_p ;
+
+ return 1 ;
+}
+
+int StopOMAPKernel(const char *pgm, CyAsHalDeviceTag tag)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+
+ if (0 == dev_p)
+ return 1 ;
+
+ Kern::Printf ("<1>StopOMAPKernel called\n");
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("<1>%s: %s: bad TAG parameter passed to function\n", pgm, __FUNCTION__) ;
+ return 1 ;
+ }
+
+ Kern::Printf ("<1>West Bridge OMAP Kernel: Done cleaning thread\n") ;
+ /* TODO: */
+
+ CyAsHalFree(dev_p) ;
+
+ return 1 ;
+}
+
+
+/*************************************************************************************************
+*
+* Below are the functions that communicate with the West Bridge device. These are system dependent
+* and must be defined by the HAL layer for a given system.
+*
+*************************************************************************************************/
+
+void
+CyAsHalWriteEP(CyAsHalDeviceTag tag, uint16_t addr, uint8_t* data, uint16_t size)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+GPIO::DisableInterrupt(KGPIO_INT) ;
+
+ /* Do additional error checks while in debug mode. */
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("<1>%s: bad TAG parameter passed to function\n", __FUNCTION__) ;
+ return ;
+ }
+
+ if (addr & 0x80)
+ {
+ Kern::Printf ("<1>West Bridge write EP address 0x%x out of range\n", addr);
+ return ;
+ }
+
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteEP(addr, data, size) ;
+GPIO::EnableInterrupt(KGPIO_INT) ;
+ return ;
+}
+
+void
+CyAsHalReadEP(CyAsHalDeviceTag tag, uint16_t addr, uint8_t* data, uint16_t size)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+GPIO::DisableInterrupt(KGPIO_INT) ;
+
+ /* Do additional error checks while in debug mode. */
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("<1>%s: bad TAG parameter passed to function\n", __FUNCTION__) ;
+ return ;
+ }
+
+ if (addr & 0x80)
+ {
+ Kern::Printf ("<1>West Bridge write EP address 0x%x out of range\n", addr);
+ return ;
+ }
+
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadEP(addr, data, size) ;
+GPIO::EnableInterrupt(KGPIO_INT) ;
+ return ;
+}
+
+/*
+* This function must be defined to write a register within the West Bridge
+* device. The addr value is the address of the register to write with
+* respect to the base address of the West Bridge device.
+*/
+void
+CyAsHalWriteRegister(CyAsHalDeviceTag tag, uint16_t addr, uint16_t data)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+GPIO::DisableInterrupt(KGPIO_INT) ;
+
+ /* Do additional error checks while in debug mode. */
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("<1>%s: bad TAG parameter passed to function\n", __FUNCTION__) ;
+ return ;
+ }
+
+ if (addr > CYAS_DEV_MAX_ADDR)
+ {
+ Kern::Printf ("<1>West Bridge write address 0x%x out of range\n", addr);
+ return ;
+ }
+
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg((TUint32) addr, (TUint16) data) ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAsHalWriteRegister(0x%02x,0x%04x)\n",addr,data) ;
+#endif
+GPIO::EnableInterrupt(KGPIO_INT) ;
+ return ;
+
+}
+
+/*
+* This function must be defined to read a register from the West Bridge
+* device. The addr value is the address of the register to read with
+* respect to the base address of the West Bridge device.
+*/
+uint16_t
+CyAsHalReadRegister(CyAsHalDeviceTag tag, uint16_t addr)
+{
+ uint16_t data = 0 ;
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag ;
+GPIO::DisableInterrupt(KGPIO_INT) ;
+
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("<1>%s: bad TAG parameter passed to function\n", __FUNCTION__) ;
+ return 0 ;
+ }
+
+ if (addr > CYAS_DEV_MAX_ADDR)
+ {
+ Kern::Printf("<1>West Bridge read address 0x%x out of range\n", addr) ;
+ return 0 ;
+ }
+
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg((TUint32) addr, (TUint16*) &data) ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAsHalReadRegister(0x%02x,0x%04x)\n",addr,data) ;
+#endif
+GPIO::EnableInterrupt(KGPIO_INT) ;
+ return data ;
+}
+
+static void
+CyServiceEPDmaReadRequest(CyAsOmapDevKernel *dev_p, uint8_t ep)
+{
+ CyAsHalDeviceTag tag = (CyAsHalDeviceTag)dev_p ;
+ uint16_t v ;
+ uint32_t size ;
+ uint16_t addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ;
+ uint8_t *dptr = (uint8_t*)EndPoints[ep].data_p ;
+
+
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyServiceEPDmaReadRequest...");
+#endif
+ /* Read the amount of data available */
+ v = CyAsHalReadRegister(tag, addr) ;
+ size = v & CY_AS_MEM_P0_EPn_DMA_REG_COUNT_MASK ;
+
+ CyAsHalReadEP(tag, ep, dptr, size) ;
+
+ /*
+ * Now, reset the DMAVAL bit indicating that the data has been read
+ */
+
+ CyAsHalWriteRegister(tag, addr, 0) ;
+
+ EndPoints[ep].pending = CyFalse ;
+ EndPoints[ep].type = CyAsHalNone ;
+ EndPoints[ep].buffer_valid = CyFalse ;
+
+ if (callback)
+ callback(tag, ep, size, CY_AS_ERROR_SUCCESS) ;
+}
+
+static void
+CyServiceEPDmaWriteRequest(CyAsOmapDevKernel *dev_p, uint8_t ep)
+{
+ CyAsHalDeviceTag tag = (CyAsHalDeviceTag)dev_p ;
+ uint16_t addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ;
+ uint8_t *dptr = (uint8_t *)EndPoints[ep].data_p ;
+ uint32_t size ;
+
+
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyServiceEPDmaWriteRequest...");
+#endif
+
+ if ( ep == CYASSTORAGE_WRITE_EP_NUM )
+ {
+ if ( EndPoints[ep].size == 0x180 )
+ {
+ size = 0x180 ;
+ }
+ else
+ size = 0x200 ;
+ }
+ else
+ size = EndPoints[ep].size ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("Service DMA write request EP%d, size=%d, ep.size=%d\n",ep,size,EndPoints[ep].size);
+#endif
+ #if 1
+ CyAsHalWriteEP(tag, ep, dptr, size) ;
+ #else
+ {
+ uint16_t v ;
+ int i ;
+ for(i = 0 ; i < size / 2 ; i++)
+ {
+ v = dptr[0] | (dptr[1] << 8) ;
+ CyAsHalWriteRegister(tag, ep, v) ;
+ dptr++ ;
+ dptr++ ;
+ }
+ }
+ #endif
+
+ /*
+ * Now, write the DMAVAL bit to indicate we are done transferring data and that the data
+ * can now be sent via USB to the USB host, sent to storage, or used internally.
+ */
+ CyAsHalWriteRegister(tag, addr, size) ;
+
+ /* We have sent the data, mark it as false */
+ EndPoints[ep].pending = CyFalse ;
+ EndPoints[ep].type = CyAsHalNone ;
+ EndPoints[ep].buffer_valid = CyFalse ;
+
+ /*
+ * Finally, tell the USB subsystem that the data is gone and we can accept the
+ * next request if one exists.
+ */
+ if (callback)
+ callback(tag, ep, size, CY_AS_ERROR_SUCCESS) ;
+}
+
+static void
+CyHandleDRQInterrupt(CyAsOmapDevKernel *dev_p)
+{
+ uint16_t v ;
+ static uint8_t service_ep = 2 ;
+ static CyBool indrq = CyFalse ;
+
+ /*Kern::Printf("<1>DRQ interrupt detected\n") ;*/
+ if (indrq)
+ {
+#ifndef NDEBUG
+
+ Kern::Printf("<1>+++++++++ Nested DRQ interrupt detected\n") ;
+ v = CyAsHalReadRegister((CyAsHalDeviceTag)dev_p, CY_AS_MEM_P0_INTR_REG) ;
+ Kern::Printf("<1>+++++++++ INTR_REG = %04x\n",v) ;
+ v = CyAsHalReadRegister((CyAsHalDeviceTag)dev_p, CY_AS_MEM_P0_DRQ) ;
+ Kern::Printf("<1>+++++++++ DRQ_REG = %04x\n",v) ;
+#endif
+ return ;
+ }
+
+ indrq = CyTrue ;
+
+ /*
+ * We have received a DMA interrupt
+ */
+ v = CyAsHalReadRegister((CyAsHalDeviceTag)dev_p, CY_AS_MEM_P0_DRQ) ;
+ if (v == 0)
+ {
+#ifndef NDEBUG
+ /*Stray DRQ is possible because we will check DRQ register before exit handler*/
+ Kern::Printf("<1>+++++++++ Stray DRQ interrupt detected\n") ;
+#endif
+ indrq = CyFalse;
+ return ;
+ }
+
+ /*
+ * Now, pick a given DMA request to handle, for now, we just go round robin. Each bit
+ * position in the service_mask represents an endpoint from EP2 to EP15. We rotate through
+ * each of the endpoints to find one that needs to be serviced.
+ */
+ while ((v & (1 << service_ep)) == 0)
+ {
+ if (service_ep == 15)
+ service_ep = 2 ;
+ else
+ service_ep++ ;
+ }
+
+ if ((v & (1 << service_ep)) == 0)
+ {
+ Kern::Printf("<1>+++++++++ Internal error, this should not happen\n") ;
+ indrq = CyFalse;
+ return ;
+ }
+
+ if (EndPoints[service_ep].type == CyAsHalWrite)
+ CyServiceEPDmaWriteRequest(dev_p, service_ep) ;
+ else if (EndPoints[service_ep].type == CyAsHalRead)
+ CyServiceEPDmaReadRequest(dev_p, service_ep) ;
+
+#ifndef NDEBUG
+ else
+ {
+ Kern::Printf("+++++++ Interrupt occurred, but there is no DMA operation pending - check DRQ_MASK logic\n") ;
+ }
+#endif
+
+ /* Now bump the EP ahead, so other endpoints get a shot before the one we just serviced */
+ if (EndPoints[service_ep].type == CyAsHalNone)
+ {
+ if (service_ep == 15)
+ service_ep = 2 ;
+ else
+ service_ep++ ;
+ }
+
+ indrq = CyFalse ;
+}
+
+void
+CyAsHalDmaCancelRequest(CyAsHalDeviceTag tag, uint8_t ep)
+{
+ if (EndPoints[ep].pending)
+ CyAsHalWriteRegister(tag, CY_AS_MEM_P0_EP2_DMA_REG + ep - 2, 0) ;
+
+ EndPoints[ep].buffer_valid = CyFalse ;
+}
+
+/*
+* This function must be defined to transfer a block of data to the West Bridge device. This
+* function can use the burst write (DMA) capabilities of West Bridge to do this, or it can
+* just copy the data using writes.
+*/
+void
+CyAsHalDmaSetupWrite(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize)
+{
+ uint32_t addr ;
+ uint16_t v ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAsHalDmaSetupWrite (%d,%d)",size,maxsize);
+#endif
+ /* No EP0 or EP1 traffic should get here */
+ CyAsHalAssert(ep != 0 && ep != 1) ;
+
+ /*
+ * If this asserts, we have an ordering problem. Another DMA request is coming down
+ * before the previous one has completed.
+ */
+ CyAsHalAssert(EndPoints[ep].buffer_valid == CyFalse) ;
+
+ /*
+ * Store the data for the interrupt service routine
+ */
+ EndPoints[ep].buffer_valid = CyTrue ;
+ EndPoints[ep].data_p = (uint16_t*)buf ;
+ EndPoints[ep].size = size ;
+ EndPoints[ep].type = CyAsHalWrite ;
+
+ /*
+ * Tell West Bridge we are ready to send data on the given endpoint
+ */
+ {
+ addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ;
+ v = (size & CY_AS_MEM_P0_EPn_DMA_REG_COUNT_MASK) | CY_AS_MEM_P0_EPn_DMA_REG_DMAVAL ;
+ }
+
+ CyAsHalWriteRegister(tag, addr, v) ;
+
+}
+
+/*
+* This function must be defined to transfer a block of data from the West Bridge device. This
+* function can use the burst read (DMA) capabilities of West Bridge to do this, or it can just
+* copy the data using reads.
+*/
+void
+CyAsHalDmaSetupRead(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize)
+{
+ uint32_t addr ;
+ uint16_t v ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("CyAsHalDmaSetupRead (%d,%d)",size,maxsize);
+#endif
+ /* No EP0 or EP1 traffic should get here */
+ CyAsHalAssert(ep != 0 && ep != 1) ;
+ CyAsHalAssert(EndPoints[ep].buffer_valid == CyFalse) ;
+
+ EndPoints[ep].buffer_valid = CyTrue ;
+ EndPoints[ep].data_p = (uint16_t*)buf ;
+ EndPoints[ep].size = size ;
+ EndPoints[ep].type = CyAsHalRead ;
+
+ /*
+ * Program the EP DMA register for Storage endpoints only.
+ */
+ if (ep == 2)
+ {
+ if (size == 1)
+ size = 2 ;
+
+ addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ;
+ v = (size & CY_AS_MEM_P0_EPn_DMA_REG_COUNT_MASK) | CY_AS_MEM_P0_EPn_DMA_REG_DMAVAL;
+ CyAsHalWriteRegister(tag, addr, v );
+ }
+ else if (ep == CYASSTORAGE_READ_EP_NUM)
+ {
+ addr = CY_AS_MEM_P0_EP8_DMA_REG ;
+
+ /* This transfer is always done in 512 byte chunks. */
+ v = 0x200 | CY_AS_MEM_P0_EPn_DMA_REG_DMAVAL ;
+ CyAsHalWriteRegister(tag, addr, v) ;
+ }
+}
+
+/*
+* This function must be defined to allow the West Bridge API to register a callback function that is
+* called when a DMA transfer is complete.
+*/
+void
+CyAsHalDmaRegisterCallback(CyAsHalDeviceTag tag, CyAsHalDmaCompleteCallback cb)
+{
+ callback = cb ;
+}
+
+/*
+* This function must be defined to return the maximum size of DMA request that can be handled
+* on the given endpoint. The return value should be the maximum size in bytes that the DMA
+* module can handle.
+*/
+uint32_t
+CyAsHalDmaMaxRequestSize(CyAsHalDeviceTag tag, CyAsEndPointNumber_t ep)
+{
+ /* Storage reads and writes are always done in 512 byte blocks. So, we do the count
+ handling within the HAL, and save on some of the data transfer delay.
+ */
+ if ((ep == CYASSTORAGE_READ_EP_NUM) || (ep == CYASSTORAGE_WRITE_EP_NUM))
+ return CYASSTORAGE_MAX_XFER_SIZE;
+ else
+ /*
+ * For the USB - Processor endpoints, the maximum transfer size depends on
+ * the speed of USB operation. So, we use the following constant to
+ * indicate to the API that splitting of the data into chunks less than
+ * or equal to the max transfer size should be handled internally.
+ */
+ return CY_AS_DMA_MAX_SIZE_HW_SIZE;
+}
+
+/*
+ * This function must be defined to set the state of the WAKEUP pin on the West Bridge device. Generally
+ * this is done via a GPIO of some type.
+ */
+CyBool
+CyAsHalSetWakeupPin(CyAsHalDeviceTag tag, CyBool state)
+{
+ /* Not supported as of now. */
+ return CyFalse ;
+}
+
+void
+CyAsHalPllLockLossHandler(CyAsHalDeviceTag tag)
+{
+ Kern::Printf("Error: West Bridge PLL has lost lock\n") ;
+ Kern::Printf("Please check the input voltage levels and clock, and restart the system\n") ;
+}
+
+#define CYASHAL_REGISTERS_TO_SAVE_COUNT (12)
+static uint16_t gAstoriaRegCache[CYASHAL_REGISTERS_TO_SAVE_COUNT][2] = {
+ {CY_AS_MEM_P0_ENDIAN, 0x0000},
+ {CY_AS_MEM_PMU_UPDATE, 0x0000},
+ {CY_AS_MEM_P0_VM_SET, 0x0000},
+ {CY_AS_MEM_P0_INT_MASK_REG, 0x0000},
+ {CY_AS_MEM_P0_RSE_ALLOCATE, 0x0000},
+ {CY_AS_MEM_P0_RSE_MASK, 0x0000},
+ {CY_AS_MEM_P0_DRQ_MASK, 0x0000},
+ {CY_AS_MEM_IROS_SLB_DATARET, 0x0000},
+ {CY_AS_MEM_IROS_IO_CFG, 0x0000},
+ {CY_AS_MEM_IROS_PLL_CFG, 0x0000},
+ {CY_AS_MEM_IROS_PXB_DATARET, 0x0000},
+ {CY_AS_MEM_IROS_SLEEP_CFG, 0x0000}
+};
+
+void
+CyAsHalReadRegsBeforeStandby (
+ CyAsHalDeviceTag tag)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag;
+ int i, pos;
+
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("%s: bad TAG parameter passed to function\n", __FUNCTION__);
+ return;
+ }
+
+ {
+ for (i = 0; i < CYASHAL_REGISTERS_TO_SAVE_COUNT; i++)
+ {
+ gAstoriaRegCache[i][1] = CyAsHalReadRegister (tag, gAstoriaRegCache[i][0]);
+
+ /* Special handling required for the RSE_ALLOCATE register, so as to
+ ensure that the SD_IO pin ownership is set correctly.
+ */
+ if (gAstoriaRegCache[i][0] == CY_AS_MEM_P0_RSE_ALLOCATE)
+ {
+ /* For each of the 4 two bits fields in the register, set it to 'b01 if the
+ * resource is currently allocated to the P port, and 'b10 if it is currently
+ * allocated to Astoria.
+ */
+ for (pos = 0; pos < 8; pos+= 2)
+ {
+ if (((gAstoriaRegCache[i][1] >> pos) & 0x03) == 0x03)
+ gAstoriaRegCache[i][1] = (gAstoriaRegCache[i][1] & (0xFF ^ (0x03 << pos))) | (0x01 << pos);
+ else
+ gAstoriaRegCache[i][1] = (gAstoriaRegCache[i][1] & (0xFF ^ (0x03 << pos))) | (0x02 << pos);
+ }
+ }
+ }
+ }
+}
+
+void
+CyAsHalRestoreRegsAfterStandby (
+ CyAsHalDeviceTag tag)
+{
+ CyAsOmapDevKernel *dev_p = (CyAsOmapDevKernel *)tag;
+ int i;
+
+ if (dev_p->m_sig != CY_AS_OMAP_KERNEL_HAL_SIG)
+ {
+ Kern::Printf("%s: bad TAG parameter passed to function\n", __FUNCTION__);
+ return;
+ }
+
+ {
+ /* Write 0xFF into the mask register so that all fields can be updated.
+ The mask will get updated to its proper value later.
+ */
+ CyAsHalWriteRegister (tag, CY_AS_MEM_P0_RSE_MASK, 0xFF);
+ for (i = 0; i < CYASHAL_REGISTERS_TO_SAVE_COUNT; i++)
+ {
+ CyAsHalWriteRegister (tag, gAstoriaRegCache[i][0], gAstoriaRegCache[i][1]);
+ }
+ }
+}
+
+void
+CyAsHalInitDevRegisters(
+ CyAsHalDeviceTag tag,
+ CyBool is_standby_wakeup)
+{
+ (void)tag;
+ (void)is_standby_wakeup;
+ Kern::Printf("CyAsHalInitDevRegisters...");
+ return ;
+}
+
+
+void
+CyAsHalPrintMessage2(const char* msg)
+{
+ Kern::Printf("%s",msg);
+}
+
+/*************************************************************************************************
+*
+* Below are the functions that must be defined to provide the basic operating system services
+* required by the API.
+*
+*************************************************************************************************/
+
+/*
+ * This function is required by the API to allocate memory. This function is expected to work
+ * exactly like malloc().
+ */
+void *
+CyAsHalAlloc(uint32_t cnt)
+{
+ void *ret_p ;
+ /*ret_p = kmalloc(cnt, GFP_KERNEL) ;*/
+ ret_p = (void*) new TUint8[cnt];
+ return ret_p ;
+}
+
+/*
+ * This function is required by the API to free memory allocated with CyAsHalAlloc(). This function is
+ * expected to work exacly like free().
+ */
+void
+CyAsHalFree(void *mem_p)
+{
+ delete [] (mem_p) ;
+}
+
+/*
+ * Allocator that can be used in interrupt context. We have to ensure that the kmalloc
+ * call does not sleep in this case.
+ */
+void *
+CyAsHalCBAlloc(uint32_t cnt)
+{
+ void *ret_p ;
+
+ /* TODO:
+ ret_p = kmalloc(cnt, GFP_ATOMIC) ;*/
+ ret_p = (void*) new TUint8[cnt];
+ return ret_p ;
+}
+
+/*
+ * This function is required to set a block of memory to a specific value. This function is
+ * expected to work exactly like memset()
+ */
+void
+CyAsHalMemSet(void *ptr, uint8_t value, uint32_t cnt)
+{
+ /*uint32_t i ;
+ uint8_t* b = (uint8_t*) ptr ;
+ for ( i = 0 ; i < cnt ; i++ )
+ *b = value ;
+ TODO: */
+ memset(ptr, value, cnt) ;
+}
+
+
+/*
+ * This function is expected to create a sleep channel. The data structure that represents the
+ * sleep channel is given by the pointer in the argument.
+ */
+CyBool
+CyAsHalCreateSleepChannel(CyAsHalSleepChannel *channel)
+{
+ /* TODO:
+ init_waitqueue_head(&channel->wq) ;
+ return CyTrue ;*/
+ if (channel)
+ channel->wq = 0 ;
+ return CyTrue ;
+}
+
+/*
+ * This function is expected to destroy a sleep channel. The data structure that represents the
+ * sleep channel is given by the pointer in the argument.
+ */
+CyBool
+CyAsHalDestroySleepChannel(CyAsHalSleepChannel *channel)
+{
+ /* TODO:
+ return CyTrue ;*/
+ channel->wq =1 ;
+ return CyTrue ;
+}
+
+CyBool
+CyAsHalSleepOn(CyAsHalSleepChannel *channel, uint32_t ms)
+{
+ /* TODO:
+ interruptible_sleep_on_timeout (&channel->wq, (ms * HZ/1000)) ;
+ return CyTrue ;*/
+
+ NKern::Sleep(ms);
+ return CyTrue;
+}
+
+CyBool
+CyAsHalWake(CyAsHalSleepChannel *channel)
+{
+
+ /* TODO:
+ wake_up (&channel->wq) ;
+ return CyTrue ;*/
+ channel->wq = 1 ;
+ return CyTrue ;
+
+}
+
+uint32_t
+CyAsHalDisableInterrupts()
+{
+ uint16_t v = CyAsHalReadRegister(gDevTag,CY_AS_MEM_P0_INT_MASK_REG);
+ if ( !Intr_Disabled )
+ {
+ CyAsHalWriteRegister(gDevTag,CY_AS_MEM_P0_INT_MASK_REG,0);
+ }
+ Intr_Disabled++ ;
+ return (uint32_t)v ;
+}
+
+void
+CyAsHalEnableInterrupts(uint32_t val)
+{
+ Intr_Disabled-- ;
+ if ( !Intr_Disabled )
+ {
+ val = CYAS_INT_MASK | CYAS_DRQ_MASK ;
+ CyAsHalWriteRegister(gDevTag,CY_AS_MEM_P0_INT_MASK_REG,(uint16_t)val);
+ /*CyAsHalWriteRegister(gDevTag,CY_AS_MEM_P0_INT_MASK_REG,0x1800);*/
+ }
+}
+
+void
+CyAsHalSleep150 (void) /* Sleep atleast 150ns */
+{
+ uint32_t i, j;
+
+ j = 0;
+ for (i = 0; i < 100; i++)
+ j += (~i);
+}
+
+int j = 0;
+void
+CyAsHalSleep(uint32_t ms)
+{
+ int i;
+
+ while (ms--)
+ {
+ i = 60000;
+ while (i--)
+ {
+ j += ((i * ~i) + 3 * i + 79);
+ }
+ }
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+int gInitComplete = 0 ;
+
+/*
+ * This callback function is called for events from the MISC module. The primary event
+ * processed by this function is the CyAsEventMiscInitialized which is sent once the
+ * West Bridge device is initialized and ready to accept requests.
+ */
+static void
+CyMiscCallback(CyAsDeviceHandle h, CyAsMiscEventType evtype, void *evdata)
+{
+ (void)h ;
+ (void)evdata ;
+
+ switch(evtype)
+ {
+ case CyAsEventMiscInitialized:
+ Kern::Printf("Firmware initialized");
+ gInitComplete = CyTrue ;
+ break ;
+ default:
+ break ;
+ }
+}
+
+int
+CyAsHalAstoriaInit(void)
+{
+ uint32_t ret = 0 ;
+ char* pgm = "Beagleboard HAL";
+ CyAsDeviceHandle dev_handle ;
+ CyAsDeviceConfig config ;
+ CyAsHalDeviceTag tag ;
+
+ if (!StartOMAPKernel(pgm, &tag, CyFalse))
+ {
+#ifndef HW_TEST
+ Kern::Printf("ERROR: Cannot start OMAPKernel\n") ;
+#endif
+ return 1 ;
+ }
+
+ /*
+ * Create a handle to a West Bridge device. It tag is used to identifiy the specific hardware
+ * we are talking to.
+ */
+ Kern::Printf("** Create API device\n") ;
+ ret = CyAsMiscCreateDevice(&dev_handle, tag) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("%s: cannot initailize the West Bridge API - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** API device created\n") ;
+
+ /*
+ * Configure the physical bus so we can talk to the West Bridge device. This is the first required
+ * API call after creating a device.
+ */
+ Kern::Printf("** API device configuring...\n");
+ memset(&config, 0, sizeof(config)) ;
+ ret = CyAsMiscConfigureDevice(dev_handle, &config) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("%s: cannot configure the West Bridge device - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** API device configured\n") ;
+
+ /*
+ * Register a callback to process events from the MISC module.
+ */
+ Kern::Printf("** Register Callback...\n") ;
+ ret = CyAsMiscRegisterCallback(dev_handle, CyMiscCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("%s: cannot configure the West Bridge device - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** Register Callback done\n") ;
+ /*
+ * Download the firmware to the device. Until the firmware has been downloaded, the West Bridge
+ * device cannot response to requests from the P port processor.
+ */
+ Kern::Printf("** Download firmware...\n") ;
+#ifdef FIRMWARE_NOPPORT
+
+#ifdef OVERCLOCK_SD
+ ret = CyAsMiscDownloadFirmware(dev_handle, CyAnFirmware.fw_image,
+ (uint16_t)CYANFW_SIZE, 0, 0) ;
+#else
+ ret = CyAsMiscDownloadFirmware(dev_handle, cyastfw_sd_mmc_rel_nopport_array.fw_image,
+ (uint16_t)CYASTFW_SD_MMC_REL_NOPPORT_SIZE, 0, 0) ;
+#endif
+
+#else
+
+#ifdef OVERCLOCK_SD
+ ret = CyAsMiscDownloadFirmware(dev_handle, CyAnFirmware.fw_image,
+ (uint16_t)CYANFW_SIZE, 0, 0) ;
+#else
+ ret = CyAsMiscDownloadFirmware(dev_handle, cyastfw_sd_mmc_rel_silicon_array.fw_image,
+ (uint16_t)CYASTFW_SD_MMC_REL_SILICON_SIZE, 0, 0) ;
+#endif
+
+#endif
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("%s: cannot download the antioch firmware - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** API device loaded firmware\n") ;
+
+ /*
+ * Note, if a firmware image is not provided, the firmware can still be loaded if the West Bridge device
+ * is in DEBUG mode. In debug mode, the firmware can be loaded via USB. In general however, the firmware
+ * should be loaded via the P Port and therefore a firmware file name should be provided.
+ */
+
+ /*
+ * Wait for the initialization event telling me that the firmware
+ * has completed initialization and is ready to go. The sleep of 100 ms
+ * is used to insure that we do not burn too many CPU cycles while waiting on
+ * the firmware initialization to finish.
+ */
+#ifndef FIRMWARE_NOPPORT
+ while (!gInitComplete)
+ {
+ NKern::Sleep(1000);
+ }
+
+ Kern::Printf("Firmware donwloaded successfully!!") ;
+#if 0
+#ifdef STORAGE_TEST
+ ret = CyAsSymbianStorageTest("Symbian WB Test",dev_handle, tag);
+ if ( !ret )
+ {
+ Kern::Printf("%s: CyAsSymbianStorageTest failed - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** CyAsSymbianStorageTest done\n") ;
+#else
+ ret = CyAsAPIUsbInit("Symbian WB Test",dev_handle, tag);
+ if ( !ret )
+ {
+ Kern::Printf("%s: CyAsAPIUsbInit failed - code %d\n", pgm, ret) ;
+ return 1 ;
+ }
+ Kern::Printf("** CyAsAPIUsbInit done\n") ;
+#endif
+#endif
+
+#endif
+
+ ret = CyAsAPIGetHandle(dev_handle, tag);
+ Kern::Printf("** CyAsAPIGetHandle done\n") ;
+
+ return 0 ;
+}
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+
+#else
+/*
+* Some compilers do not like empty C files, so if the OMAP hal is not being
+* compiled, we compile this single function. We do this so that for a given target
+* HAL there are not multiple sources for the HAL functions.
+*/
+void MyOMAPKernelHalDummyFunction(
+ void)
+{
+}
+
+#endif
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/hal/cyashalbeagleboard.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,347 @@
+/* Cypress West Bridge HAL for beagleboard SPI Symbian header file (cyashalbeagleboard_spi.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+/*
+ * This file contains the defintion of the hardware abstraction layer on beagleboard
+ * talking to the West Bridge device through SPI interface
+ */
+
+
+#ifndef _INCLUDED_CYASHALBEAGLEBOARD_H_
+#define _INCLUDED_CYASHALBEAGLEBOARD_H_
+
+typedef struct CyAsHalSleepChannel_t {
+ /* TODO:
+ wait_queue_head_t wq ;*/
+ int wq ;
+} CyAsHalSleepChannel ;
+typedef CyAsHalSleepChannel CyAnHalSleepChannel;
+
+#include "cyastypes.h"
+#include "cyas_cplus_start.h"
+
+typedef enum CyAsHalInterfaceMode
+{
+ CyAsHalCRAMMode = 0,
+ CyAsHalSRAMMode = 1,
+ CyAsHalADMMode = 2,
+ CyAsHalPNANDLBD8Mode = 3,
+ CyAsHalPNANDLBD16Mode = 4,
+ CyAsHalPNANDSBD8Mode = 5,
+ CyAsHalPNANDSBD16Mode = 6,
+ CyAsHalSPIMode = 7,
+ CyAsHalLNAMode = 8,
+ CyAsHalUnknownMode = 9
+} CyAsHalInterfaceMode;
+
+/*************************************************************************************************
+ *
+ * Below are the data structures that must be defined by the HAL layer
+ *
+ *************************************************************************************************/
+
+/*
+ * The HAL layer must define a TAG for identifying a specific West Bridge device in the system.
+ * In this case the tag is a void * which is really an OMAP device pointer
+ */
+typedef void * CyAsHalDeviceTag ;
+typedef CyAsHalDeviceTag CyAnHalDeviceTag;
+
+/* This must be included after the CyAsHalDeviceTag type is defined */
+#include "cyashalcb.h"
+
+/*************************************************************************************************
+ *
+ * Below are the functions that communicate with the West Bridge device. These are system dependent
+ * and must be defined by the HAL layer for a given system.
+ *
+ *************************************************************************************************/
+
+/*
+ * This function must be defined to write a register within the West Bridge
+ * device. The addr value is the address of the register to write with
+ * respect to the base address of the West Bridge device.
+ */
+extern void
+CyAsHalWriteRegister(CyAsHalDeviceTag tag, uint16_t addr, uint16_t data) ;
+#define CyAnHalWriteRegister(tag, addr, data) CyAsHalWriteRegister((CyAsHalDeviceTag)(tag), (addr), (data))
+
+/*
+ * This function must be defined to read a register from the West Bridge
+ * device. The addr value is the address of the register to read with
+ * respect to the base address of the West Bridge device.
+ */
+uint16_t
+CyAsHalReadRegister(CyAsHalDeviceTag tag, uint16_t addr) ;
+#define CyAnHalReadRegister(tag, addr) CyAsHalReadRegister((CyAsHalDeviceTag)(tag), (addr))
+
+/*
+ * This function must be defined to transfer a block of data to the West Bridge device. This
+ * function can use the burst write (DMA) capabilities of West Bridge to do this, or it can
+ * just copy the data using writes.
+ */
+extern void
+CyAsHalDmaSetupWrite(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize) ;
+#define CyAnHalDmaSetupWrite(tag, ep, buf, sz, max) \
+ CyAsHalDmaSetupWrite((CyAsHalDeviceTag)(tag), (ep), (buf), (sz), (max))
+
+/*
+ * This function must be defined to transfer a block of data from the West Bridge device. This
+ * function can use the burst read (DMA) capabilities of West Bridge to do this, or it can just
+ * copy the data using reads.
+ */
+extern void
+CyAsHalDmaSetupRead(CyAsHalDeviceTag tag, uint8_t ep, void *buf, uint32_t size, uint16_t maxsize) ;
+#define CyAnHalDmaSetupRead(tag, ep, buf, sz, max) \
+ CyAsHalDmaSetupRead((CyAsHalDeviceTag)(tag), (ep), (buf), (sz), (max))
+
+/*
+ * This function must be defined to cancel any pending DMA request.
+ */
+extern void
+CyAsHalDmaCancelRequest(CyAsHalDeviceTag tag, uint8_t ep) ;
+#define CyAnHalDmaCancelRequest(tag, ep) CyAsHalDmaCancelRequest((CyAsHalDeviceTag)(tag), (ep))
+
+/*
+ * This function must be defined to allow the West Bridge API to register a callback function that is
+ * called when a DMA transfer is complete.
+ */
+extern void
+CyAsHalDmaRegisterCallback(CyAsHalDeviceTag tag, CyAsHalDmaCompleteCallback cb) ;
+#define CyAnHalDmaRegisterCallback(tag, cb) \
+ CyAsHalDmaRegisterCallback((CyAsHalDeviceTag)(tag), (CyAsHalDmaRegisterCallback)(cb))
+
+/*
+ * This function must be defined to return the maximum size of DMA request that can be handled
+ * on the given endpoint. The return value should be the maximum size in bytes that the DMA
+ * module can handle.
+ */
+extern uint32_t
+CyAsHalDmaMaxRequestSize(CyAsHalDeviceTag tag, CyAsEndPointNumber_t ep) ;
+#define CyAnHalDmaMaxRequestSize(tag, ep) \
+ CyAsHalDmaMaxRequestSize((CyAsHalDeviceTag)(tag), (CyAsEndPointNumber_t)(ep))
+
+/*
+ * This function must be defined to set the state of the WAKEUP pin on the West Bridge device. Generally
+ * this is done via a GPIO of some type.
+ */
+extern CyBool
+CyAsHalSetWakeupPin(CyAsHalDeviceTag tag, CyBool state) ;
+#define CyAnHalSetWakeupPin(tag, state) CyAsHalSetWakeupPin((CyAsHalDeviceTag)(tag), (state))
+
+/*
+ * This function is called when the West Bridge PLL loses lock, because
+ * of a problem in the supply voltage or the input clock.
+ */
+extern void
+CyAsHalPllLockLossHandler(CyAsHalDeviceTag tag) ;
+#define CyAnHalPllLockLossHandler(tag) CyAsHalPllLockLossHandler((CyAsHalDeviceTag)(tag))
+
+/*
+ * Function to re-synchronise connection between Processor and West Bridge.
+ * This is a no-operation for this HAL.
+ */
+extern CyBool
+CyAsHalSyncDeviceClocks(CyAsHalDeviceTag tag) ;
+#define CyAsHalSyncDeviceClocks(tag) (CyTrue)
+
+/*
+ * Function to re-initialize West Bridge register when waking up from standby.
+ * This is a no-operation for this HAL.
+ */
+extern void
+CyAsHalInitDevRegisters(CyAsHalDeviceTag tag, CyBool is_standby_wakeup ) ;
+
+
+/*
+ * Function to read and save register values before Astoria is put into standby mode.
+ */
+extern void
+CyAsHalReadRegsBeforeStandby (
+ CyAsHalDeviceTag tag) ;
+
+/*
+ * Function to restore original values to registers after Astoria wakes up from standby mode.
+ */
+extern void
+CyAsHalRestoreRegsAfterStandby (
+ CyAsHalDeviceTag tag) ;
+
+/*************************************************************************************************
+ *
+ * Below are the functions that must be defined to provide the basic operating system services
+ * required by the API.
+ *
+ *************************************************************************************************/
+
+/*
+ * This function is required by the API to allocate memory. This function is expected to work
+ * exactly like malloc().
+ */
+void *
+CyAsHalAlloc(uint32_t cnt) ;
+#define CyAnHalAlloc(cnt) CyAsHalAlloc(cnt)
+
+/*
+ * This function is required by the API to free memory allocated with CyAsHalAlloc(). This function is
+ * expected to work exacly like free().
+ */
+void
+CyAsHalFree(void *mem_p) ;
+#define CyAnHalFree(ptr) CyAsHalFree(ptr)
+
+/*
+ * This function is required by the API to allocate memory during a callback. This function must be able to
+ * provide storage at inturupt time.
+ */
+void *
+CyAsHalCBAlloc(uint32_t cnt) ;
+#define CyAnHalCBAlloc(cnt) CyAsHalCBAlloc(cnt)
+
+/*
+ * This function is required by the API to free memory allocated with CyAsHalCBAlloc.
+ */
+void
+CyAsHalCBFree(void *mem_p) ;
+#define CyAsHalCBFree(ptr) CyAsHalFree(ptr)
+#define CyAnHalCBFree(ptr) CyAsHalFree(ptr)
+
+/*
+ * This function is required to set a block of memory to a specific value. This function is
+ * expected to work exactly like memset()
+ */
+void
+CyAsHalMemSet(void *ptr, uint8_t value, uint32_t cnt) ;
+#define CyAnHalMemSet(ptr, value, cnt) CyAsHalMemSet((ptr), (value), (cnt))
+
+/*
+ * This function is expected to create a sleep channel. The data structure that represents the
+ * sleep channel is given by the pointer in the argument.
+ */
+CyBool
+CyAsHalCreateSleepChannel(CyAsHalSleepChannel *channel) ;
+#define CyAnHalCreateSleepChannel(ch) CyAsHalCreateSleepChannel((CyAsHalSleepChannel *)(ch))
+
+/*
+ * This function is expected to destroy a sleep channel. The data structure that represents the
+ * sleep channel is given by the pointer in the argument.
+ */
+CyBool
+CyAsHalDestroySleepChannel(CyAsHalSleepChannel *channel) ;
+#define CyAnHalDestroySleepChannel(ch) CyAsHalDestroySleepChannel((CyAsHalSleepChannel *)(ch))
+
+CyBool
+CyAsHalSleepOn(CyAsHalSleepChannel *channel, uint32_t ms) ;
+#define CyAnHalSleepOn(ch, ms) CyAsHalSleepOn((CyAsHalSleepChannel *)(ch), (ms))
+
+CyBool
+CyAsHalWake(CyAsHalSleepChannel *channel) ;
+#define CyAnHalWake(ch) CyAsHalWake((CyAsHalSleepChannel *)(ch))
+
+uint32_t
+CyAsHalDisableInterrupts(void) ;
+#define CyAnHalDisableInterrupts() CyAsHalDisableInterrupts()
+
+void
+CyAsHalEnableInterrupts(uint32_t);
+#define CyAnHalEnableInterrupts(msk) CyAsHalEnableInterrupts(msk)
+
+void
+CyAsHalSleep150(void) ;
+#define CyAnHalSleep150() CyAsHalSleep150()
+
+void
+CyAsHalSleep(uint32_t ms) ;
+#define CyAnHalSleep(ms) CyAsHalSleep(ms)
+
+#define CyAsHalIsPolling() (CyFalse)
+#define CyAsHalDisablePolling()
+#define CyAsHalEnablePolling()
+
+#define CyAnHalIsPolling() (CyFalse)
+#define CyAnHalDisablePolling()
+#define CyAnHalEnablePolling()
+
+#define CyAsHalPrintMessage
+//#define CyAsHalPrintMessage Kern::Printf
+#define CyAnHalPrintMessage CyAsHalPrintMessage
+
+void
+CyAsHalPrintMessage2(const char* msg);
+
+/*#define CyAsHalAssert(cond) if (!(cond)) { CyAsHalPrintMessage ("Assertion failed at %s:%d\n", __FILE__, __LINE__); }*/
+#define CyAsHalAssert(cond)
+#define CyAnHalAssert(cond) CyAsHalAssert(cond)
+
+/*
+ As this is a completely interrupt driven HAL, there is no
+ need to implement the following functions.
+ */
+
+/*
+ * These are the functions that are not part of the HAL layer, but are required to be called
+ * for this HAL.
+ */
+int StartBeagleboardHal(const char *pgm, CyAsHalDeviceTag *tag, CyBool debug) ;
+int StopBeagleboardHal(const char *pgm, CyAsHalDeviceTag tag) ;
+
+/*
+ * Constants
+ */
+#define CY_AS_OMAP_KERNEL_HAL_SIG (0x1441)
+
+#define CYAS_DEV_MAX_ADDR (0xFF)
+#define CYAS_DEV_ADDR_RANGE (CYAS_DEV_MAX_ADDR << 16)
+
+/* The base address is added in the kernel module code. */
+#define CYAS_DEV_CALC_ADDR(addr) (addr << 16)
+
+/*
+ * Data structures
+ */
+typedef struct CyAsOmapDevKernel
+{
+ /* This is the signature for this data structure */
+ unsigned int m_sig ;
+
+ /* Address base of West Bridge Device */
+ void *m_addr_base ;
+
+ /* This is a pointer to the next West Bridge device in the system */
+ struct CyAsOmapDevKernel *m_next_p ;
+
+ /* This is for thread sync */
+ /* TODO: struct completion thread_complete ;*/
+
+ /* This is for thread to wait for interrupts */
+ CyAsHalSleepChannel thread_sc ;
+
+ /* This is for thread to exit upon StopOmapKernel */
+ int thread_flag ; /* set 1 to exit */
+
+} CyAsOmapDevKernel ;
+
+extern int
+CyAsHalAstoriaInit(void);
+
+#include "cyas_cplus_end.h"
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/hal/cyashalbeagleboard_spi.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,927 @@
+// Copyright (c) 1994-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:
+// omap3530/beagle_drivers/wb/cyashalbeagleboard_spi.cpp
+//
+
+#include <kern_priv.h>
+#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+#include <assp/omap3530_assp/omap3530_assp_priv.h>
+#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+#include <assp/omap3530_assp/omap3530_gpio.h>
+
+#include <assp.h> // Required for definition of TIsr
+
+#include <cyasregs.h> // Astoria register definitions
+#include <cyashalbeagleboard_spi.h>
+#include <cyashalbeagleboard.h>
+
+int gConfigured = 0 ;
+
+/***********************************************************************/
+/******************************* ISR **********************************/
+/***********************************************************************/
+
+int
+CyAsHalBeagleBoard__SetupISR(void* handler, void* ptr)
+{
+
+ //Set up the button to proivde a panic button invoking Fault()
+ if(KErrNone != GPIO::SetPinDirection(KGPIO_INT, GPIO::EInput))
+ return KErrArgument;
+
+ GPIO::SetPinMode(KGPIO_INT, GPIO::EEnabled);
+
+ if(KErrNone !=GPIO::BindInterrupt(KGPIO_INT, (TGpioIsr)handler, (TAny*)ptr))
+ return KErrArgument;
+
+ /*EEdgeFalling*/
+ if(KErrNone !=GPIO::SetInterruptTrigger(KGPIO_INT, GPIO::ELevelLow))
+ return KErrArgument;
+
+ if(KErrNone !=GPIO::EnableInterrupt(KGPIO_INT))
+ {
+ GPIO::UnbindInterrupt(KGPIO_INT);
+ return KErrInUse;
+ }
+ return 0 ;
+}
+
+static void
+ManualTriggerISRTest(void)
+{
+ GPIO::TGpioState intState = GPIO::EHigh ;
+
+ GPIO::GetInputState(KGPIO_INT, intState);
+ Kern::Printf("KGPIO_INT before INT is %d", intState);
+
+ //Set INT to LOW state
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(CY_AS_MEM_P0_VM_SET, 0x0545) ;
+ GPIO::GetInputState(KGPIO_INT, intState);
+ Kern::Printf("KGPIO_INT after INT is %d", intState);
+
+ //return INT to HIGH state
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(CY_AS_MEM_P0_VM_SET, 0x0745) ;
+ GPIO::GetInputState(KGPIO_INT, intState);
+ Kern::Printf("KGPIO_INT after INT is %d", intState);
+}
+
+TUint32 gISRCnt = 1 ;
+TDfc* gpMyDfc;
+
+static void myTestDFCFn(
+ TAny *aPtr)
+{
+
+ TUint32* gpISRCnt = (TUint32*)aPtr ;
+ Kern::Printf("myTestDFCFn called (%d)",*gpISRCnt);
+
+ *gpISRCnt += 1;
+
+ Kern::Printf("Enable interrupt");
+ GPIO::EnableInterrupt(KGPIO_INT) ;
+}
+
+static void myISR(TAny* aPtr)
+{
+ Kern::Printf("AstoriaISR");
+ gpMyDfc->Add();
+
+ Kern::Printf("Disable interrupt");
+ /* Disable Interrupt Here, it will be re-enabled by DFCs
+ GPIO::DisableInterrupt(KGPIO_INT) ;*/
+}
+
+/***********************************************************************/
+/**************************** SPI Driver *******************************/
+/***********************************************************************/
+
+extern void
+McSPI4Ch0_SetXFERLEVEL(TUint16 wcnt, TUint8 afl, TUint8 ael)
+{
+ TUint32 r = wcnt ;
+
+ r <<= 16 ;
+ r |= (afl & 0x3f) << 8 ;
+ r |= (ael & 0x3f) ;
+
+ AsspRegister::Write32(KMcSPI4_XFERLEVEL, r);
+}
+
+inline void McSPI4Ch0_Enable(void)
+{
+ /* Enable channel 0 */
+ AsspRegister::Write32(KMcSPI4_CH0CTRL, 0x1);
+}
+
+inline void McSPI4Ch0_Disable(void)
+{
+ /* Disable channel 0 */
+ AsspRegister::Write32(KMcSPI4_CH0CTRL, 0x0);
+}
+
+inline void McSPI4Ch0_TransmitMode(void)
+{
+ AsspRegister::Modify32(KMcSPI4_CH0CONF, 0x0, 0x1<<13);
+}
+
+inline void McSPI4Ch0_TransmitAndReceiveMode(void)
+{
+ AsspRegister::Modify32(KMcSPI4_CH0CONF, 0x1<<13, 0x0);
+}
+
+extern
+void McSPI4Ch0_SyncSlave(void)
+{
+ Kern::Printf("Sync With SPI slave not implemented\n");
+}
+
+inline void CheckForTxEmpty(void)
+{
+ TUint32 r ;
+ for(;;)
+ {
+ r = AsspRegister::Read32(KMcSPI4_CH0STAT);
+ if ( r & 0x2)
+ {
+ break;
+ }
+ Kern::Printf("Waiting for TX empty.");
+ }
+}
+
+inline void CheckForRxFull(void)
+{
+ TUint32 r ;
+ for(;;)
+ {
+ r = AsspRegister::Read32(KMcSPI4_CH0STAT);
+ if ( r & 0x1)
+ {
+ break;
+ }
+ Kern::Printf("Waiting for RX full.");
+ }
+}
+
+inline void CheckForTxEmptyRxFull(void)
+{
+ TUint32 r ;
+ for(;;)
+ {
+ r = AsspRegister::Read32(KMcSPI4_CH0STAT);
+ if ( r & 0x3)
+ {
+ break;
+ }
+ Kern::Printf("Waiting for TX empty and RX full.");
+ }
+}
+
+extern void
+McSPI4Ch0_DumpAstoriaRegs(int allReg)
+{
+ int i ;
+ TUint16 regVal = 0 ;
+
+ for ( i = 0x80 ; i < 0xfb ; i++ )
+ {
+ if ( (i == 0x84) ||
+ ((i >= 0x87) && (i <= 0x8f)) ||
+ (i == 0x93) ||
+ ((i >= 0x96) && (i <= 0x97)) ||
+ (i == 0x99) ||
+ ((i >= 0x9b) && (i <= 0x9f)) ||
+ ((i >= 0xb0) && (i <= 0xbf)) ||
+ ((i >= 0xc6) && (i <= 0xd8)) ||
+ ((i >= 0xe3) && (i <= 0xef)) ||
+ ((i >= 0xf4) && (i <= 0xf7)) )
+ {
+ /*skip*/
+ continue ;
+ }
+
+ regVal = 0 ;
+ if ( allReg )
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(i, ®Val) ;
+ else
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(CY_AS_MEM_CM_WB_CFG_ID, ®Val) ;
+ Kern::Printf("REG[%02x] = 0x%04x", i, regVal);
+ }
+}
+
+static int
+AstoriaRegTest(int type)
+{
+ int errCnt = 0 ;
+ int i ;
+ for ( i= 0 ; i < 100 ; i++ )
+ {
+ TUint16 regVal0 = 0, regVal1 = 0, regVal2 = 0, regVal3 = 0 ;
+ TUint16 expVal = 0 ;
+
+ if ( type == 1 )
+ {
+ Kern::Printf("Write/Read Register with sequential value...");
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf8, (i+1)) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf9, (i+2)) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfa, (i+3)) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfb, (i+4)) ;
+ }
+ else if ( type == 2 )
+ {
+ Kern::Printf("Write/Read 0xffff and 0x0 ...");
+ if ( i % 2 == 0 )
+ {
+ expVal = 0xffff ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf8, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf9, ~expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfa, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfb, ~expVal) ;
+
+ }
+ else
+ {
+ expVal = 0x0 ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf8, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf9, ~expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfa, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfb, ~expVal) ;
+ }
+ }
+ else if ( type == 3 )
+ {
+ Kern::Printf("Write/Read 0x5555 and 0xaaaa ...");
+ if ( i % 2 == 0 )
+ {
+ expVal = 0x5555 ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf8, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf9, ~expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfa, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfb, ~expVal) ;
+ }
+ else
+ {
+ expVal = 0xaaaa ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf8, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xf9, ~expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfa, expVal) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(0xfb, ~expVal) ;
+ }
+ }
+
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(0xf8, ®Val0) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(0xf9, ®Val1) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(0xfa, ®Val2) ;
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(0xfb, ®Val3) ;
+
+ if ( (type == 1) &&
+ ( (regVal0 != (i+1)) ||
+ (regVal1 != (i+2)) ||
+ (regVal2 != (i+3)) ||
+ (regVal3 != (i+4)) ))
+ {
+ Kern::Printf("ERROR: Write register failed (%d)\n",i);
+ Kern::Printf("ERROR: Exp[0]: 0x%04x\n",i+1);
+ Kern::Printf("ERROR: Act[0]: 0x%04x\n",regVal0);
+ Kern::Printf("ERROR: Exp[1]: 0x%04x\n",i+2);
+ Kern::Printf("ERROR: Act[1]: 0x%04x\n",regVal1);
+ Kern::Printf("ERROR: Exp[2]: 0x%04x\n",i+3);
+ Kern::Printf("ERROR: Act[2]: 0x%04x\n",regVal2);
+ Kern::Printf("ERROR: Exp[3]: 0x%04x\n",i+4);
+ Kern::Printf("ERROR: Act[3]: 0x%04x\n",regVal3);
+
+ errCnt++ ;
+ if ( errCnt > 10 )
+ return 1;
+ }
+ else if ( (type != 1 ) &&
+ ((regVal0 != expVal) ||
+ (regVal1 != ((~expVal)&0xffff)) ||
+ (regVal2 != expVal) ||
+ (regVal3 != ((~expVal)&0xffff)) ))
+ {
+ Kern::Printf("ERROR: Write register failed (%d)\n",i);
+ Kern::Printf("ERROR: Exp[0]: 0x%04x\n",expVal);
+ Kern::Printf("ERROR: Act[0]: 0x%04x\n",regVal0);
+ Kern::Printf("ERROR: Exp[1]: 0x%04x\n",(~expVal)&0xffff);
+ Kern::Printf("ERROR: Act[1]: 0x%04x\n",regVal1);
+ Kern::Printf("ERROR: Exp[2]: 0x%04x\n",expVal);
+ Kern::Printf("ERROR: Act[2]: 0x%04x\n",regVal2);
+ Kern::Printf("ERROR: Exp[3]: 0x%04x\n",(~expVal)&0xffff);
+ Kern::Printf("ERROR: Act[3]: 0x%04x\n",regVal3);
+
+ errCnt++ ;
+ if ( errCnt > 10 )
+ return 1 ;
+ }
+
+ }
+ Kern::Printf("Register test PASSED!!\n");
+ return 0 ;
+}
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+
+static void
+DumpMcSPI4Reg(void)
+{
+ TUint32 r ;
+ TUint32 i;
+
+ for ( i = KMcSPI4_SYSCONFIG ; i <= KMcSPI4_RX0 ; i+=0x4 )
+ {
+ r = AsspRegister::Read32(i);
+ switch (i)
+ {
+ case KMcSPI4_SYSCONFIG:
+ Kern::Printf("KMcSPI4_SYSCONFIG = (0x%08x)", r);
+ break;
+ case KMcSPI4_SYSSTATUS:
+ Kern::Printf("KMcSPI4_SYSSTATUS = (0x%08x)", r);
+ break;
+ case KMcSPI4_IRQSTATUS:
+ Kern::Printf("KMcSPI4_IRQSTATUS = (0x%08x)", r);
+ break;
+ case KMcSPI4_IRQENABLE:
+ Kern::Printf("KMcSPI4_IRQENABLE = (0x%08x)", r);
+ break;
+ case KMcSPI4_WAKEUPEN:
+ Kern::Printf("KMcSPI4_WAKEUPEN = (0x%08x)", r);
+ break;
+ case KMcSPI4_SYST:
+ Kern::Printf("KMcSPI4_SYST = (0x%08x)", r);
+ break;
+ case KMcSPI4_MODULCTRL:
+ Kern::Printf("KMcSPI4_MODULCTRL = (0x%08x)", r);
+ break;
+ case KMcSPI4_CH0CONF:
+ Kern::Printf("KMcSPI4_CH0CONF = (0x%08x)", r);
+ break;
+ case KMcSPI4_CH0STAT:
+ Kern::Printf("KMcSPI4_CH0STAT = (0x%08x)", r);
+ break;
+ case KMcSPI4_CH0CTRL:
+ Kern::Printf("KMcSPI4_CH0CTRL = (0x%08x)", r);
+ break;
+ case KMcSPI4_TX0:
+ Kern::Printf("KMcSPI4_TX0 = (0x%08x)", r);
+ break;
+ case KMcSPI4_RX0:
+ Kern::Printf("KMcSPI4_RX0 = (0x%08x)", r);
+ break;
+ case KMcSPI4_XFERLEVEL:
+ Kern::Printf("KMcSPI4_XFERLEVEL = (0x%08x)", r);
+ break;
+ default:
+ Kern::Printf("ERROR: unknow register value", r);
+ }
+ }
+
+ r = AsspRegister::Read32(KMcSPI4_XFERLEVEL);
+ Kern::Printf("KMcSPI4_XFERLEVEL = (0x%08x)\n", r);
+}
+
+inline TUint32 constructSPIConfigReg(
+ TUint8 PHA,
+ TUint8 POL,
+ TUint8 CLKD,
+ TUint8 EPOL,
+ TUint8 WL,
+ TUint8 TRM,
+ TUint8 DMAW,
+ TUint8 DMAR,
+ TUint8 DPE0,
+ TUint8 DPE1,
+ TUint8 IS,
+ TUint8 TURBO,
+ TUint8 FORCE,
+ TUint8 SPIENSLV,
+ TUint8 SBE,
+ TUint8 SBPOL,
+ TUint8 TCS,
+ TUint8 FFEW,
+ TUint8 FFER,
+ TUint8 CLKG)
+{
+ TUint32 r = 0 ;
+
+ r = ( CLKG & 0x1 ) << 29;
+ r |= ( FFER & 0x1 ) << 28;
+ r |= ( FFEW & 0x1 ) << 27;
+ r |= ( TCS & 0x3 ) << 25;
+ r |= ( SBPOL & 0x1 ) << 24;
+ r |= ( SBE & 0x1 ) << 23;
+ r |= ( SPIENSLV & 0x3 ) << 21;
+ r |= ( FORCE & 0x1 ) << 20;
+ r |= ( TURBO & 0x1 ) << 19;
+ r |= ( IS & 0x1 ) << 18;
+ r |= ( DPE1 & 0x1 ) << 17;
+ r |= ( DPE0 & 0x1 ) << 16;
+ r |= ( DMAR & 0x1 ) << 15;
+ r |= ( DMAW & 0x1 ) << 14;
+ r |= ( TRM & 0x3 ) << 12;
+ r |= ( WL & 0x1f ) << 7;
+ r |= ( EPOL & 0x1 ) << 6;
+ r |= ( CLKD & 0xf ) << 2;
+ r |= ( POL & 0x1 ) << 1;
+ r |= PHA & 0x1;
+ return r ;
+}
+
+static void ConfigMcSPI4Ch0(void)
+{
+ TUint32 r ;
+ Kern::Printf("Configure McSPI4 CH0...\n");
+
+ /* Enable McSPI4 functional clock */
+ r = AsspRegister::Read32(KCM_FCLKEN1_CORE);
+ AsspRegister::Write32(KCM_FCLKEN1_CORE, (r | 0x200000));
+
+ /* Enable McSPI4 interface clock */
+ r = AsspRegister::Read32(KCM_ICLKEN1_CORE);
+ AsspRegister::Write32(KCM_ICLKEN1_CORE, (r | 0x200000));
+
+ /* Software reset McSPI4 */
+ AsspRegister::Write32(KMcSPI4_SYSCONFIG, 0x1);
+
+ /* Wait until RESETDONE is set in SYSSTATUS */
+ do
+ {
+ r = AsspRegister::Read32(KMcSPI4_SYSSTATUS);
+ Kern::Printf("KMcSPI4_SYSSTATUS = (0x%08x)\n", r);
+ }while((r & 0x1) != 1);
+
+ /* Disable channel 0 */
+ McSPI4Ch0_Disable();
+
+ /* Disable all interrupts */
+ AsspRegister::Write32(KMcSPI4_IRQENABLE, 0x0);
+
+ /* Clear all interrupts */
+ AsspRegister::Write32(KMcSPI4_IRQSTATUS, 0x1777f);
+
+ /* Set Master mode */
+#ifdef SINGLE_CHANNEL_MASTER_MODE
+ AsspRegister::Write32(KMcSPI4_MODULCTRL, 0x1);
+#else
+ AsspRegister::Write32(KMcSPI4_MODULCTRL, 0x0);
+#endif
+
+
+ /* Config clock, wl */
+ r = constructSPIConfigReg(
+ 0x0, /*PHA*/
+ 0x0, /*POL*/
+ 0x2, /*CLKD (divider 2 = 12MHz)3 = 6MHz*/
+ 0x1, /*EPOL (active low)*/
+ 0x7, /*WL (8bit)*/
+ 0x0, /*TRM (Transmit and receive mode)*/
+ 0x0, /*DMAW (DMAW disable) TODO*/
+ 0x0, /*DMAR (DMAR disable) TODO*/
+ 0x1, /*DPE0 (spim_somi no transmission)*/
+ 0x0, /*DPE1 (spim_simo transmission)*/
+ 0x0, /*IS (spim_somi reception)*/
+ 0x0, /*TURBO (mutli spi-word transfer)*/
+ 0x0, /*FORCE TODO*/
+ 0x0, /*SPIENSLV (not used)*/
+ 0x0, /*SBE (no start bit) TODO*/
+ 0x0, /*SBPOL (start bit polarity) */
+ 0x0, /*TCS (cs time control) TODO*/
+ 0x0, /*FFEW (FIFO enabled) TODO*/
+ 0x0, /*FFER (FIFO enabled) TODO*/
+ 0x0 /*CLKG (One clock cycle granularity)*/
+ );
+
+ AsspRegister::Write32(KMcSPI4_CH0CONF, r);
+
+}
+
+static void
+SetPADConfigRegister(void)
+{
+ TUint32 r ;
+ Kern::Printf("Set PAD configuration registers...\n");
+
+ /* MUXMODE = 1, INPUTENABLE for SOMI */
+ AsspRegister::Write32(KPADCONFIG_McSPI4_SIMO_P12_0, 0x1010001);
+
+ r = AsspRegister::Read32(KPADCONFIG_McSPI4_CS0_P16_16);
+ AsspRegister::Write32(KPADCONFIG_McSPI4_CS0_P16_16, ((r & 0xffff) | 0x10000));
+
+ /* NOTE:
+ we must set SPI clock INPUTENABLE bit otherwise the RX register will not
+ latch any data */
+ AsspRegister::Write32(KPADCONFIG_McSPI4_CLK_P20_0, 0x40001 | 0x0100);
+
+ /* MUXMODE = 4 */
+ r = AsspRegister::Read32(KPADCONFIG_GPIO183_P23_0);
+ //AsspRegister::Write32(KPADCONFIG_GPIO183_P23_0, ((r & 0xffff0000) | 0x4 | 0x8 | 0x0100));
+ AsspRegister::Write32(KPADCONFIG_GPIO183_P23_0, ((r & 0xffff0000) | 0x4 ));
+
+ r = AsspRegister::Read32(KPADCONFIG_GPIO168_P24_16);
+ AsspRegister::Write32(KPADCONFIG_GPIO168_P24_16, ((r & 0xffff) | 0x40000 | 0x01000000));
+
+}
+
+static void
+ReadPADConfigRegister(void)
+{
+ TUint32 r ;
+
+ Kern::Printf("Reading PAD configuration registers...");
+ r = AsspRegister::Read32(KPADCONFIG_McSPI4_SIMO_P12_0);
+ Kern::Printf("KPADCONFIG_McSPI4_SIMO_P12_0 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_McSPI4_SIMO_P18_16);
+ Kern::Printf("KPADCONFIG_McSPI4_SIMO_P18_16 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_McSPI4_CS0_P16_16);
+ Kern::Printf("KPADCONFIG_McSPI4_CS0_P16_16 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_McSPI4_CLK_P20_0);
+ Kern::Printf("KPADCONFIG_McSPI4_CLK_P20_0 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_GPIO157_P22_16);
+ Kern::Printf("KPADCONFIG_GPIO157_P22_16 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_GPIO183_P23_0);
+ Kern::Printf("KPADCONFIG_GPIO183_P23_0 = (0x%08x)", r);
+
+ r = AsspRegister::Read32(KPADCONFIG_GPIO168_P24_16);
+ Kern::Printf("KPADCONFIG_GPIO168_P24_16 = (0x%08x)", r);
+
+}
+
+/***********************************************************************/
+/**************************** Public *******************************/
+/***********************************************************************/
+
+void
+CyAsHalBeagleBoardMcSPI4Ch0_WriteEP(TUint32 addr, TUint8* buff, TUint16 size)
+{
+ TUint8 size_l = size ;
+ TUint8 size_h = (size >> 8)&0x7f ;
+ TUint16 size16 = size / 2 ;
+ TUint8* p = buff ;
+
+ TUint32 r ;
+
+ r = 0x00800000;
+ r |= (addr & 0xff) << 8 ;
+ r |= size_l << 24 ;
+ r |= size_h << 16 ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("WB SPI write packet header = (0x%08x)", r);
+#endif
+ /* Set McSPI4Ch0 to Transmit only mode for write */
+ McSPI4Ch0_TransmitMode();
+
+ McSPI4Ch0_Enable();
+
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>8);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>16);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>24);
+
+ while(size16 != 0)
+ {
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, *(p+1));
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, *p);
+
+/*#ifdef SPI_DEBUG_LOG
+ Kern::Printf("0x%02x", *(p+1));
+ Kern::Printf("0x%02x", *p);
+#endif*/
+ p+=2 ;
+ size16-- ;
+ }
+
+ CheckForTxEmpty();
+
+ McSPI4Ch0_Disable();
+
+ /*
+ * Change back to Transmit and Receive mode for RegRead
+ */
+ McSPI4Ch0_TransmitAndReceiveMode();
+
+}
+
+void
+CyAsHalBeagleBoardMcSPI4Ch0_ReadEP(TUint32 addr, TUint8* buff, TUint16 size)
+{
+ TUint8 size_l = size ;
+ TUint8 size_h = (size >> 8)&0x7f ;
+ TUint16 size16 = size / 2 ;
+ TUint32 r ;
+
+ r = 0x00000000;
+ r |= (addr & 0xff) << 8 ;
+ r |= size_l << 24 ;
+ r |= size_h << 16 ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("WB SPI read packet header = (0x%08x)", r);
+#endif
+
+ McSPI4Ch0_Enable();
+
+ {
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>8);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>16);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>24);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ while(size16 != 0)
+ {
+ AsspRegister::Write32(KMcSPI4_TX0, 0);
+ CheckForTxEmptyRxFull();
+ *(buff+1) = AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, 0);
+ CheckForTxEmptyRxFull();
+ *buff = AsspRegister::Read32(KMcSPI4_RX0);
+
+ buff+=2;
+ size16--;
+
+ }
+
+ }
+
+ McSPI4Ch0_Disable();
+
+}
+
+void
+CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(TUint32 addr, TUint16 value)
+{
+ TUint32 r ;
+
+ r = 0x02800000;
+ r |= (addr & 0xff) << 8 ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("WB SPI write packet header = (0x%08x), value = (0x%04x)", r, value);
+#endif
+
+ /* Set McSPI4Ch0 to Transmit only mode for write */
+ McSPI4Ch0_TransmitMode();
+
+ McSPI4Ch0_Enable();
+
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>8);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>16);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r>>24);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, value>>8);
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, value & 0xff );
+ CheckForTxEmpty();
+
+ McSPI4Ch0_Disable();
+
+ /*
+ * Change back to Transmit and Receive mode for RegRead
+ */
+ McSPI4Ch0_TransmitAndReceiveMode();
+}
+
+void
+CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(TUint32 addr, TUint16* value)
+{
+ TUint32 r ;
+
+ r = 0x02000000;
+ r |= (addr & 0xff) << 8 ;
+#ifdef SPI_DEBUG_LOG
+ Kern::Printf("WB SPI read packet header = (0x%08x)", r);
+#endif
+
+ McSPI4Ch0_Enable();
+
+ {
+ TUint16 v ;
+
+ CheckForTxEmpty();
+ AsspRegister::Write32(KMcSPI4_TX0, r);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>8);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>16);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, r>>24);
+ CheckForTxEmptyRxFull();
+ AsspRegister::Read32(KMcSPI4_RX0);
+
+ AsspRegister::Write32(KMcSPI4_TX0, 0);
+ CheckForTxEmptyRxFull();
+ v = AsspRegister::Read32(KMcSPI4_RX0);
+ *value = v << 8;
+
+ AsspRegister::Write32(KMcSPI4_TX0, 0);
+ CheckForTxEmptyRxFull();
+ v = AsspRegister::Read32(KMcSPI4_RX0);
+ *value |= v & 0xff;
+
+ }
+
+ McSPI4Ch0_Disable();
+
+}
+
+int
+CyAsHalBeagleBoard__ConfigureSPI(void)
+{
+ /*Configure PAD*/
+ ReadPADConfigRegister();
+ SetPADConfigRegister();
+ ReadPADConfigRegister();
+
+ /*Configure McSPI4*/
+ ConfigMcSPI4Ch0();
+ DumpMcSPI4Reg();
+
+ McSPI4Ch0_Enable();
+
+ if(KErrNone != GPIO::SetPinMode(KGPIO_183, GPIO::EEnabled))
+ Kern::Printf("ERROR: SetPinMode failed!");
+
+ if(KErrNone != GPIO::SetPinDirection(KGPIO_183, GPIO::EOutput))
+ Kern::Printf("ERROR: SetPinDirection failed!");
+
+ if(KErrNone != GPIO::SetOutputState(KGPIO_183, GPIO::EHigh))
+ Kern::Printf("ERROR: SetOutputState failed!");
+
+ gConfigured = 1 ;
+ return 0 ;
+}
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+
+extern int
+CyAsHalBeagleBoard__Test(void)
+{
+ int i ;
+ int errCnt = 0 ;
+
+ if ( !gConfigured )
+ {
+ CyAsHalBeagleBoard__ConfigureSPI();
+ }
+
+ {
+ TUint16 regVal = 0 ;
+
+ Kern::Printf("Read Astoria ID register\n");
+
+ CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(0x80, ®Val) ;
+
+ if ( regVal != 0xA200 )
+ {
+ Kern::Printf("ERROR: Wrong ID register value\n");
+ Kern::Printf("ERROR: Exp: 0x%04x\n",0xa200);
+ Kern::Printf("ERROR: Act: 0x%04x\n",regVal);
+ errCnt++;
+ return errCnt ;
+ }
+ else
+ {
+ Kern::Printf("ID register read successful 0x%04x\n",regVal);
+ }
+ }
+
+ {
+ Kern::Printf("Register test...\n");
+ for ( i = 1 ; i < 4 ; i++ )
+ {
+ if ( AstoriaRegTest(i) != 0 )
+ {
+ errCnt++ ;
+ return errCnt ;
+ }
+ }
+
+ }
+
+ {
+
+ Kern::Printf("Interrupt test...\n");
+
+ /* Setup DFC */
+ gpMyDfc = new TDfc( myTestDFCFn, (void*)(&gISRCnt), Kern::DfcQue0(), 1 ) ;
+ CyAsHalBeagleBoard__SetupISR((void*)myISR,(void*)(0));
+
+ for ( i = 0 ; i < 5 ; i++ )
+ {
+ Kern::Printf("Manually trigger interrupt (%d)\n",i);
+
+ ManualTriggerISRTest();
+
+
+ if (gISRCnt != i+1)
+ {
+ Kern::Printf("ISR called (%d)\n",gISRCnt);
+ }
+ else
+ {
+ Kern::Printf("ISR didn't call (%d)\n",gISRCnt);
+ Kern::Printf("Interrupt test failed\n");
+ errCnt++ ;
+ return errCnt ;
+ }
+ }
+ }
+
+ Kern::Printf("CyAsHalBeagleBoard__Test Successful!\n");
+
+ /*if ( gIndex == 1 )
+ {
+ GPIO::TGpioState aState ;
+
+ GPIO::GetOutputState(KGPIO_183, aState);
+
+ if ( aState == GPIO::EHigh )
+ {
+ if(KErrNone != GPIO::SetOutputState(KGPIO_183, GPIO::ELow))
+ Kern::Printf("ERROR: SetOutputState failed!");
+ }
+ else
+ {
+ if(KErrNone != GPIO::SetOutputState(KGPIO_183, GPIO::EHigh))
+ Kern::Printf("ERROR: SetOutputState failed!");
+ }
+ gIndex = 0 ;
+ }*/
+
+ /*
+ if ( gIndex == 2 )
+ {
+ McSPI4Ch0_DumpAstoriaRegs(0);
+ }
+
+ if ( gIndex == 3 )
+ {
+ McSPI4Ch0_DumpAstoriaRegs(1);
+ gIndex = 0 ;
+ }
+ */
+ return 0 ;
+}
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+
+
+
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/hal/cyashalbeagleboard_spi.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,67 @@
+#ifndef _CYASHALBEAGLEBOARD_SPI_H_
+#define _CYASHALBEAGLEBOARD_SPI_H_
+
+#include <kern_priv.h>
+#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+#include <assp/omap3530_assp/omap3530_assp_priv.h>
+#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+#include <assp/omap3530_assp/omap3530_gpio.h>
+
+#include <assp.h> // Required for definition of TIsr
+
+const TUint KGPIO_183 = 183;
+const TUint KGPIO_INT = 168;
+
+//#define SINGLE_CHANNEL_MASTER_MODE
+
+/* PRCM registers */
+const TUint KCM_FCLKEN1_CORE = Omap3530HwBase::TVirtual<0x48004A00>::Value;
+const TUint KCM_ICLKEN1_CORE = Omap3530HwBase::TVirtual<0x48004A10>::Value;
+
+const TUint32 KCONTROL_SEC_CTRL = Omap3530HwBase::TVirtual<0x480022B0>::Value;
+
+/* Pad configuration registers */
+const TUint32 KPADCONFIG_McSPI4_SIMO_P12_0 = Omap3530HwBase::TVirtual<0x48002190>::Value;
+const TUint32 KPADCONFIG_McSPI4_SIMO_P18_16 = Omap3530HwBase::TVirtual<0x48002190>::Value;
+const TUint32 KPADCONFIG_McSPI4_CS0_P16_16 = Omap3530HwBase::TVirtual<0x48002194>::Value;
+const TUint32 KPADCONFIG_McSPI4_CLK_P20_0 = Omap3530HwBase::TVirtual<0x4800218c>::Value;
+const TUint32 KPADCONFIG_GPIO157_P22_16 = Omap3530HwBase::TVirtual<0x4800218c>::Value;
+const TUint32 KPADCONFIG_GPIO183_P23_0 = Omap3530HwBase::TVirtual<0x480021c0>::Value;
+const TUint32 KPADCONFIG_GPIO168_P24_16 = Omap3530HwBase::TVirtual<0x480021bc>::Value;
+
+/* SPI configuration registers */
+const TUint32 KMcSPI4_SYSCONFIG = Omap3530HwBase::TVirtual<0x480BA010>::Value;
+const TUint32 KMcSPI4_SYSSTATUS = Omap3530HwBase::TVirtual<0x480BA014>::Value;
+const TUint32 KMcSPI4_IRQSTATUS = Omap3530HwBase::TVirtual<0x480BA018>::Value;
+const TUint32 KMcSPI4_IRQENABLE = Omap3530HwBase::TVirtual<0x480BA01c>::Value;
+const TUint32 KMcSPI4_WAKEUPEN = Omap3530HwBase::TVirtual<0x480BA020>::Value;
+const TUint32 KMcSPI4_SYST = Omap3530HwBase::TVirtual<0x480BA024>::Value;
+const TUint32 KMcSPI4_MODULCTRL = Omap3530HwBase::TVirtual<0x480BA028>::Value;
+const TUint32 KMcSPI4_CH0CONF = Omap3530HwBase::TVirtual<0x480BA02c>::Value;
+const TUint32 KMcSPI4_CH0STAT = Omap3530HwBase::TVirtual<0x480BA030>::Value;
+const TUint32 KMcSPI4_CH0CTRL = Omap3530HwBase::TVirtual<0x480BA034>::Value;
+const TUint32 KMcSPI4_TX0 = Omap3530HwBase::TVirtual<0x480BA038>::Value;
+const TUint32 KMcSPI4_RX0 = Omap3530HwBase::TVirtual<0x480BA03c>::Value;
+const TUint32 KMcSPI4_XFERLEVEL = Omap3530HwBase::TVirtual<0x480BA07c>::Value;
+/**/
+
+extern int
+CyAsHalBeagleBoard__ConfigureSPI(void);
+
+extern int
+CyAsHalBeagleBoard__SetupISR(void* handler, void* ptr);
+
+extern void
+CyAsHalBeagleBoardMcSPI4Ch0_ReadReg(TUint32 addr, TUint16* value);
+
+extern void
+CyAsHalBeagleBoardMcSPI4Ch0_WriteReg(TUint32 addr, TUint16 value);
+
+extern void
+CyAsHalBeagleBoardMcSPI4Ch0_ReadEP(TUint32 addr, TUint8* buff, TUint16 size);
+
+extern void
+CyAsHalBeagleBoardMcSPI4Ch0_WriteEP(TUint32 addr, TUint8* buff, TUint16 size);
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanch9.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,27 @@
+/* Cypress West Bridge API header file (cyanch9.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANCH9_H_
+#define _INCLUDED_CYANCH9_H_
+
+#include <cyasch9.h>
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanerr.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,404 @@
+/* Cypress West Bridge API header file (cyanerr.h)
+ ## Symbols for backward compatibility with previous releases of Antioch SDK.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANERR_H_
+#define _INCLUDED_CYANERR_H_
+
+#include "cyaserr.h"
+
+#ifndef __doxygen__
+
+/*
+ * Function completed successfully.
+ */
+#define CY_AN_ERROR_SUCCESS (CY_AS_ERROR_SUCCESS)
+
+/*
+ * A function trying to acquire a resource was unable to do so.
+ */
+#define CY_AN_ERROR_NOT_ACQUIRED (CY_AS_ERROR_NOT_ACQUIRED)
+
+/*
+ * A function trying to acquire a resource was unable to do so.
+ */
+#define CY_AN_ERROR_NOT_RELEASED (CY_AS_ERROR_NOT_RELEASED)
+
+/*
+ * The West Bridge firmware is not loaded.
+ */
+#define CY_AN_ERROR_NO_FIRMWARE (CY_AS_ERROR_NO_FIRMWARE)
+
+/*
+ * A timeout occurred waiting on a response from the West Bridge device
+ */
+#define CY_AN_ERROR_TIMEOUT (CY_AS_ERROR_TIMEOUT)
+
+/*
+ * A request to download firmware was made while not in the CONFIG mode
+ */
+#define CY_AN_ERROR_NOT_IN_CONFIG_MODE (CY_AS_ERROR_NOT_IN_CONFIG_MODE)
+
+/*
+ * This error is returned if the firmware size specified is too invalid.
+ */
+#define CY_AN_ERROR_INVALID_SIZE (CY_AS_ERROR_INVALID_SIZE)
+
+/*
+ * This error is returned if a request is made to acquire a resource that has
+ * already been acquired.
+ */
+#define CY_AN_ERROR_RESOURCE_ALREADY_OWNED (CY_AS_ERROR_RESOURCE_ALREADY_OWNED)
+
+/*
+ * This error is returned if a request is made to release a resource that has
+ * not previously been acquired.
+ */
+#define CY_AN_ERROR_RESOURCE_NOT_OWNED (CY_AS_ERROR_RESOURCE_NOT_OWNED)
+
+/*
+ * This error is returned when a request is made for a media that does not exist
+ */
+#define CY_AN_ERROR_NO_SUCH_MEDIA (CY_AS_ERROR_NO_SUCH_MEDIA)
+
+/*
+ * This error is returned when a request is made for a device that does not exist
+ */
+#define CY_AN_ERROR_NO_SUCH_DEVICE (CY_AS_ERROR_NO_SUCH_DEVICE)
+
+/*
+ * This error is returned when a request is made for a unit that does not exist
+ */
+#define CY_AN_ERROR_NO_SUCH_UNIT (CY_AS_ERROR_NO_SUCH_UNIT)
+
+/*
+ * This error is returned when a request is made for a block that does not exist
+ */
+#define CY_AN_ERROR_INVALID_BLOCK (CY_AS_ERROR_INVALID_BLOCK)
+
+/*
+ * This error is returned when an invalid trace level is set.
+ */
+#define CY_AN_ERROR_INVALID_TRACE_LEVEL (CY_AS_ERROR_INVALID_TRACE_LEVEL)
+
+/*
+ * This error is returned when West Bridge is already in the standby state
+ * and an attempt is made to put West Bridge into this state again.
+ */
+#define CY_AN_ERROR_ALREADY_STANDBY (CY_AS_ERROR_ALREADY_STANDBY)
+
+/*
+ * This error is returned when the API needs to set a pin on the
+ * West Bridge device, but this is not supported by the underlying HAL
+ * layer.
+ */
+#define CY_AN_ERROR_SETTING_WAKEUP_PIN (CY_AS_ERROR_SETTING_WAKEUP_PIN)
+
+/*
+ * This error is returned when a module is being started that has
+ * already been started.
+ */
+#define CY_AN_ERROR_ALREADY_RUNNING (CY_AS_ERROR_ALREADY_RUNNING)
+
+/*
+ * This error is returned when a module is being stopped that has
+ * already been stopped.
+ */
+#define CY_AN_ERROR_NOT_RUNNING (CY_AS_ERROR_NOT_RUNNING)
+
+/*
+ * This error is returned when the caller tries to claim a media that has already been
+ * claimed.
+ */
+#define CY_AN_ERROR_MEDIA_ALREADY_CLAIMED (CY_AS_ERROR_MEDIA_ALREADY_CLAIMED)
+
+/*
+ * This error is returned when the caller tries to release a media that has already been
+ * released.
+ */
+#define CY_AN_ERROR_MEDIA_NOT_CLAIMED (CY_AS_ERROR_MEDIA_NOT_CLAIMED)
+
+/*
+ * This error is returned when canceling trying to cancel an asynchronous operation when
+ * an async operation is not pending.
+ */
+#define CY_AN_ERROR_NO_OPERATION_PENDING (CY_AS_ERROR_NO_OPERATION_PENDING)
+
+/*
+ * This error is returned when an invalid endpoint number is provided to an API call.
+ */
+#define CY_AN_ERROR_INVALID_ENDPOINT (CY_AS_ERROR_INVALID_ENDPOINT)
+
+/*
+ * This error is returned when an invalid descriptor type
+ * is specified in an API call.
+ */
+#define CY_AN_ERROR_INVALID_DESCRIPTOR (CY_AS_ERROR_INVALID_DESCRIPTOR)
+
+/*
+ * This error is returned when an invalid descriptor index
+ * is specified in an API call.
+ */
+#define CY_AN_ERROR_BAD_INDEX (CY_AS_ERROR_BAD_INDEX)
+
+/*
+ * This error is returned if trying to set a USB descriptor
+ * when in the P port enumeration mode.
+ */
+#define CY_AN_ERROR_BAD_ENUMERATION_MODE (CY_AS_ERROR_BAD_ENUMERATION_MODE)
+
+/*
+ * This error is returned when the endpoint configuration specified
+ * is not valid.
+ */
+#define CY_AN_ERROR_INVALID_CONFIGURATION (CY_AS_ERROR_INVALID_CONFIGURATION)
+
+/*
+ * This error is returned when the API cannot verify it is connected
+ * to an West Bridge device.
+ */
+#define CY_AN_ERROR_NO_ANTIOCH (CY_AS_ERROR_NO_ANTIOCH)
+
+/*
+ * This error is returned when an API function is called and CyAnMiscConfigureDevice
+ * has not been called to configure West Bridge for the current environment.
+ */
+#define CY_AN_ERROR_NOT_CONFIGURED (CY_AS_ERROR_NOT_CONFIGURED)
+
+/*
+ * This error is returned when West Bridge cannot allocate memory required for
+ * internal API operations.
+ */
+#define CY_AN_ERROR_OUT_OF_MEMORY (CY_AS_ERROR_OUT_OF_MEMORY)
+
+/*
+ * This error is returned when a module is being started that has
+ * already been started.
+ */
+#define CY_AN_ERROR_NESTED_SLEEP (CY_AS_ERROR_NESTED_SLEEP)
+
+/*
+ * This error is returned when an operation is attempted on an endpoint that has
+ * been disabled.
+ */
+#define CY_AN_ERROR_ENDPOINT_DISABLED (CY_AS_ERROR_ENDPOINT_DISABLED)
+
+/*
+ * This error is returned when a call is made to an API function when the device is in
+ * standby.
+ */
+#define CY_AN_ERROR_IN_STANDBY (CY_AS_ERROR_IN_STANDBY)
+
+/*
+ * This error is returned when an API call is made with an invalid handle value.
+ */
+#define CY_AN_ERROR_INVALID_HANDLE (CY_AS_ERROR_INVALID_HANDLE)
+
+/*
+ * This error is returned when an invalid response is returned from the West Bridge device.
+ */
+#define CY_AN_ERROR_INVALID_RESPONSE (CY_AS_ERROR_INVALID_RESPONSE)
+
+/*
+ * This error is returned from the callback function for any asynchronous read or write
+ * request that is canceled.
+ */
+#define CY_AN_ERROR_CANCELED (CY_AS_ERROR_CANCELED)
+
+/*
+ * This error is returned when the call to create sleep channel fails
+ * in the HAL layer.
+ */
+#define CY_AN_ERROR_CREATE_SLEEP_CHANNEL_FAILED (CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED)
+
+/*
+ * This error is returned when the call to CyAnMiscLeaveStandby
+ * is made and the device is not in standby.
+ */
+#define CY_AN_ERROR_NOT_IN_STANDBY (CY_AS_ERROR_NOT_IN_STANDBY)
+
+/*
+ * This error is returned when the call to destroy sleep channel fails
+ * in the HAL layer.
+ */
+#define CY_AN_ERROR_DESTROY_SLEEP_CHANNEL_FAILED (CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED)
+
+/*
+ * This error is returned when an invalid resource is specified to a call
+ * to CyAnMiscAcquireResource() or CyAnMiscReleaseResource()
+ */
+#define CY_AN_ERROR_INVALID_RESOURCE (CY_AS_ERROR_INVALID_RESOURCE)
+
+/*
+ * This error occurs when an operation is requested on an endpoint that has
+ * a currently pending async operation.
+ */
+#define CY_AN_ERROR_ASYNC_PENDING (CY_AS_ERROR_ASYNC_PENDING)
+
+/*
+ * This error is returned when a call to CyAnStorageCancelAsync() or
+ * CyAnUsbCancelAsync() is made when no asynchronous request is pending.
+ */
+#define CY_AN_ERROR_ASYNC_NOT_PENDING (CY_AS_ERROR_ASYNC_NOT_PENDING)
+
+/*
+ * This error is returned when a request is made to put the West Bridge device
+ * into standby mode while the USB stack is still active.
+ */
+#define CY_AN_ERROR_USB_RUNNING (CY_AS_ERROR_USB_RUNNING)
+
+/*
+ * A request for in the wrong direction was issued on an endpoint.
+ */
+#define CY_AN_ERROR_USB_BAD_DIRECTION (CY_AS_ERROR_USB_BAD_DIRECTION)
+
+/*
+ * An invalid request was received
+ */
+#define CY_AN_ERROR_INVALID_REQUEST (CY_AS_ERROR_INVALID_REQUEST)
+
+/*
+ * An ACK request was requested while no setup packet was pending.
+ */
+#define CY_AN_ERROR_NO_SETUP_PACKET_PENDING (CY_AS_ERROR_NO_SETUP_PACKET_PENDING)
+
+/*
+ * A call was made to a API function that cannot be called from a callback.
+ */
+#define CY_AN_ERROR_INVALID_IN_CALLBACK (CY_AS_ERROR_INVALID_IN_CALLBACK)
+
+/*
+ * A call was made to CyAnUsbSetEndPointConfig() before CyAnUsbSetPhysicalConfiguration()
+ * was called.
+ */
+#define CY_AN_ERROR_ENDPOINT_CONFIG_NOT_SET (CY_AS_ERROR_ENDPOINT_CONFIG_NOT_SET)
+
+/*
+ * The physical endpoint referenced is not valid in the current physical configuration
+ */
+#define CY_AN_ERROR_INVALID_PHYSICAL_ENDPOINT (CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT)
+
+/*
+ * The data supplied to the CyAnMiscDownloadFirmware() call is not aligned on a
+ * WORD (16 bit) boundary.
+ */
+#define CY_AN_ERROR_ALIGNMENT_ERROR (CY_AS_ERROR_ALIGNMENT_ERROR)
+
+/*
+ * A call was made to destroy the West Bridge device, but the USB stack or the storage
+ * stack was will running.
+ */
+#define CY_AN_ERROR_STILL_RUNNING (CY_AS_ERROR_STILL_RUNNING)
+
+/*
+ * A call was made to the API for a function that is not yet supported.
+ */
+#define CY_AN_ERROR_NOT_YET_SUPPORTED (CY_AS_ERROR_NOT_YET_SUPPORTED)
+
+/*
+ * A NULL callback was provided where a non-NULL callback was required
+ */
+#define CY_AN_ERROR_NULL_CALLBACK (CY_AS_ERROR_NULL_CALLBACK)
+
+/*
+ * This error is returned when a request is made to put the West Bridge device
+ * into standby mode while the storage stack is still active.
+ */
+#define CY_AN_ERROR_STORAGE_RUNNING (CY_AS_ERROR_STORAGE_RUNNING)
+
+/*
+ * This error is returned when an operation is attempted that cannot be completed while
+ * the USB stack is connected to a USB host.
+ */
+#define CY_AN_ERROR_USB_CONNECTED (CY_AS_ERROR_USB_CONNECTED)
+
+/*
+ * This error is returned when a USB disconnect is attempted and the West Bridge device is
+ * not connected.
+ */
+#define CY_AN_ERROR_USB_NOT_CONNECTED (CY_AS_ERROR_USB_NOT_CONNECTED)
+
+/*
+ * This error is returned when an P2S storage operation attempted and data could not be
+ * read or written to the storage media.
+ */
+#define CY_AN_ERROR_MEDIA_ACCESS_FAILURE (CY_AS_ERROR_MEDIA_ACCESS_FAILURE)
+
+/*
+ * This error is returned when an P2S storage operation attempted and the media is write
+ * protected.
+ */
+#define CY_AN_ERROR_MEDIA_WRITE_PROTECTED (CY_AS_ERROR_MEDIA_WRITE_PROTECTED)
+
+/*
+ * This error is returned when an attempt is made to cancel a request that has
+ * already been sent to the West Bridge.
+ */
+#define CY_AN_ERROR_OPERATION_IN_TRANSIT (CY_AS_ERROR_OPERATION_IN_TRANSIT)
+
+/*
+ * This error is returned when an invalid parameter is passed to one of the APIs.
+ */
+#define CY_AN_ERROR_INVALID_PARAMETER (CY_AS_ERROR_INVALID_PARAMETER)
+
+/*
+ * This error is returned if an API is not supported by the current West Bridge device
+ * or the active firmware version.
+ */
+#define CY_AN_ERROR_NOT_SUPPORTED (CY_AS_ERROR_NOT_SUPPORTED)
+
+/*
+ * This error is returned when a call is made to one of the Storage or
+ * USB APIs while the device is in suspend mode.
+ */
+#define CY_AN_ERROR_IN_SUSPEND (CY_AS_ERROR_IN_SUSPEND)
+
+/*
+ * This error is returned when the call to CyAnMiscLeaveSuspend
+ * is made and the device is not in suspend mode.
+ */
+#define CY_AN_ERROR_NOT_IN_SUSPEND (CY_AS_ERROR_NOT_IN_SUSPEND)
+
+/*
+ * This error is returned when a command that is disabled by USB is called.
+ */
+#define CY_AN_ERROR_FEATURE_NOT_ENABLED (CY_AS_ERROR_FEATURE_NOT_ENABLED)
+
+/*
+ * This error is returned when an Async storage read or write is called before a
+ * query device call is issued.
+ */
+#define CY_AN_ERROR_QUERY_DEVICE_NEEDED (CY_AS_ERROR_QUERY_DEVICE_NEEDED)
+
+/*
+ * This error is returned when a call is made to USB or STORAGE Start or Stop before
+ * a prior Start or Stop has finished.
+ */
+#define CY_AN_ERROR_STARTSTOP_PENDING (CY_AS_ERROR_STARTSTOP_PENDING)
+
+/*
+ * This error is returned when a request is made for a bus that does not exist
+ */
+#define CY_AN_ERROR_NO_SUCH_BUS (CY_AS_ERROR_NO_SUCH_BUS)
+
+#endif /* __doxygen__ */
+
+#endif /* _INCLUDED_CYANERR_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanmedia.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,48 @@
+/* Cypress West Bridge API header file (cyanmedia.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANMEDIA_H_
+#define _INCLUDED_CYANMEDIA_H_
+
+#include "cyas_cplus_start.h"
+
+/* Summary
+ Specifies a specific type of media supported by West Bridge
+
+ Description
+ The West Bridge device supports five specific types of media as storage/IO devices
+ attached to it's S-Port. This type is used to indicate the type of
+ media being referenced in any API call.
+*/
+#include "cyasmedia.h"
+#define CyAnMediaNand CyAsMediaNand /* Flash NAND memory (may be SLC or MLC) */
+#define CyAnMediaSDFlash CyAsMediaSDFlash /* An SD flash memory device */
+#define CyAnMediaMMCFlash CyAsMediaMMCFlash /* An MMC flash memory device */
+#define CyAnMediaCEATA CyAsMediaCEATA /* A CE-ATA disk drive */
+#define CyAnMediaSDIO CyAsMediaSDIO /* SDIO device. */
+#define CyAnMediaMaxMediaValue CyAsMediaMaxMediaValue
+
+typedef CyAsMediaType CyAnMediaType;
+
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYANMEDIA_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanmisc.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,538 @@
+/* Cypress West Bridge API header file (cyanmisc.h)
+ ## Version for backward compatibility with previous Antioch SDK releases.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANMISC_H_
+#define _INCLUDED_CYANMISC_H_
+
+#include "cyantypes.h"
+#include <cyasmisc.h>
+#include "cyanmedia.h"
+#include "cyas_cplus_start.h"
+
+#define CY_AN_LEAVE_STANDBY_DELAY_CLOCK (CY_AS_LEAVE_STANDBY_DELAY_CLOCK)
+#define CY_AN_RESET_DELAY_CLOCK (CY_AS_RESET_DELAY_CLOCK)
+
+#define CY_AN_LEAVE_STANDBY_DELAY_CRYSTAL (CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL)
+#define CY_AN_RESET_DELAY_CRYSTAL (CY_AS_RESET_DELAY_CRYSTAL)
+
+/* Defines to convert the old CyAn names to the new
+ * CyAs names
+ */
+typedef CyAsDeviceHandle CyAnDeviceHandle;
+
+#define CyAnDeviceDackAck CyAsDeviceDackAck
+#define CyAnDeviceDackEob CyAsDeviceDackEob
+typedef CyAsDeviceDackMode CyAnDeviceDackMode;
+
+typedef CyAsDeviceConfig CyAnDeviceConfig;
+
+#define CyAnResourceUSB CyAsBusUSB
+#define CyAnResourceSDIO_MMC CyAsBus_1
+#define CyAnResourceNand CyAsBus_0
+typedef CyAsResourceType CyAnResourceType;
+
+#define CyAnResetSoft CyAsResetSoft
+#define CyAnResetHard CyAsResetHard
+typedef CyAsResetType CyAnResetType;
+typedef CyAsFunctCBType CyAnFunctCBType;
+typedef CyAsFunctionCallback CyAnFunctionCallback;
+
+#define CyAnEventMiscInitialized CyAsEventMiscInitialized
+#define CyAnEventMiscAwake CyAsEventMiscAwake
+#define CyAnEventMiscHeartBeat CyAsEventMiscHeartBeat
+#define CyAnEventMiscWakeup CyAsEventMiscWakeup
+#define CyAnEventMiscDeviceMismatch CyAsEventMiscDeviceMismatch
+typedef CyAsMiscEventType CyAnMiscEventType;
+typedef CyAsMiscEventCallback CyAnMiscEventCallback;
+
+#define CyAnMiscGpio_0 CyAsMiscGpio_0
+#define CyAnMiscGpio_1 CyAsMiscGpio_1
+#define CyAnMiscGpio_Nand_CE CyAsMiscGpio_Nand_CE
+#define CyAnMiscGpio_Nand_CE2 CyAsMiscGpio_Nand_CE2
+#define CyAnMiscGpio_Nand_WP CyAsMiscGpio_Nand_WP
+#define CyAnMiscGpio_Nand_CLE CyAsMiscGpio_Nand_CLE
+#define CyAnMiscGpio_Nand_ALE CyAsMiscGpio_Nand_ALE
+#define CyAnMiscGpio_UValid CyAsMiscGpio_UValid
+#define CyAnMiscGpio_SD_POW CyAsMiscGpio_SD_POW
+typedef CyAsMiscGpio CyAnMiscGpio;
+
+#define CY_AN_SD_DEFAULT_FREQ CY_AS_SD_DEFAULT_FREQ
+#define CY_AN_SD_RATED_FREQ CY_AS_SD_RATED_FREQ
+typedef CyAsLowSpeedSDFreq CyAnLowSpeedSDFreq;
+
+#define CY_AN_HS_SD_FREQ_48 CY_AS_HS_SD_FREQ_48
+#define CY_AN_HS_SD_FREQ_24 CY_AS_HS_SD_FREQ_24
+typedef CyAsHighSpeedSDFreq CyAnHighSpeedSDFreq;
+
+#define CyAnMiscActiveHigh CyAsMiscActiveHigh
+#define CyAnMiscActiveLow CyAsMiscActiveLow
+typedef CyAsMiscSignalPolarity CyAnMiscSignalPolarity;
+
+typedef CyAsGetFirmwareVersionData CyAnGetFirmwareVersionData;
+
+enum {
+ CYAN_FW_TRACE_LOG_NONE = 0,
+ CYAN_FW_TRACE_LOG_STATE,
+ CYAN_FW_TRACE_LOG_CALLS,
+ CYAN_FW_TRACE_LOG_STACK_TRACE,
+ CYAN_FW_TRACE_MAX_LEVEL
+};
+
+
+/***********************************/
+/***********************************/
+/* FUNCTIONS */
+/***********************************/
+/***********************************/
+
+
+EXTERN CyAnReturnStatus_t
+CyAnMiscCreateDevice(
+ CyAnDeviceHandle * handle_p,
+ CyAnHalDeviceTag tag
+ ) ;
+#define CyAnMiscCreateDevice(h, tag) CyAsMiscCreateDevice((CyAsDeviceHandle *)(h), (CyAsHalDeviceTag)(tag))
+
+EXTERN CyAnReturnStatus_t
+CyAnMiscDestroyDevice(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnMiscDestroyDevice(h) CyAsMiscDestroyDevice((CyAsDeviceHandle)(h))
+
+EXTERN CyAnReturnStatus_t
+CyAnMiscConfigureDevice(
+ CyAnDeviceHandle handle,
+ CyAnDeviceConfig *config_p
+ ) ;
+#define CyAnMiscConfigureDevice(h, cfg) CyAsMiscConfigureDevice((CyAsDeviceHandle)(h), (CyAsDeviceConfig *)(cfg))
+
+EXTERN CyAnReturnStatus_t
+CyAnMiscInStandby(
+ CyAnDeviceHandle handle,
+ CyBool *standby
+ ) ;
+#define CyAnMiscInStandby(h, standby) CyAsMiscInStandby((CyAsDeviceHandle)(h), (standby))
+
+/* Sync version of Download Firmware */
+EXTERN CyAnReturnStatus_t
+CyAnMiscDownloadFirmware(
+ CyAnDeviceHandle handle,
+ const void *fw_p,
+ uint16_t size
+ ) ;
+
+#define CyAnMiscDownloadFirmware(handle, fw_p, size) \
+ CyAsMiscDownloadFirmware((CyAsDeviceHandle)(handle), (fw_p), (size), 0, 0)
+
+/* Async version of Download Firmware */
+EXTERN CyAnReturnStatus_t
+CyAnMiscDownloadFirmwareEX(
+ CyAnDeviceHandle handle,
+ const void *fw_p,
+ uint16_t size,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+#define CyAnMiscDownloadFirmwareEX(h, fw_p, size, cb, client) \
+ CyAsMiscDownloadFirmware((CyAsDeviceHandle)(h), (fw_p), (size), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Get Firmware Version */
+EXTERN CyAnReturnStatus_t
+CyAsMiscGetFirmwareVersion_dep(CyAsDeviceHandle handle,
+ uint16_t *major,
+ uint16_t *minor,
+ uint16_t *build,
+ uint8_t *mediaType,
+ CyBool *isDebugMode);
+
+#define CyAnMiscGetFirmwareVersion(h, major, minor, bld, type, mode) \
+ CyAsMiscGetFirmwareVersion_dep((CyAsDeviceHandle)(h), (major), (minor), (bld), (type), (mode))
+
+/* Async version of Get Firmware Version*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscGetFirmwareVersionEX(
+ CyAnDeviceHandle handle,
+ CyAnGetFirmwareVersionData* data,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscGetFirmwareVersionEX(h, data, cb, client) \
+ CyAsMiscGetFirmwareVersion((CyAsDeviceHandle)(h), (data), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Read MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscReadMCURegister(
+ CyAnDeviceHandle handle,
+ uint16_t address,
+ uint8_t *value
+ ) ;
+
+#define CyAnMiscReadMCURegister(handle, address, value) \
+ CyAsMiscReadMCURegister((CyAsDeviceHandle)(handle), (address), (value), 0, 0)
+
+/* Async version of Read MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscReadMCURegisterEX(
+ CyAnDeviceHandle handle,
+ uint16_t address,
+ uint8_t *value,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+#define CyAnMiscReadMCURegisterEX(h, addr, val, cb, client) \
+ CyAsMiscReadMCURegister((CyAsDeviceHandle)(h), (addr), (val), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Write MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscWriteMCURegister(
+ CyAnDeviceHandle handle,
+ uint16_t address,
+ uint8_t mask,
+ uint8_t value
+ ) ;
+#define CyAnMiscWriteMCURegister(handle, address, mask, value) \
+ CyAsMiscWriteMCURegister((CyAsDeviceHandle)(handle), (address), (mask), (value), 0, 0)
+
+/* Async version of Write MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscWriteMCURegisterEX(
+ CyAnDeviceHandle handle,
+ uint16_t address,
+ uint8_t mask,
+ uint8_t value,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscWriteMCURegisterEX(h, addr, mask, val, cb, client) \
+ CyAsMiscWriteMCURegister((CyAsDeviceHandle)(h), (addr), (mask), (val), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Write MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscReset(
+ CyAnDeviceHandle handle,
+ CyAnResetType type,
+ CyBool flush
+ ) ;
+#define CyAnMiscReset(handle, type, flush) \
+ CyAsMiscReset((CyAsDeviceHandle)(handle), (type), (flush), 0, 0)
+
+/* Async version of Write MCU Register*/
+EXTERN CyAnReturnStatus_t
+CyAnMiscResetEX(
+ CyAnDeviceHandle handle,
+ CyAnResetType type,
+ CyBool flush,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscResetEX(h, type, flush, cb, client) \
+ CyAsMiscReset((CyAsDeviceHandle)(h), (CyAsResetType)(type), (flush), (CyAsFunctionCallback)(cb), (client))
+
+/* Synchronous version of CyAnMiscAcquireResource. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscAcquireResource(
+ CyAnDeviceHandle handle,
+ CyAnResourceType type,
+ CyBool force
+ ) ;
+#define CyAnMiscAcquireResource(h, type, force) \
+ CyAsMiscAcquireResource_dep((CyAsDeviceHandle)(h), (CyAsResourceType)(type), (force))
+
+/* Asynchronous version of CyAnMiscAcquireResource. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscAcquireResourceEX(
+ CyAnDeviceHandle handle,
+ CyAnResourceType* type,
+ CyBool force,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscAcquireResourceEX(h, type_p, force, cb, client) \
+ CyAsMiscAcquireResource((CyAsDeviceHandle)(h), (CyAsResourceType *)(type_p), \
+ (force), (CyAsFunctionCallback)(cb), (client))
+
+/* The one and only version of Release resource */
+EXTERN CyAnReturnStatus_t
+CyAnMiscReleaseResource(
+ CyAnDeviceHandle handle,
+ CyAnResourceType type
+ ) ;
+#define CyAnMiscReleaseResource(h, type) \
+ CyAsMiscReleaseResource((CyAsDeviceHandle)(h), (CyAsResourceType)(type))
+
+/* Synchronous version of CyAnMiscSetTraceLevel. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetTraceLevel(
+ CyAnDeviceHandle handle,
+ uint8_t level,
+ CyAnMediaType media,
+ uint32_t device,
+ uint32_t unit
+ ) ;
+
+#define CyAnMiscSetTraceLevel(handle, level, media, device, unit) \
+ CyAsMiscSetTraceLevel_dep((CyAsDeviceHandle)(handle), (level), (CyAsMediaType)(media), (device), (unit), 0, 0)
+
+/* Asynchronous version of CyAnMiscSetTraceLevel. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetTraceLevelEX(
+ CyAnDeviceHandle handle,
+ uint8_t level,
+ CyAnMediaType media,
+ uint32_t device,
+ uint32_t unit,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscSetTraceLevelEX(h, level, media, device, unit, cb, client) \
+ CyAsMiscSetTraceLevel_dep((CyAsDeviceHandle)(h), (level), (CyAsMediaType)(media), (device), (unit), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Synchronous version of CyAnMiscEnterStandby. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscEnterStandby(
+ CyAnDeviceHandle handle,
+ CyBool pin
+ ) ;
+#define CyAnMiscEnterStandby(handle, pin) \
+ CyAsMiscEnterStandby((CyAsDeviceHandle)(handle), (pin), 0, 0)
+
+/* Synchronous version of CyAnMiscEnterStandby. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscEnterStandbyEX(
+ CyAnDeviceHandle handle,
+ CyBool pin,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscEnterStandbyEX(h, pin, cb, client) \
+ CyAsMiscEnterStandby((CyAsDeviceHandle)(h), (pin), (CyAsFunctionCallback)(cb), (client))
+
+/* Only one version of CyAnMiscLeaveStandby. */
+EXTERN CyAnReturnStatus_t
+CyAnMiscLeaveStandby(
+ CyAnDeviceHandle handle,
+ CyAnResourceType type
+ ) ;
+#define CyAnMiscLeaveStandby(h, type) \
+ CyAsMiscLeaveStandby((CyAsDeviceHandle)(h), (CyAsResourceType)(type))
+
+/* The one version of Misc Register Callback */
+EXTERN CyAnReturnStatus_t
+CyAnMiscRegisterCallback(
+ CyAnDeviceHandle handle,
+ CyAnMiscEventCallback callback
+ ) ;
+#define CyAnMiscRegisterCallback(h, cb) \
+ CyAsMiscRegisterCallback((CyAsDeviceHandle)(h), (CyAsMiscEventCallback)(cb))
+
+/* The only version of SetLogLevel */
+EXTERN void
+CyAnMiscSetLogLevel(
+ uint8_t level
+ ) ;
+#define CyAnMiscSetLogLevel(level) CyAsMiscSetLogLevel(level)
+
+/* Sync version of Misc Storage Changed */
+EXTERN CyAnReturnStatus_t
+CyAnMiscStorageChanged(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnMiscStorageChanged(handle) \
+ CyAsMiscStorageChanged((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async version of Misc Storage Changed */
+EXTERN CyAnReturnStatus_t
+CyAnMiscStorageChangedEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscStorageChangedEX(h, cb, client) \
+ CyAsMiscStorageChanged((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Heartbeat control */
+EXTERN CyAnReturnStatus_t
+CyAnMiscHeartBeatControl(
+ CyAnDeviceHandle handle,
+ CyBool enable
+ ) ;
+#define CyAnMiscHeartBeatControl(handle, enable) \
+ CyAsMiscHeartBeatControl((CyAsDeviceHandle)(handle), (enable), 0, 0)
+
+/* Async version of Heartbeat control */
+EXTERN CyAnReturnStatus_t
+CyAnMiscHeartBeatControlEX(
+ CyAnDeviceHandle handle,
+ CyBool enable,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscHeartBeatControlEX(h, enable, cb, client) \
+ CyAsMiscHeartBeatControl((CyAsDeviceHandle)(h), (enable), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Get Gpio */
+EXTERN CyAnReturnStatus_t
+CyAnMiscGetGpioValue(
+ CyAnDeviceHandle handle,
+ CyAnMiscGpio pin,
+ uint8_t *value
+ ) ;
+#define CyAnMiscGetGpioValue(handle, pin, value) \
+ CyAsMiscGetGpioValue((CyAsDeviceHandle)(handle), (CyAsMiscGpio)(pin), (value), 0, 0)
+
+/* Async version of Get Gpio */
+EXTERN CyAnReturnStatus_t
+CyAnMiscGetGpioValueEX(
+ CyAnDeviceHandle handle,
+ CyAnMiscGpio pin,
+ uint8_t *value,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscGetGpioValueEX(h, pin, value, cb, client) \
+ CyAsMiscGetGpioValue((CyAsDeviceHandle)(h), (CyAsMiscGpio)(pin), (value), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Set Gpio */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetGpioValue(
+ CyAnDeviceHandle handle,
+ CyAnMiscGpio pin,
+ uint8_t value
+ ) ;
+#define CyAnMiscSetGpioValue(handle, pin, value) \
+ CyAsMiscSetGpioValue((CyAsDeviceHandle)(handle), (CyAsMiscGpio)(pin), (value), 0, 0)
+
+/* Async version of Set Gpio */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetGpioValueEX(
+ CyAnDeviceHandle handle,
+ CyAnMiscGpio pin,
+ uint8_t value,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscSetGpioValueEX(h, pin, value, cb, client) \
+ CyAsMiscSetGpioValue((CyAsDeviceHandle)(h), (CyAsMiscGpio)(pin), (value), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Enter suspend */
+EXTERN CyAnReturnStatus_t
+CyAnMiscEnterSuspend(
+ CyAnDeviceHandle handle,
+ CyBool usb_wakeup_en,
+ CyBool gpio_wakeup_en
+ ) ;
+#define CyAnMiscEnterSuspend(handle, usb_wakeup_en, gpio_wakeup_en) \
+ CyAsMiscEnterSuspend((CyAsDeviceHandle)(handle), (usb_wakeup_en), (gpio_wakeup_en), 0, 0)
+
+/* Async version of Enter suspend */
+EXTERN CyAnReturnStatus_t
+CyAnMiscEnterSuspendEX(
+ CyAnDeviceHandle handle,
+ CyBool usb_wakeup_en,
+ CyBool gpio_wakeup_en,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscEnterSuspendEX(h, usb_en, gpio_en, cb, client) \
+ CyAsMiscEnterSuspend((CyAsDeviceHandle)(h), (usb_en), (gpio_en), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Enter suspend */
+EXTERN CyAnReturnStatus_t
+CyAnMiscLeaveSuspend(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnMiscLeaveSuspend(handle) \
+ CyAsMiscLeaveSuspend((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async version of Enter suspend */
+EXTERN CyAnReturnStatus_t
+CyAnMiscLeaveSuspendEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+#define CyAnMiscLeaveSuspendEX(h, cb, client) \
+ CyAsMiscLeaveSuspend((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of SetLowSpeedSDFreq */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetLowSpeedSDFreq(
+ CyAnDeviceHandle handle,
+ CyAnLowSpeedSDFreq setting
+ ) ;
+#define CyAnMiscSetLowSpeedSDFreq(h, setting) \
+ CyAsMiscSetLowSpeedSDFreq((CyAsDeviceHandle)(h), (CyAsLowSpeedSDFreq)(setting), 0, 0)
+
+/* Async version of SetLowSpeedSDFreq */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetLowSpeedSDFreqEX(
+ CyAnDeviceHandle handle,
+ CyAnLowSpeedSDFreq setting,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscSetLowSpeedSDFreqEX(h, setting, cb, client) \
+ CyAsMiscSetLowSpeedSDFreq((CyAsDeviceHandle)(h), (CyAsLowSpeedSDFreq)(setting), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* SetHighSpeedSDFreq */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetHighSpeedSDFreq(
+ CyAnDeviceHandle handle,
+ CyAnHighSpeedSDFreq setting,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnMiscSetHighSpeedSDFreq(h, setting, cb, client) \
+ CyAsMiscSetHighSpeedSDFreq((CyAsDeviceHandle)(h), (CyAsHighSpeedSDFreq)(setting), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* ReserveLNABootArea */
+EXTERN CyAnReturnStatus_t
+CyAnMiscReserveLNABootArea(
+ CyAnDeviceHandle handle,
+ uint8_t numzones,
+ CyAnFunctionCallback cb,
+ uint32_t client);
+#define CyAnMiscReserveLNABootArea(h, num, cb, client) \
+ CyAsMiscReserveLNABootArea((CyAsDeviceHandle)(h), num, (CyAsFunctionCallback)(cb), \
+ (client))
+
+/* SetSDPowerPolarity */
+EXTERN CyAnReturnStatus_t
+CyAnMiscSetSDPowerPolarity(
+ CyAnDeviceHandle handle,
+ CyAnMiscSignalPolarity polarity,
+ CyAnFunctionCallback cb,
+ uint32_t client);
+#define CyAnMiscSetSDPowerPolarity(h, pol, cb, client) \
+ CyAsMiscSetSDPowerPolarity((CyAsDeviceHandle)(h), (CyAsMiscSignalPolarity)(pol), \
+ (CyAsFunctionCallback)(cb), (client))
+
+#include "cyas_cplus_end.h"
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanregs.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,180 @@
+/* Cypress West Bridge API header file (cyanregs.h)
+ ## Register and field definitions for the Antioch device.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANREG_H_
+#define _INCLUDED_CYANREG_H_
+
+#if !defined(__doxygen__)
+
+#define CY_AN_MEM_CM_WB_CFG_ID (0x80)
+#define CY_AN_MEM_CM_WB_CFG_ID_VER_MASK (0x000F)
+#define CY_AN_MEM_CM_WB_CFG_ID_HDID_MASK (0xFFF0)
+#define CY_AN_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE (0xA100)
+#define CY_AN_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE (0x6800)
+#define CY_AN_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE (0xA200)
+
+
+#define CY_AN_MEM_RST_CTRL_REG (0x81)
+#define CY_AN_MEM_RST_CTRL_REG_HARD (0x0003)
+#define CY_AN_MEM_RST_CTRL_REG_SOFT (0x0001)
+#define CY_AN_MEM_RST_RSTCMPT (0x0004)
+
+#define CY_AN_MEM_P0_ENDIAN (0x82)
+#define CY_AN_LITTLE_ENDIAN (0x0000)
+#define CY_AN_BIG_ENDIAN (0x0101)
+
+#define CY_AN_MEM_P0_VM_SET (0x83)
+#define CY_AN_MEM_P0_VM_SET_VMTYPE_MASK (0x0007)
+#define CY_AN_MEM_P0_VM_SET_VMTYPE_RAM (0x0005)
+#define CY_AN_MEM_P0_VM_SET_VMTYPE_VMWIDTH (0x0008)
+#define CY_AN_MEM_P0_VM_SET_VMTYPE_FLOWCTRL (0x0010)
+#define CY_AN_MEM_P0_VM_SET_IFMODE (0x0020)
+#define CY_AN_MEM_P0_VM_SET_CFGMODE (0x0040)
+#define CY_AN_MEM_P0_VM_SET_DACKEOB (0x0080)
+#define CY_AN_MEM_P0_VM_SET_OVERRIDE (0x0100)
+#define CY_AN_MEM_P0_VM_SET_INTOVERD (0x0200)
+#define CY_AN_MEM_P0_VM_SET_DRQOVERD (0x0400)
+#define CY_AN_MEM_P0_VM_SET_DRQPOL (0x0800)
+#define CY_AN_MEM_P0_VM_SET_DACKPOL (0x1000)
+
+
+#define CY_AN_MEM_P0_NV_SET (0x84)
+#define CY_AN_MEM_P0_NV_SET_WPSWEN (0x0001)
+#define CY_AN_MEM_P0_NV_SET_WPPOLAR (0x0002)
+
+#define CY_AN_MEM_PMU_UPDATE (0x85)
+#define CY_AN_MEM_PMU_UPDATE_UVALID (0x0001)
+#define CY_AN_MEM_PMU_UPDATE_USBUPDATE (0x0002)
+#define CY_AN_MEM_PMU_UPDATE_SDIOUPDATE (0x0004)
+
+#define CY_AN_MEM_P0_INTR_REG (0x90)
+#define CY_AN_MEM_P0_INTR_REG_MCUINT (0x0020)
+#define CY_AN_MEM_P0_INTR_REG_DRQINT (0x0800)
+#define CY_AN_MEM_P0_INTR_REG_MBINT (0x1000)
+#define CY_AN_MEM_P0_INTR_REG_PMINT (0x2000)
+#define CY_AN_MEM_P0_INTR_REG_PLLLOCKINT (0x4000)
+
+#define CY_AN_MEM_P0_INT_MASK_REG (0x91)
+#define CY_AN_MEM_P0_INT_MASK_REG_MMCUINT (0x0020)
+#define CY_AN_MEM_P0_INT_MASK_REG_MDRQINT (0x0800)
+#define CY_AN_MEM_P0_INT_MASK_REG_MMBINT (0x1000)
+#define CY_AN_MEM_P0_INT_MASK_REG_MPMINT (0x2000)
+#define CY_AN_MEM_P0_INT_MASK_REG_MPLLLOCKINT (0x4000)
+
+#define CY_AN_MEM_MCU_MB_STAT (0x92)
+#define CY_AN_MEM_P0_MCU_MBNOTRD (0x0001)
+
+#define CY_AN_MEM_P0_MCU_STAT (0x94)
+#define CY_AN_MEM_P0_MCU_STAT_CARDINS (0x0001)
+#define CY_AN_MEM_P0_MCU_STAT_CARDREM (0x0002)
+
+#define CY_AN_MEM_PWR_MAGT_STAT (0x95)
+#define CY_AN_MEM_PWR_MAGT_STAT_WAKEUP (0x0001)
+
+#define CY_AN_MEM_P0_RSE_ALLOCATE (0x98)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_SDIOAVI (0x0001)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_SDIOALLO (0x0002)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_NANDAVI (0x0004)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_NANDALLO (0x0008)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_USBAVI (0x0010)
+#define CY_AN_MEM_P0_RSE_ALLOCATE_USBALLO (0x0020)
+
+#define CY_AN_MEM_P0_RSE_MASK (0x9A)
+#define CY_AN_MEM_P0_RSE_MASK_MSDIOBUS_RW (0x0003)
+#define CY_AN_MEM_P0_RSE_MASK_MNANDBUS_RW (0x00C0)
+#define CY_AN_MEM_P0_RSE_MASK_MUSBBUS_RW (0x0030)
+
+#define CY_AN_MEM_P0_DRQ (0xA0)
+#define CY_AN_MEM_P0_DRQ_EP2DRQ (0x0004)
+#define CY_AN_MEM_P0_DRQ_EP3DRQ (0x0008)
+#define CY_AN_MEM_P0_DRQ_EP4DRQ (0x0010)
+#define CY_AN_MEM_P0_DRQ_EP5DRQ (0x0020)
+#define CY_AN_MEM_P0_DRQ_EP6DRQ (0x0040)
+#define CY_AN_MEM_P0_DRQ_EP7DRQ (0x0080)
+#define CY_AN_MEM_P0_DRQ_EP8DRQ (0x0100)
+#define CY_AN_MEM_P0_DRQ_EP9DRQ (0x0200)
+#define CY_AN_MEM_P0_DRQ_EP10DRQ (0x0400)
+#define CY_AN_MEM_P0_DRQ_EP11DRQ (0x0800)
+#define CY_AN_MEM_P0_DRQ_EP12DRQ (0x1000)
+#define CY_AN_MEM_P0_DRQ_EP13DRQ (0x2000)
+#define CY_AN_MEM_P0_DRQ_EP14DRQ (0x4000)
+#define CY_AN_MEM_P0_DRQ_EP15DRQ (0x8000)
+
+#define CY_AN_MEM_P0_DRQ_MASK (0xA1)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP2DRQ (0x0004)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP3DRQ (0x0008)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP4DRQ (0x0010)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP5DRQ (0x0020)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP6DRQ (0x0040)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP7DRQ (0x0080)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP8DRQ (0x0100)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP9DRQ (0x0200)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP10DRQ (0x0400)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP11DRQ (0x0800)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP12DRQ (0x1000)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP13DRQ (0x2000)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP14DRQ (0x4000)
+#define CY_AN_MEM_P0_DRQ_MASK_MEP15DRQ (0x8000)
+
+#define CY_AN_MEM_P0_EP2_DMA_REG (0xA2)
+#define CY_AN_MEM_P0_EPn_DMA_REG_COUNT_MASK (0x7FF)
+#define CY_AN_MEM_P0_EPn_DMA_REG_DMAVAL (1 << 12)
+#define CY_AN_MEM_P0_EP3_DMA_REG (0xA3)
+#define CY_AN_MEM_P0_EP4_DMA_REG (0xA4)
+#define CY_AN_MEM_P0_EP5_DMA_REG (0xA5)
+#define CY_AN_MEM_P0_EP6_DMA_REG (0xA6)
+#define CY_AN_MEM_P0_EP7_DMA_REG (0xA7)
+#define CY_AN_MEM_P0_EP8_DMA_REG (0xA8)
+#define CY_AN_MEM_P0_EP9_DMA_REG (0xA9)
+#define CY_AN_MEM_P0_EP10_DMA_REG (0xAA)
+#define CY_AN_MEM_P0_EP11_DMA_REG (0xAB)
+#define CY_AN_MEM_P0_EP12_DMA_REG (0xAC)
+#define CY_AN_MEM_P0_EP13_DMA_REG (0xAD)
+#define CY_AN_MEM_P0_EP14_DMA_REG (0xAE)
+#define CY_AN_MEM_P0_EP15_DMA_REG (0xAF)
+
+#define CY_AN_MEM_IROS_IO_CFG (0xC1)
+#define CY_AN_MEM_IROS_IO_CFG_GPIODRVST_MASK (0x0003)
+#define CY_AN_MEM_IROS_IO_CFG_GPIOSLEW_MASK (0x0004)
+#define CY_AN_MEM_IROS_IO_CFG_PPIODRVST_MASK (0x0018)
+#define CY_AN_MEM_IROS_IO_CFG_PPIOSLEW_MASK (0x0020)
+#define CY_AN_MEM_IROS_IO_CFG_SSIODRVST_MASK (0x0300)
+#define CY_AN_MEM_IROS_IO_CFG_SSIOSLEW_MASK (0x0400)
+#define CY_AN_MEM_IROS_IO_CFG_SNIODRVST_MASK (0x1800)
+#define CY_AN_MEM_IROS_IO_CFG_SNIOSLEW_MASK (0x2000)
+
+#define CY_AN_MEM_PLL_LOCK_LOSS_STAT (0xC4)
+#define CY_AN_MEM_PLL_LOCK_LOSS_STAT_PLLSTAT (0x0800)
+
+#define CY_AN_MEM_P0_MAILBOX0 (0xF0)
+#define CY_AN_MEM_P0_MAILBOX1 (0xF1)
+#define CY_AN_MEM_P0_MAILBOX2 (0xF2)
+#define CY_AN_MEM_P0_MAILBOX3 (0xF3)
+
+#define CY_AN_MEM_MCU_MAILBOX0 (0xF8)
+#define CY_AN_MEM_MCU_MAILBOX1 (0xF9)
+#define CY_AN_MEM_MCU_MAILBOX2 (0xFA)
+#define CY_AN_MEM_MCU_MAILBOX3 (0xFB)
+
+#endif /* !defined(__doxygen__) */
+
+#endif /* _INCLUDED_CYANREG_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyansdkversion.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,30 @@
+/* Cypress Antioch Sdk Version file (cyansdkversion.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANSDK_VERSION_H_
+#define _INCLUDED_CYANSDK_VERSION_H_
+
+/* Antioch SDK version 1.3.2 */
+#define CYAN_MAJOR_VERSION (1)
+#define CYAN_MINOR_VERSION (3)
+#define CYAN_BUILD_NUMBER (473)
+
+#endif /*_INCLUDED_CYANSDK_VERSION_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanstorage.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,371 @@
+/* Cypress West Bridge API header file (cyanstorage.h)
+ ## Header for backward compatibility with previous releases of Antioch SDK.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANSTORAGE_H_
+#define _INCLUDED_CYANSTORAGE_H_
+#ifndef __doxygen__
+
+#include "cyanmedia.h"
+#include "cyanmisc.h"
+#include "cyasstorage.h"
+#include "cyas_cplus_start.h"
+
+#define CY_AN_LUN_PHYSICAL_DEVICE (CY_AS_LUN_PHYSICAL_DEVICE)
+#define CY_AN_STORAGE_EP_SIZE (CY_AS_STORAGE_EP_SIZE)
+
+#define CyAnStorageAntioch CyAsStorageAntioch
+#define CyAnStorageProcessor CyAsStorageProcessor
+#define CyAnStorageRemoved CyAsStorageRemoved
+#define CyAnStorageInserted CyAsStorageInserted
+#define CyAnSdioInterrupt CyAsSdioInterrupt
+typedef CyAsStorageEvent CyAnStorageEvent;
+
+#define CyAnOpRead CyAsOpRead
+#define CyAnOpWrite CyAsOpWrite
+typedef CyAsOperType CyAnOperType;
+
+typedef CyAsDeviceDesc CyAnDeviceDesc;
+
+typedef CyAsUnitDesc CyAnUnitDesc;
+
+typedef CyAsStorageCallback_dep CyAnStorageCallback;
+
+typedef CyAsStorageEventCallback_dep CyAnStorageEventCallback;
+
+#define CyAnSDReg_OCR CyAsSDReg_OCR
+#define CyAnSDReg_CID CyAsSDReg_CID
+#define CyAnSDReg_CSD CyAsSDReg_CSD
+typedef CyAsSDCardRegType CyAnSDCardRegType;
+
+typedef CyAsStorageQueryDeviceData_dep CyAnStorageQueryDeviceData ;
+
+typedef CyAsStorageQueryUnitData_dep CyAnStorageQueryUnitData ;
+
+typedef CyAsStorageSDRegReadData CyAnStorageSDRegReadData;
+
+#define CY_AN_SD_REG_OCR_LENGTH (CY_AS_SD_REG_OCR_LENGTH)
+#define CY_AN_SD_REG_CID_LENGTH (CY_AS_SD_REG_CID_LENGTH)
+#define CY_AN_SD_REG_CSD_LENGTH (CY_AS_SD_REG_CSD_LENGTH)
+#define CY_AN_SD_REG_MAX_RESP_LENGTH (CY_AS_SD_REG_MAX_RESP_LENGTH)
+
+/**** API Functions ******/
+
+/* Sync version of Storage Start */
+EXTERN CyAnReturnStatus_t
+CyAnStorageStart(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnStorageStart(handle) CyAsStorageStart((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async version of Storage Start */
+EXTERN CyAnReturnStatus_t
+CyAnStorageStartEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageStartEX(h, cb, client) \
+ CyAsStorageStart((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Storage Stop */
+EXTERN CyAnReturnStatus_t
+CyAnStorageStop(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnStorageStop(handle) CyAsStorageStop((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async version of Storage Stop */
+EXTERN CyAnReturnStatus_t
+CyAnStorageStopEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageStopEX(h, cb, client) \
+ CyAsStorageStop((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Register Call back api */
+EXTERN CyAnReturnStatus_t
+CyAnStorageRegisterCallback(
+ CyAnDeviceHandle handle,
+ CyAnStorageEventCallback callback
+ ) ;
+#define CyAnStorageRegisterCallback(h, cb) \
+ CyAsStorageRegisterCallback_dep((CyAsDeviceHandle)(h), (CyAsStorageEventCallback_dep)(cb))
+
+/* Sync version of Storage Claim */
+EXTERN CyAnReturnStatus_t
+CyAnStorageClaim(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type
+ ) ;
+#define CyAnStorageClaim(h, type) \
+ CyAsStorageClaim_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type))
+
+/* Async version of Storage Claim */
+EXTERN CyAnReturnStatus_t
+CyAnStorageClaimEX(
+ CyAnDeviceHandle handle,
+ CyAnMediaType* type,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageClaimEX(h, type_p, cb, client) \
+ CyAsStorageClaim_dep_EX((CyAsDeviceHandle)(h), (CyAsMediaType *)(type_p), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync Version of Storage Release */
+EXTERN CyAnReturnStatus_t
+CyAnStorageRelease(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type
+ ) ;
+#define CyAnStorageRelease(h, type) \
+ CyAsStorageRelease_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type))
+
+/* Async Version of Storage Release */
+EXTERN CyAnReturnStatus_t
+CyAnStorageReleaseEX(
+ CyAnDeviceHandle handle,
+ CyAnMediaType* type,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageReleaseEX(h, type_p, cb, client) \
+ CyAsStorageRelease_dep_EX((CyAsDeviceHandle)(h), (CyAsMediaType *)(type_p), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Query Media */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryMedia(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t * count
+ ) ;
+#define CyAnStorageQueryMedia(handle, type, count) \
+ CyAsStorageQueryMedia((CyAsDeviceHandle)(handle), (CyAsMediaType)(type), (count), 0, 0)
+
+/* Async version of Query Media */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryMediaEX(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t * count,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageQueryMediaEX(h, type, count, cb, client) \
+ CyAsStorageQueryMedia((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (count), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Query device */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryDevice(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ CyAnDeviceDesc * desc_p
+ ) ;
+#define CyAnStorageQueryDevice(h, type, device, desc_p) \
+ CyAsStorageQueryDevice_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (CyAsDeviceDesc *)(desc_p))
+
+/* Async version of Query device */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryDeviceEX(
+ CyAnDeviceHandle handle,
+ CyAnStorageQueryDeviceData* data,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageQueryDeviceEX(h, data, cb, client) \
+ CyAsStorageQueryDevice_dep_EX((CyAsDeviceHandle)(h), (CyAsStorageQueryDeviceData_dep *)(data), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Query Unit */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryUnit(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ uint32_t unit,
+ CyAnUnitDesc * desc_p
+ ) ;
+#define CyAnStorageQueryUnit(h, type, device, unit, desc_p) \
+ CyAsStorageQueryUnit_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (unit), (CyAsUnitDesc *)(desc_p))
+
+/* Async version of Query Unit */
+EXTERN CyAnReturnStatus_t
+CyAnStorageQueryUnitEX(
+ CyAnDeviceHandle handle,
+ CyAnStorageQueryUnitData* data_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageQueryUnitEX(h, data_p, cb, client) \
+ CyAsStorageQueryUnit_dep_EX((CyAsDeviceHandle)(h), (CyAsStorageQueryUnitData_dep *)(data_p), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of device control */
+EXTERN CyAnReturnStatus_t
+CyAnStorageDeviceControl(
+ CyAnDeviceHandle handle,
+ CyBool card_detect_en,
+ CyBool write_prot_en
+ ) ;
+#define CyAnStorageDeviceControl(handle, card_detect_en, write_prot_en) \
+ CyAsStorageDeviceControl_dep((CyAsDeviceHandle)(handle), (card_detect_en), (write_prot_en), 0, 0)
+
+/* Async version of device control */
+EXTERN CyAnReturnStatus_t
+CyAnStorageDeviceControlEX(
+ CyAnDeviceHandle handle,
+ CyBool card_detect_en,
+ CyBool write_prot_en,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageDeviceControlEX(h, det_en, prot_en, cb, client) \
+ CyAsStorageDeviceControl_dep((CyAsDeviceHandle)(h), (det_en), (prot_en), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync Read */
+EXTERN CyAnReturnStatus_t
+CyAnStorageRead(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ uint32_t unit,
+ uint32_t block,
+ void * data_p,
+ uint16_t num_blocks
+ ) ;
+#define CyAnStorageRead(h, type, device, unit, block, data_p, nblks) \
+ CyAsStorageRead_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (unit), (block), (data_p), (nblks))
+
+/* Async Read */
+EXTERN CyAnReturnStatus_t
+CyAnStorageReadAsync(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ uint32_t unit,
+ uint32_t block,
+ void * data_p,
+ uint16_t num_blocks,
+ CyAnStorageCallback callback
+ ) ;
+#define CyAnStorageReadAsync(h, type, device, unit, block, data_p, nblks, cb) \
+ CyAsStorageReadAsync_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (unit), (block), \
+ (data_p), (nblks), (CyAsStorageCallback_dep)(cb))
+
+/* Sync Write */
+EXTERN CyAnReturnStatus_t
+CyAnStorageWrite(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ uint32_t unit,
+ uint32_t block,
+ void * data_p,
+ uint16_t num_blocks
+ ) ;
+#define CyAnStorageWrite(h, type, device, unit, block, data_p, nblks) \
+ CyAsStorageWrite_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (unit), (block), (data_p), (nblks))
+
+/* Async Write */
+EXTERN CyAnReturnStatus_t
+CyAnStorageWriteAsync(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint32_t device,
+ uint32_t unit,
+ uint32_t block,
+ void * data_p,
+ uint16_t num_blocks,
+ CyAnStorageCallback callback
+ ) ;
+#define CyAnStorageWriteAsync(h, type, device, unit, block, data_p, nblks, cb) \
+ CyAsStorageWriteAsync_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), (unit), (block), \
+ (data_p), (nblks), (CyAsStorageCallback_dep)(cb))
+
+/* Cancel Async */
+EXTERN CyAnReturnStatus_t
+CyAnStorageCancelAsync(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnStorageCancelAsync(h) CyAsStorageCancelAsync((CyAsDeviceHandle)(h))
+
+/* Sync SD Register Read*/
+EXTERN CyAnReturnStatus_t
+CyAnStorageSDRegisterRead(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint8_t device,
+ CyAnSDCardRegType regType,
+ uint8_t readLen,
+ uint8_t *data_p
+ ) ;
+#define CyAnStorageSDRegisterRead(h, type, device, regType, len, data_p) \
+ CyAsStorageSDRegisterRead_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), \
+ (CyAsSDCardRegType)(regType), (len), (data_p))
+
+/*Async SD Register Read*/
+EXTERN CyAnReturnStatus_t
+CyAnStorageSDRegisterReadEX(
+ CyAnDeviceHandle handle,
+ CyAnMediaType type,
+ uint8_t device,
+ CyAnSDCardRegType regType,
+ CyAnStorageSDRegReadData *data_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnStorageSDRegisterReadEX(h, type, device, regType, data_p, cb, client) \
+ CyAsStorageSDRegisterRead_dep_EX((CyAsDeviceHandle)(h), (CyAsMediaType)(type), (device), \
+ (CyAsSDCardRegType)(regType), (CyAsStorageSDRegReadData *)(data_p), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Create partition on storage device */
+EXTERN CyAnReturnStatus_t
+CyAnStorageCreatePPartition(
+ CyAnDeviceHandle handle,
+ CyAnMediaType media,
+ uint32_t device,
+ uint32_t size,
+ CyAnFunctionCallback cb,
+ uint32_t client) ;
+#define CyAnStorageCreatePPartition(h, media, dev, size, cb, client) \
+ CyAsStorageCreatePPartition_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(media), (dev), \
+ (size), (CyAsFunctionCallback)(cb), (client))
+
+/* Remove partition on storage device */
+EXTERN CyAnReturnStatus_t
+CyAnStorageRemovePPartition(
+ CyAnDeviceHandle handle,
+ CyAnMediaType media,
+ uint32_t device,
+ CyAnFunctionCallback cb,
+ uint32_t client) ;
+#define CyAnStorageRemovePPartition(h, media, dev, cb, client) \
+ CyAsStorageRemovePPartition_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(media), (dev), \
+ (CyAsFunctionCallback)(cb), (client))
+
+#include "cyas_cplus_end.h"
+#endif /*__doxygen__ */
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyantioch.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,35 @@
+/* Cypress West Bridge API header file (cyastioch.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANTIOCH_H_
+#define _INCLUDED_CYANTIOCH_H_
+
+#if !defined(__doxygen__)
+
+#include "cyanerr.h"
+#include "cyanmisc.h"
+#include "cyanstorage.h"
+#include "cyanusb.h"
+#include "cyanch9.h"
+
+#endif
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyantypes.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,30 @@
+/* Cypress West Bridge API header file (cyantypes.h)
+ ## Type definitions for backward compatibility with previous Antioch SDK releases.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANTYPES_H_
+#define _INCLUDED_CYANTYPES_H_
+
+#include "cyastypes.h"
+typedef CyAsEndPointNumber_t CyAnEndPointNumber_t ;
+typedef CyAsReturnStatus_t CyAnReturnStatus_t ;
+typedef CyAsBusNumber_t CyAnBusNumber_t ;
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyanusb.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,552 @@
+/* Cypress West Bridge API header file (cyanusb.h)
+ ## Header for backward compatibility with previous Antioch SDK releases.
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYANUSB_H_
+#define _INCLUDED_CYANUSB_H_
+
+#if !defined(__doxygen__)
+
+#include "cyanmisc.h"
+#include "cyasusb.h"
+#include "cyas_cplus_start.h"
+
+#define CY_AN_MAX_USB_DESCRIPTOR_SIZE (CY_AS_MAX_USB_DESCRIPTOR_SIZE)
+
+typedef CyAsUsbInquiryData_dep CyAnUsbInquiryData;
+typedef CyAsUsbUnknownCommandData_dep CyAnUsbUnknownCommandData ;
+typedef CyAsUsbStartStopData_dep CyAnUsbStartStopData ;
+typedef CyAsMSCProgressData CyAnMSCProgressData ;
+
+#define CyAnUsbNandEnum CyAsUsbNandEnum
+#define CyAnUsbSDEnum CyAsUsbSDEnum
+#define CyAnUsbMMCEnum CyAsUsbMMCEnum
+#define CyAnUsbCEATAEnum CyAsUsbCEATAEnum
+typedef CyAsUsbMassStorageEnum CyAnUsbMassStorageEnum;
+
+#define CyAnUsbDescDevice CyAsUsbDescDevice
+#define CyAnUsbDescDeviceQual CyAsUsbDescDeviceQual
+#define CyAnUsbDescFSConfiguration CyAsUsbDescFSConfiguration
+#define CyAnUsbDescHSConfiguration CyAsUsbDescHSConfiguration
+#define CyAnUsbDescString CyAsUsbDescString
+typedef CyAsUsbDescType CyAnUsbDescType ;
+
+#define CyAnUsbIn CyAsUsbIn
+#define CyAnUsbOut CyAsUsbOut
+#define CyAnUsbInOut CyAsUsbInOut
+typedef CyAsUsbEndPointDir CyAnUsbEndPointDir ;
+
+
+#define CyAnUsbControl CyAsUsbControl
+#define CyAnUsbIso CyAsUsbIso
+#define CyAnUsbBulk CyAsUsbBulk
+#define CyAnUsbInt CyAsUsbInt
+typedef CyAsUsbEndPointType CyAnUsbEndPointType ;
+
+
+typedef CyAsUsbEnumControl_dep CyAnUsbEnumControl ;
+typedef CyAsUsbEndPointConfig CyAnUsbEndPointConfig ;
+
+#define CyAnUsbMSUnit0 CyAsUsbMSUnit0
+#define CyAnUsbMSUnit1 CyAsUsbMSUnit1
+#define CyAnUsbMSBoth CyAsUsbMSBoth
+typedef CyAsUsbMSType_t CyAnUsbMSType_t ;
+
+#define CyAnEventUsbSuspend CyAsEventUsbSuspend
+#define CyAnEventUsbResume CyAsEventUsbResume
+#define CyAnEventUsbReset CyAsEventUsbReset
+#define CyAnEventUsbSetConfig CyAsEventUsbSetConfig
+#define CyAnEventUsbSpeedChange CyAsEventUsbSpeedChange
+#define CyAnEventUsbSetupPacket CyAsEventUsbSetupPacket
+#define CyAnEventUsbStatusPacket CyAsEventUsbStatusPacket
+#define CyAnEventUsbInquiryBefore CyAsEventUsbInquiryBefore
+#define CyAnEventUsbInquiryAfter CyAsEventUsbInquiryAfter
+#define CyAnEventUsbStartStop CyAsEventUsbStartStop
+#define CyAnEventUsbUnknownStorage CyAsEventUsbUnknownStorage
+#define CyAnEventUsbMSCProgress CyAsEventUsbMSCProgress
+typedef CyAsUsbEvent CyAnUsbEvent;
+
+typedef CyAsUsbEventCallback_dep CyAnUsbEventCallback ;
+
+typedef CyAsUsbIoCallback CyAnUsbIoCallback;
+typedef CyAsUsbFunctionCallback CyAnUsbFunctionCallback;
+
+/******* USB Functions ********************/
+
+/* Sync Usb Start */
+extern CyAnReturnStatus_t
+CyAnUsbStart(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbStart(handle) CyAsUsbStart((CyAsDeviceHandle)(handle), 0, 0)
+
+/*Async Usb Start */
+extern CyAnReturnStatus_t
+CyAnUsbStartEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbStartEX(h, cb, client) CyAsUsbStart((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync Usb Stop */
+extern CyAnReturnStatus_t
+CyAnUsbStop(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbStop(handle) CyAsUsbStop((CyAsDeviceHandle)(handle), 0, 0)
+
+/*Async Usb Stop */
+extern CyAnReturnStatus_t
+CyAnUsbStopEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbStopEX(h, cb, client) CyAsUsbStop((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Register USB event callback */
+EXTERN CyAnReturnStatus_t
+CyAnUsbRegisterCallback(
+ CyAnDeviceHandle handle,
+ CyAnUsbEventCallback callback
+ ) ;
+#define CyAnUsbRegisterCallback(h, cb) \
+ CyAsUsbRegisterCallback_dep((CyAsDeviceHandle)(h), (CyAsUsbEventCallback_dep)(cb))
+
+/*Sync Usb connect */
+EXTERN CyAnReturnStatus_t
+CyAnUsbConnect(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbConnect(handle) CyAsUsbConnect((CyAsDeviceHandle)(handle), 0, 0)
+
+/*Async Usb connect */
+extern CyAnReturnStatus_t
+CyAnUsbConnectEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbConnectEX(h, cb, client) \
+ CyAsUsbConnect((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/*Sync Usb disconnect */
+EXTERN CyAnReturnStatus_t
+CyAnUsbDisconnect(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbDisconnect(handle) CyAsUsbDisconnect((CyAsDeviceHandle)(handle), 0, 0)
+
+/*Async Usb disconnect */
+extern CyAnReturnStatus_t
+CyAnUsbDisconnectEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbDisconnectEX(h, cb, client) \
+ CyAsUsbDisconnect((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of set enum config */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetEnumConfig(
+ CyAnDeviceHandle handle,
+ CyAnUsbEnumControl * config_p
+ ) ;
+#define CyAnUsbSetEnumConfig(handle, config_p) \
+ CyAsUsbSetEnumConfig_dep((CyAsDeviceHandle)(handle), (CyAsUsbEnumControl_dep *)(config_p), 0, 0)
+
+/* Async version of set enum config */
+extern CyAnReturnStatus_t
+CyAnUsbSetEnumConfigEX(
+ CyAnDeviceHandle handle,
+ CyAnUsbEnumControl * config_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbSetEnumConfigEX(h, config_p, cb, client) \
+ CyAsUsbSetEnumConfig_dep((CyAsDeviceHandle)(h), (CyAsUsbEnumControl_dep *)(config_p), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of get enum config */
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetEnumConfig(
+ CyAnDeviceHandle handle,
+ CyAnUsbEnumControl * config_p
+ ) ;
+#define CyAnUsbGetEnumConfig(handle, config_p) \
+ CyAsUsbGetEnumConfig_dep((CyAsDeviceHandle)(handle), (CyAsUsbEnumControl_dep *)(config_p), 0, 0)
+
+/* Async version of get enum config */
+extern CyAnReturnStatus_t
+CyAnUsbGetEnumConfigEX(
+ CyAnDeviceHandle handle,
+ CyAnUsbEnumControl * config_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbGetEnumConfigEX(h, config_p, cb, client) \
+ CyAsUsbGetEnumConfig_dep((CyAsDeviceHandle)(h), (CyAsUsbEnumControl_dep *)(config_p), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Sync Version of Set descriptor */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetDescriptor(
+ CyAnDeviceHandle handle,
+ CyAnUsbDescType type,
+ uint8_t index,
+ void * desc_p,
+ uint16_t length
+ ) ;
+#define CyAnUsbSetDescriptor(handle, type, index, desc_p, length) \
+ CyAsUsbSetDescriptor((CyAsDeviceHandle)(handle), (CyAsUsbDescType)(type), (index), (desc_p), (length), 0, 0)
+
+/* Async Version of Set descriptor */
+extern CyAnReturnStatus_t
+CyAnUsbSetDescriptorEX(
+ CyAnDeviceHandle handle,
+ CyAnUsbDescType type,
+ uint8_t index,
+ void * desc_p,
+ uint16_t length,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbSetDescriptorEX(h, type, index, desc_p, length, cb, client) \
+ CyAsUsbSetDescriptor((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (desc_p), (length), \
+ (CyAsFunctionCallback)(cb), (client))
+
+/* Only version of clear descriptors */
+EXTERN CyAnReturnStatus_t
+CyAnUsbClearDescriptors(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbClearDescriptors(h, cb, client) \
+ CyAsUsbClearDescriptors((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of get descriptor*/
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetDescriptor(
+ CyAnDeviceHandle handle,
+ CyAnUsbDescType type,
+ uint8_t index,
+ void * desc_p,
+ uint32_t * length_p
+ ) ;
+#define CyAnUsbGetDescriptor(h, type, index, desc_p, length_p) \
+ CyAsUsbGetDescriptor_dep((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (desc_p), (length_p))
+
+typedef CyAsGetDescriptorData CyAnGetDescriptorData ;
+
+/* Async version of get descriptor */
+extern CyAnReturnStatus_t
+CyAnUsbGetDescriptorEX(
+ CyAnDeviceHandle handle,
+ CyAnUsbDescType type,
+ uint8_t index,
+ CyAnGetDescriptorData * data,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbGetDescriptorEX(h, type, index, data, cb, client) \
+ CyAsUsbGetDescriptor((CyAsDeviceHandle)(h), (CyAsUsbDescType)(type), (index), (CyAsGetDescriptorData *)(data), \
+ (CyAsFunctionCallback)(cb), (client))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetPhysicalConfiguration(
+ CyAnDeviceHandle handle,
+ uint8_t config
+ ) ;
+#define CyAnUsbSetPhysicalConfiguration(h, config) \
+ CyAsUsbSetPhysicalConfiguration((CyAsDeviceHandle)(h), (config))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetEndPointConfig(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbEndPointConfig * config_p
+ ) ;
+#define CyAnUsbSetEndPointConfig(h, ep, config_p) \
+ CyAsUsbSetEndPointConfig((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbEndPointConfig *)(config_p))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetEndPointConfig(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbEndPointConfig * config_p
+ ) ;
+#define CyAnUsbGetEndPointConfig(h, ep, config_p) \
+ CyAsUsbGetEndPointConfig((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbEndPointConfig *)(config_p))
+
+/* Sync version of commit */
+EXTERN CyAnReturnStatus_t
+CyAnUsbCommitConfig(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbCommitConfig(handle) CyAsUsbCommitConfig((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async version of commit */
+extern CyAnReturnStatus_t
+CyAnUsbCommitConfigEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbCommitConfigEX(h, cb, client) \
+ CyAsUsbCommitConfig((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbReadData(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool pktread,
+ uint32_t dsize,
+ uint32_t * dataread,
+ void * data
+ ) ;
+#define CyAnUsbReadData(h, ep, pkt, dsize, dataread, data_p) \
+ CyAsUsbReadData((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (pkt), (dsize), (dataread), (data_p))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbReadDataAsync(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool pktread,
+ uint32_t dsize,
+ void * data,
+ CyAnUsbIoCallback callback
+ ) ;
+#define CyAnUsbReadDataAsync(h, ep, pkt, dsize, data_p, cb) \
+ CyAsUsbReadDataAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (pkt), (dsize), (data_p), \
+ (CyAsUsbIoCallback)(cb))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbWriteData(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ uint32_t dsize,
+ void * data
+ ) ;
+#define CyAnUsbWriteData(h, ep, dsize, data_p) \
+ CyAsUsbWriteData((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (dsize), (data_p))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbWriteDataAsync(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ uint32_t dsize,
+ void * data,
+ CyBool spacket,
+ CyAnUsbIoCallback callback
+ ) ;
+#define CyAnUsbWriteDataAsync(h, ep, dsize, data_p, spacket, cb) \
+ CyAsUsbWriteDataAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (dsize), (data_p), (spacket), \
+ (CyAsUsbIoCallback)(cb))
+
+EXTERN CyAnReturnStatus_t
+CyAnUsbCancelAsync(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep
+ ) ;
+#define CyAnUsbCancelAsync(h, ep) CyAsUsbCancelAsync((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep))
+
+/* Sync version of set stall */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetStall(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbFunctionCallback cb,
+ uint32_t client
+) ;
+#define CyAnUsbSetStall(h, ep, cb, client) \
+ CyAsUsbSetStall_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
+
+/* Async version of set stall */
+extern CyAnReturnStatus_t
+CyAnUsbSetStallEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnFunctionCallback cb,
+ uint32_t client
+) ;
+#define CyAnUsbSetStallEX(h, ep, cb, client) \
+ CyAsUsbSetStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
+
+/*Sync version of clear stall */
+EXTERN CyAnReturnStatus_t
+CyAnUsbClearStall(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbClearStall(h, ep, cb, client) \
+ CyAsUsbClearStall_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
+
+/*Sync version of clear stall */
+extern CyAnReturnStatus_t
+CyAnUsbClearStallEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbClearStallEX(h, ep, cb, client) \
+ CyAsUsbClearStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync get stall */
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetStall(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool * stall_p
+ ) ;
+#define CyAnUsbGetStall(handle, ep, stall_p) \
+ CyAsUsbGetStall((CyAsDeviceHandle)(handle), (CyAsEndPointNumber_t)(ep), (stall_p), 0, 0)
+
+/* Async get stall */
+extern CyAnReturnStatus_t
+CyAnUsbGetStallEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool * stall_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbGetStallEX(h, ep, stall_p, cb, client) \
+ CyAsUsbGetStall((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (stall_p), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of Set Nak */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetNak(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbFunctionCallback cb,
+ uint32_t client
+) ;
+
+#define CyAnUsbSetNak(h, ep, cb, client) \
+ CyAsUsbSetNak_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
+
+/* Async version of Set Nak */
+extern CyAnReturnStatus_t
+CyAnUsbSetNakEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnFunctionCallback cb,
+ uint32_t client
+) ;
+#define CyAnUsbSetNakEX(h, ep, cb, client) \
+ CyAsUsbSetNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync version of clear nak */
+EXTERN CyAnReturnStatus_t
+CyAnUsbClearNak(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnUsbFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbClearNak(h, ep, cb, client) \
+ CyAsUsbClearNak_dep((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsUsbFunctionCallback)(cb), (client))
+
+/* Sync version of clear nak */
+extern CyAnReturnStatus_t
+CyAnUsbClearNakEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbClearNakEX(h, ep, cb, client) \
+ CyAsUsbClearNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync Get NAK */
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetNak(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool * nak_p
+) ;
+#define CyAnUsbGetNak(handle, ep, nak_p) \
+ CyAsUsbGetNak((CyAsDeviceHandle)(handle), (CyAsEndPointNumber_t)(ep), (nak_p), 0, 0)
+
+/* Async Get NAK */
+EXTERN CyAnReturnStatus_t
+CyAnUsbGetNakEX(
+ CyAnDeviceHandle handle,
+ CyAnEndPointNumber_t ep,
+ CyBool * nak_p,
+ CyAnFunctionCallback cb,
+ uint32_t client
+) ;
+#define CyAnUsbGetNakEX(h, ep, nak_p, cb, client) \
+ CyAsUsbGetNak((CyAsDeviceHandle)(h), (CyAsEndPointNumber_t)(ep), (nak_p), (CyAsFunctionCallback)(cb), (client))
+
+/* Sync remote wakup */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSignalRemoteWakeup(
+ CyAnDeviceHandle handle
+ ) ;
+#define CyAnUsbSignalRemoteWakeup(handle) CyAsUsbSignalRemoteWakeup((CyAsDeviceHandle)(handle), 0, 0)
+
+/* Async remote wakup */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSignalRemoteWakeupEX(
+ CyAnDeviceHandle handle,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbSignalRemoteWakeupEX(h, cb, client) \
+ CyAsUsbSignalRemoteWakeup((CyAsDeviceHandle)(h), (CyAsFunctionCallback)(cb), (client))
+
+/* Only version of SetMSReportThreshold */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSetMSReportThreshold(
+ CyAnDeviceHandle handle,
+ uint32_t wr_sectors,
+ uint32_t rd_sectors,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbSetMSReportThreshold(h, wr_cnt, rd_cnt, cb, client) \
+ CyAsUsbSetMSReportThreshold((CyAsDeviceHandle)(h), wr_cnt, rd_cnt, (CyAsFunctionCallback)(cb), (client))
+
+/* Select storage partitions to be enumerated. */
+EXTERN CyAnReturnStatus_t
+CyAnUsbSelectMSPartitions (
+ CyAnDeviceHandle handle,
+ CyAnMediaType media,
+ uint32_t device,
+ CyAnUsbMSType_t type,
+ CyAnFunctionCallback cb,
+ uint32_t client
+ ) ;
+#define CyAnUsbSelectMSPartitions(h, media, dev, type, cb, client) \
+ CyAsUsbSelectMSPartitions_dep((CyAsDeviceHandle)(h), (CyAsMediaType)(media), (dev), \
+ (CyAsUsbMSType_t)(type), (CyAsFunctionCallback)(cb), (client))
+
+#include "cyas_cplus_end.h"
+#endif /*__doxygen__*/
+#endif /*_INCLUDED_CYANUSB_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyas_cplus_end.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,10 @@
+/*
+ * This file is included at the end of other include files. It basically turns off
+ * the C++ specific code words that insure this code is seen as C code even within
+ * a C++ compiler.
+ *
+ */
+
+#ifdef __cplusplus
+}
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyas_cplus_start.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,11 @@
+/*
+ * This file is included after all other headers files, but before any other
+ * definitions in the file. It basically insures that the definitions within
+ * the file are seen as C defintions even when compiled by a C++ compiler.
+ */
+
+#ifdef __cplusplus
+
+extern "C" {
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasch9.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,325 @@
+/* Cypress West Bridge API header file (cyasch9.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASCH9_H_
+#define _INCLUDED_CYASCH9_H_
+
+/*
+ * These chapter 9 USB 2.0 constants are provided for convenience
+ */
+
+#define CY_CH9_SETUP_TYPE_MASK (0x60) /* Used to mask off request type */
+#define CY_CH9_SETUP_STANDARD_REQUEST (0) /* Standard Request */
+#define CY_CH9_SETUP_CLASS_REQUEST (0x20) /* Class Request */
+#define CY_CH9_SETUP_VENDOR_REQUEST (0x40) /* Vendor Request */
+#define CY_CH9_SETUP_RESERVED_REQUEST (0x60) /* Reserved or illegal request */
+
+#define CY_CH9_SETUP_DEST_MASK (0x1f) /* Used to mask off the dest of the request */
+#define CY_CH9_SETUP_DEST_DEVICE (0)
+#define CY_CH9_SETUP_DEST_INTERFACE (1)
+#define CY_CH9_SETUP_DEST_ENDPOINT (2)
+#define CY_CH9_SETUP_DEST_OTHER (3)
+
+#define CY_CH9_SC_GET_STATUS (0x00) /* Setup command: Get Status */
+#define CY_CH9_SC_CLEAR_FEATURE (0x01) /* Setup command: Clear Feature */
+#define CY_CH9_SC_RESERVED (0x02) /* Setup command: Reserved */
+#define CY_CH9_SC_SET_FEATURE (0x03) /* Setup command: Set Feature */
+#define CY_CH9_SC_SET_ADDRESS (0x05) /* Setup command: Set Address */
+#define CY_CH9_SC_GET_DESCRIPTOR (0x06) /* Setup command: Get Descriptor */
+#define CY_CH9_SC_SET_DESCRIPTOR (0x07) /* Setup command: Set Descriptor */
+#define CY_CH9_SC_GET_CONFIGURATION (0x08) /* Setup command: Get Configuration */
+#define CY_CH9_SC_SET_CONFIGURATION (0x09) /* Setup command: Set Configuration */
+#define CY_CH9_SC_GET_INTERFACE (0x0a) /* Setup command: Get Interface */
+#define CY_CH9_SC_SET_INTERFACE (0x0b) /* Setup command: Set Interface */
+#define CY_CH9_SC_SYNC_FRAME (0x0c) /* Setup command: Sync Frame */
+#define CY_CH9_SC_ANCHOR_LOAD (0xa0) /* Setup command: Anchor load */
+
+#define CY_CH9_GD_DEVICE (0x01) /* Get descriptor: Device */
+#define CY_CH9_GD_CONFIGURATION (0x02) /* Get descriptor: Configuration */
+#define CY_CH9_GD_STRING (0x03) /* Get descriptor: String */
+#define CY_CH9_GD_INTERFACE (0x04) /* Get descriptor: Interface */
+#define CY_CH9_GD_ENDPOINT (0x05) /* Get descriptor: Endpoint */
+#define CY_CH9_GD_DEVICE_QUALIFIER (0x06) /* Get descriptor: Device Qualifier */
+#define CY_CH9_GD_OTHER_SPEED_CONFIGURATION (0x07) /* Get descriptor: Other Configuration */
+#define CY_CH9_GD_INTERFACE_POWER (0x08) /* Get descriptor: Interface Power */
+#define CY_CH9_GD_HID (0x21) /* Get descriptor: HID */
+#define CY_CH9_GD_REPORT (0x22) /* Get descriptor: Report */
+
+#define CY_CH9_GS_DEVICE (0x80) /* Get Status: Device */
+#define CY_CH9_GS_INTERFACE (0x81) /* Get Status: Interface */
+#define CY_CH9_GS_ENDPOINT (0x82) /* Get Status: End Point */
+
+#define CY_CH9_FT_DEVICE (0x00) /* Feature: Device */
+#define CY_CH9_FT_ENDPOINT (0x02) /* Feature: End Point */
+
+/*
+ * Language Codes
+ */
+
+#define CY_CH9_LANGID_AFRIKAANS (0x0436)
+#define CY_CH9_LANGID_ALBANIAN (0x041c)
+#define CY_CH9_LANGID_ARABIC_SAUDI_ARABIA (0x0401)
+#define CY_CH9_LANGID_ARABIC_IRAQ (0x0801)
+#define CY_CH9_LANGID_ARABIC_EGYPT (0x0c01)
+#define CY_CH9_LANGID_ARABIC_LIBYA (0x1001)
+#define CY_CH9_LANGID_ARABIC_ALGERIA (0x1401)
+#define CY_CH9_LANGID_ARABIC_MOROCCO (0x1801)
+#define CY_CH9_LANGID_ARABIC_TUNISIA (0x1c01)
+#define CY_CH9_LANGID_ARABIC_OMAN (0x2001)
+#define CY_CH9_LANGID_ARABIC_YEMEN (0x2401)
+#define CY_CH9_LANGID_ARABIC_SYRIA (0x2801)
+#define CY_CH9_LANGID_ARABIC_JORDAN (0x2c01)
+#define CY_CH9_LANGID_ARABIC_LEBANON (0x3001)
+#define CY_CH9_LANGID_ARABIC_KUWAIT (0x3401)
+#define CY_CH9_LANGID_ARABIC_UAE (0x3801)
+#define CY_CH9_LANGID_ARABIC_BAHRAIN (0x3c01)
+#define CY_CH9_LANGID_ARABIC_QATAR (0x4001)
+#define CY_CH9_LANGID_ARMENIAN (0x042b)
+#define CY_CH9_LANGID_ASSAMESE (0x044d)
+#define CY_CH9_LANGID_AZERI_LATIN (0x042c)
+#define CY_CH9_LANGID_AZERI_CYRILLIC (0x082c)
+#define CY_CH9_LANGID_BASQUE (0x042d)
+#define CY_CH9_LANGID_BELARUSSIAN (0x0423)
+#define CY_CH9_LANGID_BENGALI (0x0445)
+#define CY_CH9_LANGID_BULGARIAN (0x0402)
+#define CY_CH9_LANGID_BURMESE (0x0455)
+#define CY_CH9_LANGID_CATALAN (0x0403)
+#define CY_CH9_LANGID_CHINESE_TAIWAN (0x0404)
+#define CY_CH9_LANGID_CHINESE_PRC (0x0804)
+#define CY_CH9_LANGID_CHINESE_HONG_KONG_SAR_PRC (0x0c04)
+#define CY_CH9_LANGID_CHINESE_SINGAPORE (0x1004)
+#define CY_CH9_LANGID_CHINESE_MACAU_SAR (0x1404)
+#define CY_CH9_LANGID_CROATIAN (0x041a)
+#define CY_CH9_LANGID_CZECH (0x0405)
+#define CY_CH9_LANGID_DANISH (0x0406)
+#define CY_CH9_LANGID_DUTCH_NETHERLANDS (0x0413)
+#define CY_CH9_LANGID_DUTCH_BELGIUM (0x0813)
+#define CY_CH9_LANGID_ENGLISH_UNITED_STATES (0x0409)
+#define CY_CH9_LANGID_ENGLISH_UNITED_KINGDON (0x0809)
+#define CY_CH9_LANGID_ENGLISH_AUSTRALIAN (0x0c09)
+#define CY_CH9_LANGID_ENGLISH_CANADIAN (0x1009)
+#define CY_CH9_LANGID_ENGLISH_NEW Zealand (0x1409)
+#define CY_CH9_LANGID_ENGLISH_IRELAND (0x1809)
+#define CY_CH9_LANGID_ENGLISH_SOUTH Africa (0x1c09)
+#define CY_CH9_LANGID_ENGLISH_JAMAICA (0x2009)
+#define CY_CH9_LANGID_ENGLISH_CARIBBEAN (0x2409)
+#define CY_CH9_LANGID_ENGLISH_BELIZE (0x2809)
+#define CY_CH9_LANGID_ENGLISH_TRINIDAD (0x2c09)
+#define CY_CH9_LANGID_ENGLISH_ZIMBABWE (0x3009)
+#define CY_CH9_LANGID_ENGLISH_PHILIPPINES (0x3409)
+#define CY_CH9_LANGID_ESTONIAN (0x0425)
+#define CY_CH9_LANGID_FAEROESE (0x0438)
+#define CY_CH9_LANGID_FARSI (0x0429)
+#define CY_CH9_LANGID_FINNISH (0x040b)
+#define CY_CH9_LANGID_FRENCH_STANDARD (0x040c)
+#define CY_CH9_LANGID_FRENCH_BELGIAN (0x080c)
+#define CY_CH9_LANGID_FRENCH_CANADIAN (0x0c0c)
+#define CY_CH9_LANGID_FRENCH_SWITZERLAND (0x100c)
+#define CY_CH9_LANGID_FRENCH_LUXEMBOURG (0x140c)
+#define CY_CH9_LANGID_FRENCH_MONACO (0x180c)
+#define CY_CH9_LANGID_GEORGIAN (0x0437)
+#define CY_CH9_LANGID_GERMAN_STANDARD (0x0407)
+#define CY_CH9_LANGID_GERMAN_SWITZERLAND (0x0807)
+#define CY_CH9_LANGID_GERMAN_AUSTRIA (0x0c07)
+#define CY_CH9_LANGID_GERMAN_LUXEMBOURG (0x1007)
+#define CY_CH9_LANGID_GERMAN_LIECHTENSTEIN (0x1407)
+#define CY_CH9_LANGID_GREEK (0x0408)
+#define CY_CH9_LANGID_GUJARATI (0x0447)
+#define CY_CH9_LANGID_HEBREW (0x040d)
+#define CY_CH9_LANGID_HINDI (0x0439)
+#define CY_CH9_LANGID_HUNGARIAN (0x040e)
+#define CY_CH9_LANGID_ICELANDIC (0x040f)
+#define CY_CH9_LANGID_INDONESIAN (0x0421)
+#define CY_CH9_LANGID_ITALIAN_STANDARD (0x0410)
+#define CY_CH9_LANGID_ITALIAN_SWITZERLAND (0x0810)
+#define CY_CH9_LANGID_JAPANESE (0x0411)
+#define CY_CH9_LANGID_KANNADA (0x044b)
+#define CY_CH9_LANGID_KASHMIRI_INDIA (0x0860)
+#define CY_CH9_LANGID_KAZAKH (0x043f)
+#define CY_CH9_LANGID_KONKANI (0x0457)
+#define CY_CH9_LANGID_KOREAN (0x0412)
+#define CY_CH9_LANGID_KOREAN_JOHAB (0x0812)
+#define CY_CH9_LANGID_LATVIAN (0x0426)
+#define CY_CH9_LANGID_LITHUANIAN (0x0427)
+#define CY_CH9_LANGID_LITHUANIAN_CLASSIC (0x0827)
+#define CY_CH9_LANGID_MACEDONIAN (0x042f)
+#define CY_CH9_LANGID_MALAY_MALAYSIAN (0x043e)
+#define CY_CH9_LANGID_MALAY_BRUNEI_DARUSSALAM (0x083e)
+#define CY_CH9_LANGID_MALAYALAM (0x044c)
+#define CY_CH9_LANGID_MANIPURI (0x0458)
+#define CY_CH9_LANGID_MARATHI (0x044e)
+#define CY_CH9_LANGID_NEPALI_INDIA (0x0861)
+#define CY_CH9_LANGID_NORWEGIAN_BOKMAL (0x0414)
+#define CY_CH9_LANGID_NORWEGIAN_NYNORSK (0x0814)
+#define CY_CH9_LANGID_ORIYA (0x0448)
+#define CY_CH9_LANGID_POLISH (0x0415)
+#define CY_CH9_LANGID_PORTUGUESE_BRAZIL (0x0416)
+#define CY_CH9_LANGID_PORTUGUESE_STANDARD (0x0816)
+#define CY_CH9_LANGID_PUNJABI (0x0446)
+#define CY_CH9_LANGID_ROMANIAN (0x0418)
+#define CY_CH9_LANGID_RUSSIAN (0x0419)
+#define CY_CH9_LANGID_SANSKRIT (0x044f)
+#define CY_CH9_LANGID_SERBIAN_CYRILLIC (0x0c1a)
+#define CY_CH9_LANGID_SERBIAN_LATIN (0x081a)
+#define CY_CH9_LANGID_SINDHI (0x0459)
+#define CY_CH9_LANGID_SLOVAK (0x041b)
+#define CY_CH9_LANGID_SLOVENIAN (0x0424)
+#define CY_CH9_LANGID_SPANISH_TRADITIONAL_SORT (0x040a)
+#define CY_CH9_LANGID_SPANISH_MEXICAN (0x080a)
+#define CY_CH9_LANGID_SPANISH_MODERN_SORT (0x0c0a)
+#define CY_CH9_LANGID_SPANISH_GUATEMALA (0x100a)
+#define CY_CH9_LANGID_SPANISH_COSTA_RICA (0x140a)
+#define CY_CH9_LANGID_SPANISH_PANAMA (0x180a)
+#define CY_CH9_LANGID_SPANISH_DOMINICAN Republic (0x1c0a)
+#define CY_CH9_LANGID_SPANISH_VENEZUELA (0x200a)
+#define CY_CH9_LANGID_SPANISH_COLOMBIA (0x240a)
+#define CY_CH9_LANGID_SPANISH_PERU (0x280a)
+#define CY_CH9_LANGID_SPANISH_ARGENTINA (0x2c0a)
+#define CY_CH9_LANGID_SPANISH_ECUADOR (0x300a)
+#define CY_CH9_LANGID_SPANISH_CHILE (0x340a)
+#define CY_CH9_LANGID_SPANISH_URUGUAY (0x380a)
+#define CY_CH9_LANGID_SPANISH_PARAGUAY (0x3c0a)
+#define CY_CH9_LANGID_SPANISH_BOLIVIA (0x400a)
+#define CY_CH9_LANGID_SPANISH_EL_SALVADOR (0x440a)
+#define CY_CH9_LANGID_SPANISH_HONDURAS (0x480a)
+#define CY_CH9_LANGID_SPANISH_NICARAGUA (0x4c0a)
+#define CY_CH9_LANGID_SPANISH_PUERTO Rico (0x500a)
+#define CY_CH9_LANGID_SUTU (0x0430)
+#define CY_CH9_LANGID_SWAHILI_KENYA (0x0441)
+#define CY_CH9_LANGID_SWEDISH (0x041d)
+#define CY_CH9_LANGID_SWEDISH_FINLAND (0x081d)
+#define CY_CH9_LANGID_TAMIL (0x0449)
+#define CY_CH9_LANGID_TATAR_TATARSTAN (0x0444)
+#define CY_CH9_LANGID_TELUGU (0x044a)
+#define CY_CH9_LANGID_THAI (0x041e)
+#define CY_CH9_LANGID_TURKISH (0x041f)
+#define CY_CH9_LANGID_UKRAINIAN (0x0422)
+#define CY_CH9_LANGID_URDU_PAKISTAN (0x0420)
+#define CY_CH9_LANGID_URDU_INDIA (0x0820)
+#define CY_CH9_LANGID_UZBEK_LATIN (0x0443)
+#define CY_CH9_LANGID_UZBEK_CYRILLIC (0x0843)
+#define CY_CH9_LANGID_VIETNAMESE (0x042a)
+
+#pragma pack(push, 1)
+typedef struct CyCh9DeviceDesc
+{
+ uint8_t bLength ;
+ uint8_t bDescriptorType ;
+ uint16_t bcdUSB ;
+ uint8_t bDeviceClass ;
+ uint8_t bDeviceSubClass ;
+ uint8_t bDeviceProtocol ;
+ uint8_t bMaxPacketSize0 ;
+ uint16_t idVendor ;
+ uint16_t idProduct ;
+ uint16_t bcdDevice ;
+ uint8_t iManufacturer ;
+ uint8_t iProduct;
+ uint8_t iSerialNumber;
+ uint8_t bNumConfigurations;
+} CyCh9DeviceDesc ;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct CyCh9DeviceQualifierDesc
+{
+ uint8_t bLength ;
+ uint8_t bDescriptorType ;
+ uint16_t bcdUSB ;
+ uint8_t bDeviceClass ;
+ uint8_t bDeviceSubClass ;
+ uint8_t bDeviceProtocol ;
+ uint8_t bMaxPacketSize0 ;
+ uint8_t bNumConfigurations;
+ uint8_t reserved ;
+} CyCh9DeviceQualifierDesc ;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct CyCh9ConfigurationDesc
+{
+ uint8_t bLength ;
+ uint8_t bDescriptorType ;
+ uint16_t wTotalLength ;
+ uint8_t bNumInterfaces ;
+ uint8_t bConfigurationValue ;
+ uint8_t iConfiguration ;
+ uint8_t bmAttributes ;
+ uint8_t bMaxPower ;
+} CyCh9ConfigurationDesc ;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct CyCh9InterfaceDesc
+{
+ uint8_t bLength ;
+ uint8_t bDescriptorType ;
+ uint8_t bInterfaceNumber ;
+ uint8_t bAlternateSetting ;
+ uint8_t bNumEndpoints ;
+ uint8_t bInterfaceClass ;
+ uint8_t bInterfaceSubClass ;
+ uint8_t bInterfaceProtocol ;
+ uint8_t iInterface ;
+} CyCh9InterfaceDesc ;
+#pragma pack(pop)
+
+#pragma pack(push,1)
+typedef struct CyCh9EndpointDesc
+{
+ uint8_t bLength ;
+ uint8_t bDescriptorType ;
+ uint8_t bEndpointAddress ;
+ uint8_t bmAttributes ;
+ uint16_t wMaxPacketSize ;
+ uint8_t bInterval ;
+} CyCh9EndpointDesc ;
+#pragma pack(pop)
+
+/* Configuration attributes */
+#define CY_CH9_CONFIG_ATTR_RESERVED_BIT7 (0x80)
+#define CY_CH9_CONFIG_ATTR_SELF_POWERED (0x40)
+#define CY_CH9_CONFIG_ATTR_REMOTE_WAKEUP (0x20)
+
+#define CY_CH9_ENDPOINT_DIR_OUT (0)
+#define CY_CH9_ENDPOINT_DIR_IN (0x80)
+#define CY_CH9_MK_EP_ADDR(dir, num) ((dir) | ((num) & 0x0f))
+
+#define CY_CH9_ENDPOINT_ATTR_CONTROL (0)
+#define CY_CH9_ENDPOINT_ATTR_ISOCHRONOUS (1)
+#define CY_CH9_ENDPOINT_ATTR_BULK (2)
+#define CY_CH9_ENDPOINT_ATTR_INTERRUPT (3)
+
+#define CY_CH9_ENDPOINT_ATTR_NO_SYNC (0 << 2)
+#define CY_CH9_ENDPOINT_ATTR_ASYNCHRONOUS (1 << 2)
+#define CY_CH9_ENDPOINT_ATTR_ADAPTIVE (2 << 2)
+#define CY_CH9_ENDPOINT_ATTR_SYNCHRONOUS (3 << 2)
+
+#define CY_CH9_ENDPOINT_ATTR_DATA (0 << 4)
+#define CY_CH9_ENDPOINT_ATTR_FEEDBACK (1 << 4)
+#define CY_CH9_ENDPOINT_ATTR_IMPLICIT_FEEDBACK (2 << 4)
+#define CY_CH9_ENDPOINT_ATTR_RESERVED (3 << 4)
+
+#define CY_CH9_ENDPOINT_PKTSIZE_NONE (0 << 11)
+#define CY_CH9_ENDPOINT_PKTSIZE_ONE (1 << 11)
+#define CY_CH9_ENDPOINT_PKTSIZE_TWO (2 << 11)
+#define CY_CH9_ENDPOINT_PKTSIZE_RESERVED (3 << 11)
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyaserr.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1052 @@
+/* Cypress West Bridge API header file (cyaserr.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASERR_H_
+#define _INCLUDED_CYASERR_H_
+
+/*@@West Bridge Errors
+ Summary
+ This section lists the error codes for West Bridge.
+
+*/
+
+/* Summary
+ The function completed sucessfully
+*/
+#define CY_AS_ERROR_SUCCESS (0)
+
+/* Summary
+ A function trying to acquire a resource was unable to do so.
+
+ Description
+ This code indicates that a resource that the API was trying to claim
+ could not be claimed.
+
+ See Also
+ * CyAsMiscAcquireResource
+ * CyAsStorageClaim
+*/
+#define CY_AS_ERROR_NOT_ACQUIRED (1)
+
+/* Summary
+ A function trying to acquire a resource was unable to do so.
+
+ Description
+ The West Bridge API provides the capability to assign the storage media to
+ either the West Bridge device or the USB port. This error indicates the
+ P port was trying to release a storage media and was not able to do
+ so. This generally means it was not owned by the P port processor.
+
+ See Also
+ * CyAsStorageRelease
+*/
+#define CY_AS_ERROR_NOT_RELEASED (2)
+
+/* Summary
+ The West Bridge firmware is not loaded.
+
+ Description
+ Most of the API functions that are part of the West Bridge API rely on firmware
+ running on the West Bridge device. This error code is returned when one of
+ these functions is called and the firmware has not yet been loaded.
+
+ See Also
+ * CyAsMiscGetFirmwareVersion
+ * CyAsMiscReset
+ * CyAsMiscAcquireResource
+ * CyAsMiscReleaseResource
+ * CyAsMiscSetTraceLevel
+ * CyAsStorageStart
+ * CyAsStorageStop
+ * CyAsStorageRegisterCallback
+ * CyAsStorageClaim
+ * CyAsStorageRelease
+ * CyAsStorageQueryMedia
+ * CyAsStorageQueryDevice
+ * CyAsStorageQueryUnit
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_NO_FIRMWARE (3)
+
+/* Summary
+ A timeout occurred waiting on a response from the West Bridge device
+
+ Description
+ When requests are made of the West Bridge device, a response is expected
+ within a given timeframe. If a response is not recevied within the
+ given timeframe, a timeout error occurs.
+*/
+#define CY_AS_ERROR_TIMEOUT (4)
+
+/* Summary
+ A request to download firmware was made while not in the CONFIG mode
+
+ Description
+ Firmware is downloaded via the CyAsMiscDownloadFirmware() function. This
+ function can only be called while in the CONFIG mode. This error indicates
+ that the CyAsMiscDownloadFirmware() call was made while not in the CONFIG
+ mode.
+
+ See Also
+ * CyAsMiscDownloadFirmware
+*/
+#define CY_AS_ERROR_NOT_IN_CONFIG_MODE (5)
+
+/* Summary
+ This error is returned if the firmware size specified is too invalid.
+
+ Description
+ If the size of the firmware to be downloaded into West Bridge is invalid, this
+ error is issued. Invalid firmware sizes are those greater than 24K or a
+ size of zero.
+
+ See Also
+ * CyAsMiscDownloadFirmare
+*/
+#define CY_AS_ERROR_INVALID_SIZE (6)
+
+/* Summary
+ This error is returned if a request is made to acquire a resource that has
+ already been acquired.
+
+ Description
+ This error is returned if a request is made to acquire a resource that has
+ already been acquired.
+
+ See Also
+ * CyAsMiscAcquireResource
+ * CyAsMiscReleaseResource
+*/
+#define CY_AS_ERROR_RESOURCE_ALREADY_OWNED (7)
+
+/* Summary
+ This error is returned if a request is made to release a resource that has
+ not previously been acquired.
+
+ Description
+ This error is returned if a request is made to release a resource that has
+ not previously been acquired.
+
+ See Also
+ * CyAsMiscAcquireResource
+ * CyAsMiscReleaseResource
+*/
+#define CY_AS_ERROR_RESOURCE_NOT_OWNED (8)
+
+/* Summary
+ This error is returned when a request is made for a media that does not exist
+
+ Description
+ This error is returned when a request is made that references a storage media that
+ does not exist. This error is returned when the storage media is not present in
+ the current system, or if the media value given is not valid.
+
+ See Also
+ * CyAsMiscSetTraceLevel
+ * CyAsStorageClaim
+ * CyAsStorageRelease
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_NO_SUCH_MEDIA (9)
+
+/* Summary
+ This error is returned when a request is made for a device that does not exist
+
+ Description
+ This error is returned when a request is made that references a storage device
+ that does not exist. This error is returned when the device index is not present
+ in the current system, or if the device index exceeds 15.
+
+ See Also
+ * CyAsMiscSetTraceLevel
+ * CyAsStorageQueryDevice
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_NO_SUCH_DEVICE (10)
+
+/* Summary
+ This error is returned when a request is made for a unit that does not exist
+
+ Description
+ This error is returned when a request is made that references a storage unit
+ that does not exist. This error is returned when the unit index is not present
+ in the current system, or if the unit index exceeds 255.
+
+ See Also
+ * CyAsMiscSetTraceLevel
+ * CyAsStorageQueryDevice
+ * CyAsStorageQueryUnit
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_NO_SUCH_UNIT (11)
+
+/* Summary
+ This error is returned when a request is made for a block that does not exist
+
+ Description
+ This error is returned when a request is made that references a storage block
+ that does not exist. This error is returned when the block address reference
+ an address beyond the end of the unit selected.
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_INVALID_BLOCK (12)
+
+/* Summary
+ This error is returned when an invalid trace level is set.
+
+ Description
+ This error is returned when the trace level request is greater
+ than three.
+
+ See Also
+ * CyAsMiscSetTraceLevel
+*/
+#define CY_AS_ERROR_INVALID_TRACE_LEVEL (13)
+
+/* Summary
+ This error is returned when West Bridge is already in the standby state
+ and an attempt is made to put West Bridge into this state again.
+
+ Description
+ This error is returned when West Bridge is already in the standby state
+ and an attempt is made to put West Bridge into this state again.
+
+ See Also
+ * CyAsMiscEnterStandby
+*/
+#define CY_AS_ERROR_ALREADY_STANDBY (14)
+
+/* Summary
+ This error is returned when the API needs to set a pin on the
+ West Bridge device, but this is not supported by the underlying HAL
+ layer.
+
+ Description
+ This error is returned when the API needs to set a pin on the
+ West Bridge device, but this is not supported by the underlying HAL
+ layer.
+
+ See Also
+ * CyAsMiscEnterStandby
+ * CyAsMiscLeaveStandby
+*/
+#define CY_AS_ERROR_SETTING_WAKEUP_PIN (15)
+
+/* Summary
+ This error is returned when a module is being started that has
+ already been started.
+
+ Description
+ This error is returned when a module is being started and that module
+ has already been started. This error does not occur with the CyAsStorageStart()
+ or CyAsUsbStart() functions as the storage and USB modules are reference counted.
+
+ Note
+ At the current time, this error is returned by module internal to the API but
+ not returned by any of the API functions.
+*/
+#define CY_AS_ERROR_ALREADY_RUNNING (16)
+
+/* Summary
+ This error is returned when a module is being stopped that has
+ already been stopped.
+
+ Description
+ This error is returned when a module is being stopped and that module
+ has already been stopped. This error does not occur with the CyAsStorageStop()
+ or CyAsUsbStop() functions as the storage and USB modules are reference counted.
+
+ Note
+ At the current time, this error is returned by module internal to the API but
+ not returned by any of the API functions.
+*/
+
+#define CY_AS_ERROR_NOT_RUNNING (17)
+
+/* Summary
+ This error is returned when the caller tries to claim a media that has already been
+ claimed.
+
+ Description
+ This error is returned when the caller tries to claim a media that has already been
+ claimed.
+
+ See Also
+ * CyAsStorageClaim
+*/
+#define CY_AS_ERROR_MEDIA_ALREADY_CLAIMED (18)
+
+/* Summary
+ This error is returned when the caller tries to release a media that has already been
+ released.
+
+ Description
+ This error is returned when the caller tries to release a media that has already been
+ released.
+
+ See Also
+ * CyAsStorageRelease
+*/
+#define CY_AS_ERROR_MEDIA_NOT_CLAIMED (19)
+
+/* Summary
+ This error is returned when canceling trying to cancel an asynchronous operation when
+ an async operation is not pending.
+
+ Description
+ This error is returned when a call is made to a function to cancel an asynchronous operation
+ and there is no asynchronous operation pending.
+
+ See Also
+ * CyAsStorageCancelAsync
+ * CyAsUsbCancelAsync
+*/
+#define CY_AS_ERROR_NO_OPERATION_PENDING (20)
+
+/* Summary
+ This error is returned when an invalid endpoint number is provided to an API call.
+
+ Description
+ This error is returned when an invalid endpoint number is specified in an API call. The
+ endpoint number may be invalid because it is greater than 15, or because it was a reference
+ to an endpoint that is invalid for West Bridge (2, 4, 6, or 8).
+
+ See Also
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbGetEndPointConfig
+ * CyAsUsbReadData
+ * CyAsUsbWriteData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+ * CyAsUsbSetStall
+ * CyAsUsbGetStall
+*/
+#define CY_AS_ERROR_INVALID_ENDPOINT (21)
+
+/* Summary
+ This error is returned when an invalid descriptor type
+ is specified in an API call.
+
+ Description
+ This error is returned when an invalid descriptor type
+ is specified in an API call.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+*/
+#define CY_AS_ERROR_INVALID_DESCRIPTOR (22)
+
+/* Summary
+ This error is returned when an invalid descriptor index
+ is specified in an API call.
+
+ Description
+ This error is returned when an invalid descriptor index
+ is specified in an API call.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+*/
+#define CY_AS_ERROR_BAD_INDEX (23)
+
+/* Summary
+ This error is returned if trying to set a USB descriptor
+ when in the P port enumeration mode.
+
+ Description
+ This error is returned if trying to set a USB descriptor
+ when in the P port enumeration mode.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+*/
+#define CY_AS_ERROR_BAD_ENUMERATION_MODE (24)
+
+/* Summary
+ This error is returned when the endpoint configuration specified
+ is not valid.
+
+ Description
+ This error is returned when the endpoint configuration specified
+ is not valid.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+ * CyAsUsbCommitConfig
+*/
+#define CY_AS_ERROR_INVALID_CONFIGURATION (25)
+
+/* Summary
+ This error is returned when the API cannot verify it is connected
+ to an West Bridge device.
+
+ Description
+ When the API is initialized, the API tries to read the ID register from
+ the West Bridge device. The value from this ID register should match the
+ value expected before communications with West Bridge are established. This
+ error means that the contents of the ID register cannot be verified.
+
+ See Also
+ * CyAsMiscConfigureDevice
+*/
+#define CY_AS_ERROR_NO_ANTIOCH (26)
+
+/* Summary
+ This error is returned when an API function is called and CyAsMiscConfigureDevice
+ has not been called to configure West Bridge for the current environment.
+
+ Description
+ This error is returned when an API function is called and CyAsMiscConfigureDevice
+ has not been called to configure West Bridge for the current environment.
+
+ See Also
+ * Almost all API function
+*/
+#define CY_AS_ERROR_NOT_CONFIGURED (27)
+
+/* Summary
+ This error is returned when West Bridge cannot allocate memory required for
+ internal API operations.
+
+ Description
+ This error is returned when West Bridge cannot allocate memory required for
+ internal API operations.
+
+ See Also
+ * Almost all API functoins
+*/
+#define CY_AS_ERROR_OUT_OF_MEMORY (28)
+
+/* Summary
+ This error is returned when a module is being started that has
+ already been started.
+
+ Description
+ This error is returned when a module is being started and that module
+ has already been started. This error does not occur with the CyAsStorageStart()
+ or CyAsUsbStart() functions as the storage and USB modules are reference counted.
+
+ Note
+ At the current time, this error is returned by module internal to the API but
+ not returned by any of the API functions.
+*/
+#define CY_AS_ERROR_NESTED_SLEEP (29)
+
+/* Summary
+ This error is returned when an operation is attempted on an endpoint that has
+ been disabled.
+
+ Description
+ This error is returned when an operation is attempted on an endpoint that has
+ been disabled.
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbWriteData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+*/
+#define CY_AS_ERROR_ENDPOINT_DISABLED (30)
+
+/* Summary
+ This error is returned when a call is made to an API function when the device is in
+ standby.
+
+ Description
+ When the West Bridge device is in standby, the only two API functions that can be called
+ are CyAsMiscInStandby() and CyAsMiscLeaveStandby(). Calling any other API function
+ will result in this error.
+
+ See Also
+*/
+#define CY_AS_ERROR_IN_STANDBY (31)
+
+/* Summary
+ This error is returned when an API call is made with an invalid handle value.
+
+ Description
+ This error is returned when an API call is made with an invalid handle value.
+
+ See Also
+*/
+#define CY_AS_ERROR_INVALID_HANDLE (32)
+
+/* Summary
+ This error is returned when an invalid response is returned from the West Bridge device.
+
+ Description
+ Many of the API calls result in requests made to the West Bridge device. This error occurs
+ when the response from West Bridge is invalid and generally indicates that the West Bridge device
+ should be reset.
+
+ See Also
+*/
+#define CY_AS_ERROR_INVALID_RESPONSE (33)
+
+/* Summary
+ This error is returned from the callback function for any asynchronous read or write
+ request that is canceled.
+
+ Description
+ When asynchronous requests are canceled, this error is passed to the callback function
+ associated with the request to indicate that the request has been canceled
+
+ See Also
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+ * CyAsStorageCancelAsync
+ * CyAsUsbCancelAsync
+*/
+#define CY_AS_ERROR_CANCELED (34)
+
+/* Summary
+ This error is returned when the call to create sleep channel fails
+ in the HAL layer.
+
+ Description
+ This error is returned when the call to create sleep channel fails
+ in the HAL layer.
+
+ See Also
+ * CyAsMiscConfigureDevice
+*/
+#define CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED (35)
+
+/* Summary
+ This error is returned when the call to CyAsMiscLeaveStandby
+ is made and the device is not in standby.
+
+ Description
+ This error is returned when the call to CyAsMiscLeaveStandby
+ is made and the device is not in standby.
+
+ See Also
+*/
+#define CY_AS_ERROR_NOT_IN_STANDBY (36)
+
+/* Summary
+ This error is returned when the call to destroy sleep channel fails
+ in the HAL layer.
+
+ Description
+ This error is returned when the call to destroy sleep channel fails
+ in the HAL layer.
+
+ See Also
+ * CyAsMiscDestroyDevice
+*/
+#define CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED (37)
+
+/* Summary
+ This error is returned when an invalid resource is specified to a call
+ to CyAsMiscAcquireResource() or CyAsMiscReleaseResource()
+
+ Description
+ This error is returned when an invalid resource is specified to a call
+ to CyAsMiscAcquireResource() or CyAsMiscReleaseResource()
+
+ See Also
+ * CyAsMiscAcquireResource
+ * CyAsMiscReleaseResource
+*/
+#define CY_AS_ERROR_INVALID_RESOURCE (38)
+
+/* Summary
+ This error occurs when an operation is requested on an endpoint that has
+ a currently pending async operation.
+
+ Description
+ There can only be a single asynchronous pending operation on a given endpoint and
+ while the operation is pending on other operation can occur on the endpoint. In
+ addition, the device cannot enter standby while any asynchronous operations are
+ pending.
+
+ See Also
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsUsbReadData
+ * CyAsUsbWriteData
+ * CyAsMiscEnterStandby
+*/
+#define CY_AS_ERROR_ASYNC_PENDING (39)
+
+/* Summary
+ This error is returned when a call to CyAsStorageCancelAsync() or
+ CyAsUsbCancelAsync() is made when no asynchronous request is pending.
+
+ Description
+ This error is returned when a call to CyAsStorageCancelAsync() or
+ CyAsUsbCancelAsync() is made when no asynchronous request is pending.
+
+ See Also
+ * CyAsStorageCancelAsync
+ * CyAsUsbCancelAsync
+*/
+#define CY_AS_ERROR_ASYNC_NOT_PENDING (40)
+
+/* Summary
+ This error is returned when a request is made to put the West Bridge device
+ into standby mode while the USB stack is still active.
+
+ Description
+ This error is returned when a request is made to put the West Bridge device
+ into standby mode while the USB stack is still active. You must call the
+ function CyAsUsbStop() in order to shut down the USB stack in order to go
+ into the standby mode.
+
+ See Also
+ * CyAsMiscEnterStandby
+*/
+#define CY_AS_ERROR_USB_RUNNING (41)
+
+/* Summary
+ A request for in the wrong direction was issued on an endpoint.
+
+ Description
+ This error is returned when a write is attempted on an OUT endpoint or
+ a read is attempted on an IN endpoint.
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbWriteData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+*/
+#define CY_AS_ERROR_USB_BAD_DIRECTION (42)
+
+/* Summary
+ An invalid request was received
+
+ Description
+ This error is isused if an invalid request is issued.
+*/
+#define CY_AS_ERROR_INVALID_REQUEST (43)
+
+/* Summary
+ An ACK request was requested while no setup packet was pending.
+
+ Description
+ This error is issued if CyAsUsbAckSetupPacket() is called when no setup packet is
+ pending.
+*/
+#define CY_AS_ERROR_NO_SETUP_PACKET_PENDING (44)
+
+/* Summary
+ A call was made to a API function that cannot be called from a callback.
+
+ Description
+ Only asynchronous functions can be called from within West Bridge callbacks.
+ This error results when an invalid function is called from a callback.
+*/
+#define CY_AS_ERROR_INVALID_IN_CALLBACK (45)
+
+/* Summary
+ A call was made to CyAsUsbSetEndPointConfig() before CyAsUsbSetPhysicalConfiguration()
+ was called.
+
+ Description
+ When logical endpoints are configured, you must define the physical endpoint for the
+ logical endpoint being configured. Therefore CyAsUsbSetPhysicalConfiguration() must
+ be called to define the physical endpoints before calling CyAsUsbSetEndPointConfig().
+*/
+#define CY_AS_ERROR_ENDPOINT_CONFIG_NOT_SET (46)
+
+/* Summary
+ The physical endpoint referenced is not valid in the current physical configuration
+
+ Description
+ When logical endpoints are configured, you must define the physical endpoint for the
+ logical endpoint being configured. Given the current physical configuration, the
+ physical endpoint referenced is not valid.
+*/
+#define CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT (47)
+
+/* Summary
+ The data supplied to the CyAsMiscDownloadFirmware() call is not aligned on a
+ WORD (16 bit) boundary.
+
+ Description
+ Many systems have problems with the transfer of data a word at a time when the
+ data is not word aligned. For this reason, we require that the firmware image
+ be aligned on a word boundary and be an even number of bytes. This error is returned
+ if these conditions are not met.
+*/
+#define CY_AS_ERROR_ALIGNMENT_ERROR (48)
+
+/* Summary
+ A call was made to destroy the West Bridge device, but the USB stack or the storage
+ stack was will running.
+
+ Description
+ Before calling CyAsMiscDestroyDevice to destroy an West Bridge device created via a
+ call to CyAsMiscCreateDevice, the USB and STORAGE stacks much be stopped via calls
+ to CyAsUsbStop and CyAsStorageStop. This error indicates that one of these two
+ stacks have not been stopped.
+*/
+#define CY_AS_ERROR_STILL_RUNNING (49)
+
+/* Summary
+ A call was made to the API for a function that is not yet supported.
+
+ Description
+ There are calls that are not yet supported that may be called through the API. This
+ is done to maintain compatibility in the future with the API. This error is returned
+ if you are asking for a capability that does not yet exist.
+*/
+#define CY_AS_ERROR_NOT_YET_SUPPORTED (50)
+
+/* Summary
+ A NULL callback was provided where a non-NULL callback was required
+
+ Description
+ When async IO function are called, a callback is required to indicate that the
+ IO has completed. This callback must be non-NULL.
+*/
+#define CY_AS_ERROR_NULL_CALLBACK (51)
+
+/* Summary
+ This error is returned when a request is made to put the West Bridge device
+ into standby mode while the storage stack is still active.
+
+ Description
+ This error is returned when a request is made to put the West Bridge device
+ into standby mode while the storage stack is still active. You must call the
+ function CyAsStorageStop() in order to shut down the storage stack in order to go
+ into the standby mode.
+
+ See Also
+ * CyAsMiscEnterStandby
+*/
+#define CY_AS_ERROR_STORAGE_RUNNING (52)
+
+/* Summary
+ This error is returned when an operation is attempted that cannot be completed while
+ the USB stack is connected to a USB host.
+
+ Description
+ This error is returned when an operation is attempted that cannot be completed while
+ the USB stack is connected to a USB host. In order to sucessfully complete the
+ desired operation, CyAsUsbDisconnect() must be called to disconnect from the host.
+*/
+#define CY_AS_ERROR_USB_CONNECTED (53)
+
+/* Summary
+ This error is returned when a USB disconnect is attempted and the West Bridge device is
+ not connected.
+
+ Description
+ This error is returned when a USB disconnect is attempted and the West Bridge device is
+ not connected.
+*/
+#define CY_AS_ERROR_USB_NOT_CONNECTED (54)
+
+/* Summary
+ This error is returned when an P2S storage operation attempted and data could not be
+ read or written to the storage media.
+
+ Description
+ This error is returned when an P2S storage operation attempted and data could not be
+ read or written to the storage media. If this error is recevied then a retry can be
+ done.
+*/
+#define CY_AS_ERROR_MEDIA_ACCESS_FAILURE (55)
+
+/* Summary
+ This error is returned when an P2S storage operation attempted and the media is write
+ protected.
+
+ Description
+ This error is returned when an P2S storage operation attempted and the media is write
+ protected.
+*/
+#define CY_AS_ERROR_MEDIA_WRITE_PROTECTED (56)
+
+/* Summary
+ This error is returned when an attempt is made to cancel a request that has
+ already been sent to the West Bridge.
+
+ Description
+ It is not possible to cancel an asynchronous storage read/write operation after
+ the actual data transfer with the West Bridge has started. This error is returned
+ if CyAsStorageCancelAsync is called to cancel such a request.
+ */
+#define CY_AS_ERROR_OPERATION_IN_TRANSIT (57)
+
+/* Summary
+ This error is returned when an invalid parameter is passed to one of the APIs.
+
+ Description
+ Some of the West Bridge APIs are applicable to only specific media types, devices
+ etc. This error code is returned when a API is called with an invalid parameter
+ type.
+ */
+#define CY_AS_ERROR_INVALID_PARAMETER (58)
+
+/* Summary
+ This error is returned if an API is not supported in the current setup.
+
+ Description
+ Some of the West Bridge APIs work only with specific device types or firmware images.
+ This error is returned when such APIs are called when the current device or firmware
+ does not support the invoked API function.
+ */
+#define CY_AS_ERROR_NOT_SUPPORTED (59)
+
+/* Summary
+ This error is returned when a call is made to one of the Storage or
+ USB APIs while the device is in suspend mode.
+
+ Description
+ This error is returned when a call is made to one of the storage or
+ USB APIs while the device is in suspend mode.
+ */
+#define CY_AS_ERROR_IN_SUSPEND (60)
+
+/* Summary
+ This error is returned when the call to CyAsMiscLeaveSuspend
+ is made and the device is not in suspend mode.
+
+ Description
+ This error is returned when the call to CyAsMiscLeaveSuspend
+ is made and the device is not in suspend mode.
+ */
+#define CY_AS_ERROR_NOT_IN_SUSPEND (61)
+
+/* Summary
+ This error is returned when a command that is disabled by USB is called.
+
+ Description
+ The remote wakeup capability should be exercised only if enabled by the USB host.
+ This error is returned when the CyAsUsbSignalRemoteWakeup API is called when the
+ feature has not been enabled by the USB host.
+ */
+#define CY_AS_ERROR_FEATURE_NOT_ENABLED (62)
+
+/* Summary
+ This error is returned when an Async storage read or write is called before a
+ query device call is issued.
+
+ Description
+ In order for the SDK to properly set up a DMA the block size of a given media
+ needs to be known. This is done by making a call to CyAsStorageQueryDevice. This
+ call only needs to be made once per device. If this call is not issued before
+ an Async read or write is issued this error code is returned.
+ */
+#define CY_AS_ERROR_QUERY_DEVICE_NEEDED (63)
+
+/* Summary
+ This error is returned when a call is made to USB or STORAGE Start or Stop before
+ a prior Start or Stop has finished.
+
+ Description
+ The USB and STORAGE start and stop functions can only be called if a prior start
+ or stop function call has fully completed. This means when an async EX call is made
+ you must wait until the callback for that call has been completed before calling
+ start or stop again.
+ */
+#define CY_AS_ERROR_STARTSTOP_PENDING (64)
+
+/* Summary
+ This error is returned when a request is made for a bus that does not exist
+
+ Description
+ This error is returned when a request is made that references a bus number that
+ does not exist. This error is returned when the bus number is not present in
+ the current system, or if the bus number given is not valid.
+
+ See Also
+ * CyAsMiscSetTraceLevel
+ * CyAsStorageClaim
+ * CyAsStorageRelease
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_ERROR_NO_SUCH_BUS (65)
+
+/* Summary
+ This error is returned when the bus corresponding to a media type cannot be resolved.
+
+ Description
+ In some S-Port configurations, the same media type may be supported on multiple
+ buses. In this case, it is not possible to resolve the target address based on the
+ media type. This error indicates that only bus-based addressing is supported
+ in a particular run-time configuration.
+
+ See Also
+ * CyAsMediaType
+ * CyAsBusNumber_t
+ */
+#define CY_AS_ERROR_ADDRESS_RESOLUTION_ERROR (66)
+
+/* Summary
+ This error is returned when an invalid command is passed to the CyAsStorageSDIOSync()
+ function.
+
+ Description
+ This error indiactes an unknown Command type was passed to the SDIO command handler
+ function.
+ */
+
+#define CY_AS_ERROR_INVALID_COMMAND (67)
+
+
+/* Summary
+ This error is returned when an invalid function /uninitialized function is passed to an SDIO
+ function.
+
+ Description
+ This error indiactes an unknown/uninitialized function number was passed to a SDIO
+ function.
+ */
+#define CY_AS_ERROR_INVALID_FUNCTION (68)
+
+/* Summary
+ This error is returned when an invalid block size is passed to CyAsSdioSetBlocksize().
+
+ Description
+ This error is returned when an invalid block size (greater than maximum block size supported)is
+ passed to CyAsSdioSetBlocksize().
+ */
+
+#define CY_AS_ERROR_INVALID_BLOCKSIZE (69)
+
+/* Summary
+ This error is returned when an tuple requested is not found.
+
+ Description
+ This error is returned when an tuple requested is not found.
+ */
+#define CY_AS_ERROR_TUPLE_NOT_FOUND (70)
+
+/* Summary
+ This error is returned when an extended IO operation to an SDIO function is
+ Aborted.
+ Description
+ This error is returned when an extended IO operation to an SDIO function is
+ Aborted. */
+#define CY_AS_ERROR_IO_ABORTED (71)
+
+/* Summary
+ This error is returned when an extended IO operation to an SDIO function is
+ Suspended.
+ Description
+ This error is returned when an extended IO operation to an SDIO function is
+ Suspended. */
+#define CY_AS_ERROR_IO_SUSPENDED (72)
+
+/* Summary
+ This error is returned when IO is attempted to a Suspended SDIO function.
+ Description
+ This error is returned when IO is attempted to a Suspended SDIO function. */
+#define CY_AS_ERROR_FUNCTION_SUSPENDED (73)
+
+/* Summary
+ This error is returned if an MTP function is called before MTPStart has completed.
+ Description
+ This error is returned if an MTP function is called before MTPStart has completed.
+*/
+#define CY_AS_ERROR_MTP_NOT_STARTED (74)
+
+/* Summary
+ This error is returned by API functions that are not valid in MTP mode (CyAsStorageClaim for example)
+ Description
+ This error is returned by API functions that are not valid in MTP mode (CyAsStorageClaim for example)
+*/
+#define CY_AS_ERROR_NOT_VALID_IN_MTP (75)
+
+/* Summary
+ This error is returned when an attempt is made to partition a storage device that is already
+ partitioned.
+
+ Description
+ This error is returned when an attempt is made to partition a storage device that is already
+ partitioned.
+*/
+#define CY_AS_ERROR_ALREADY_PARTITIONED (76)
+
+/* Summary
+ This error is returned when a call is made to CyAsUsbSelectMSPartitions after CyAsUsbSetEnumConfig
+ is called.
+
+ Description
+ This error is returned when a call is made to CyAsUsbSelectMSPartitions after CyAsUsbSetEnumConfig
+ is called.
+ */
+#define CY_AS_ERROR_INVALID_CALL_SEQUENCE (77)
+
+/* Summary
+ This error is returned when a StorageWrite opperation is attempted during an ongoing MTP transfer.
+ Description
+ This error is returned when a StorageWrite opperation is attempted during an ongoing MTP transfer.
+ A MTP transfer is initiated by a call to CyAsMTPInitSendObject or CyAsMTPInitGetObject and is not
+ finished until the CyAsMTPSendObjectComplete or CyAsMTPGetObjectComplete event is generated.
+*/
+#define CY_AS_ERROR_NOT_VALID_DURING_MTP (78)
+
+/* Summary
+ This error is returned when a StorageRead or StorageWrite is attempted while a UsbRead or UsbWrite on
+ a Turbo endpoint (2 or 6) is pending, or visa versa.
+ Description
+ When there is a pending usb read or write on a turbo endpoint (2 or 6) a storage read or write call
+ may not be performed. Similarly when there is a pending storage read or write a usb read or write may
+ not be performed on a turbo endpoint (2 or 6).
+*/
+#define CY_AS_ERROR_STORAGE_EP_TURBO_EP_CONFLICT (79)
+
+/* Summary
+ This error is returned when processor requests to reserve greater number of zones than available for
+ proc booting via lna firmware.
+
+ Description
+ Astoria does not allocate any nand zones for the processor in this case.
+*/
+#define CY_AS_ERROR_EXCEEDED_NUM_ZONES_AVAIL (80)
+
+#endif /* _INCLUDED_CYASERR_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyashal.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,85 @@
+/* Cypress West Bridge API header file (cyashal.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASHAL_H_
+#define _INCLUDED_CYASHAL_H_
+
+#if !defined(__doxygen__)
+
+/* The possible HAL layers defined and implemented by Cypress */
+/*nxz*/
+#ifdef __CY_ASTORIA_BEAGLEBOARD_SPI__HAL__
+#ifdef CY_HAL_DEFINED
+#error Only one HAL layer can be defined
+#endif
+
+#define CY_HAL_DEFINED
+
+#include "cyashalbeagleboard.h"
+#endif
+
+#ifdef __CY_ASTORIA_FPGA_HAL__
+#ifdef CY_HAL_DEFINED
+#error Only one HAL layer can be defined
+#endif
+
+#define CY_HAL_DEFINED
+
+#include "cyashalfpga.h"
+#endif
+
+/***** SCM User space HAL ****/
+#ifdef __CY_ASTORIA_SCM_HAL__
+#ifdef CY_HAL_DEFINED
+#error Only one HAL layer can be defined
+#endif
+
+#define CY_HAL_DEFINED
+
+#include "cyanhalscm.h"
+#endif
+/***** SCM User space HAL ****/
+
+/***** SCM Kernel HAL ****/
+#ifdef __CY_ASTORIA_SCM_KERNEL_HAL__
+#ifdef CY_HAL_DEFINED
+#error Only one HAL layer can be defined
+#endif
+
+#define CY_HAL_DEFINED
+
+#include "cyanhalscm_kernel.h"
+#endif
+/***** SCM Kernel HAL ****/
+
+#ifdef __CY_ASTORIA_CUSTOMER_HAL__
+#ifdef CY_HAL_DEFINED
+#error Only one HAL layer can be defined
+#endif
+
+#define CY_HAL_DEFINED
+#include "cyashal_customer.h"
+
+#endif
+
+#endif /* __doxygen__ */
+
+#endif /* _INCLUDED_CYASHAL_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyashalcb.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,42 @@
+/* Cypress West Bridge API header file (cyashalcb.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASHALCB_H_
+#define _INCLUDED_CYASHALCB_H_
+
+/* Summary
+ This type defines a callback function type called when a DMA operation has completed.
+
+ Description
+
+ See Also
+ * CyAsHalDmaRegisterCallback
+ * CyAsHalDmaSetupWrite
+ * CyAsHalDmaSetupRead
+*/
+typedef void (*CyAsHalDmaCompleteCallback)(
+ CyAsHalDeviceTag tag,
+ CyAsEndPointNumber_t ep,
+ uint32_t cnt,
+ CyAsReturnStatus_t ret) ;
+
+typedef CyAsHalDmaCompleteCallback CyAnHalDmaCompleteCallback;
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyashaldef.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,78 @@
+/* Cypress West Bridge API header file (cyashaldef.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASHALDEF_H_
+#define _INCLUDED_CYASHALDEF_H_
+
+/* Summary
+ If set to TRUE, the basic numeric types are defined by the West Bridge API code
+
+ Description
+ The West Bridge API relies on some basic integral types to be defined. These types include
+ uint8_t, int8_t, uint16_t, int16_t, uint32_t, and int32_t. If this macro is defined the
+ West Bridge API will define these types based on some basic assumptions. If this value is
+ set and the West Bridge API is used to set these types, the definition of these types must
+ be examined to insure that they are appropriate for the given target architecture and
+ compiler.
+
+ Notes
+ It is preferred that if the basic platform development environment defines these types
+ that the CY_DEFINE_BASIC_TYPES macro be undefined and the appropriate target system header
+ file be added to the file cyashaldef.h.
+*/
+#ifndef CY_DEFINE_BASIC_TYPES
+
+/*
+ * Include your target system header file that defines the basic types here if at all
+ * possible.
+ */
+#ifdef __CY_ASTORIA_SCM_KERNEL_HAL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#endif
+
+#else
+
+/*
+ * Define the basic types. If these are not defined by your system, define these
+ * here by defining the symbol CY_DEFINE_BASIC_TYPES
+ */
+typedef signed char int8_t ;
+typedef signed short int16_t ;
+typedef signed int int32_t ;
+typedef unsigned char uint8_t ;
+typedef unsigned short uint16_t ;
+typedef unsigned int uint32_t ;
+
+/*nxz*/
+#include <e32def.h>
+
+
+#endif
+
+#if !defined(__doxygen__)
+typedef int CyBool ;
+#define CyTrue (1)
+#define CyFalse (0)
+#endif
+
+#endif /* _INCLUDED_CYASHALDEF_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyashaldoc.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,687 @@
+/* Cypress West Bridge API header file (cyashaldoc.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASHALDOC_H_
+#define _INCLUDED_CYASHALDOC_H_
+
+#include "cyashaldef.h"
+
+/*@@Hardware Abstraction Layer (HAL)
+ Summary
+ This software module is supplied by the user of the West Bridge API. This module contains the
+ software that is specific to the hardware implementation or operating system of the client
+ system.
+
+ * Sleep Channels *
+ A sleep channel is a operating system object that provides that capability for one
+ thread or process to sleep while waiting on the completion of some hardware event. The
+ hardware event is usually processed by a hardware interrupt and the interrupt handler
+ then wakes the thread or process that is sleeping.
+
+ A sleep channel provides the mechanism for this operation. A sleep channel is created and
+ initialized during the API initialization. When the API needs to wait for the hardware, the
+ API performs a SleepOn() operation on the sleep channel. When hardware event occurs, an
+ interrupt handler processes the event and then performs a Wake() operation on the sleep channel
+ to wake the sleeping process or thread.
+
+ * DMA Model *
+ When the West Bridge API needs to transfer USB or storage data to/from the West Bridge device, this is
+ done using a "DMA" operation. In this context the term DMA is used loosely as the West Bridge
+ API does not really care if the data is transferred using a burst read or write operation,
+ or if the data is transferred using programmed I/O operations. When a "DMA" operation is
+ needed, the West Bridge API calls either CyAsHalDmaSetupRead() or CyAsHalDmaSetupWrite() depending
+ on the direction of the data flow. The West Bridge API expects the "DMA" operation requested in
+ the call to be completed and the registered "DMA complete" callback to be called.
+
+ The West Bridge API looks at several factors to determine the size of the "DMA" request to
+ pass to the HAL layer. First the West Bridge API calls CyAsHalDmaMaxRequestSize() to determine
+ the maximum amount of data the HAL layer can accept for a "DMA" operation on the requested
+ endpoint. The West Bridge API will never exceed this value in a "DMA" request to the HAL
+ layer. The West Bridge API also sends the maximum amount of data the West Bridge device can
+ accept as part of the "DMA" request. If the amount of data in the "DMA" request to the HAL
+ layer exceeds the amount of data the West Bridge device can accept, it is expected that the
+ HAL layer has the ability to break the request into multiple operations.
+
+ If the HAL implementation requires the API to handle the size of the "DMA" requests for
+ one or more endpoints, the value CY_AS_DMA_MAX_SIZE_HW_SIZE can be returned from the
+ CyAsHalDmaMaxRequestSize() call. In this case, the API assumes that the maximum size of
+ each "DMA" request should be limited to the maximum that can be accepted by the endpoint
+ in question.
+
+ Notes
+ See the <install>/api/hal/scm_kernel/cyashalscm_kernel.c file for an example of how
+ the DMA request size can be managed by the HAL implementation.
+
+ * Interrupt Handling *
+ The HAL implementation is required to handle interrupts arriving from the West Bridge device,
+ and call the appropriate handlers. If the interrupt arriving is one of PLLLOCKINT,
+ PMINT, MBINT or MCUINT, the CyAsIntrServiceInterrupt API should be called to service the
+ interrupt. If the interrupt arriving is DRQINT, the HAL should identify the endpoint
+ corresponding to which the DRQ is being generated and perform the read/write transfer
+ from the West Bridge. See the <install>/api/hal/scm_kernel/cyashalscm_kernel.c or
+ <install>/api/hal/fpga/cyashalfpga.c reference HAL implementations for examples.
+
+ The HAL implementation can choose to poll the West Bridge interrupt status register instead
+ of using interrupts. In this case, the polling has to be performed from a different
+ thread/task than the one running the APIs. This is required because there are API calls
+ that block on the reception of data from the West Bridge, which is delivered only through
+ the interrupt handlers.
+
+ * Required Functions *
+ This section defines the types and functions that must be supplied in order to provide a
+ complete HAL layer for the West Bridge API.
+
+ Types that must be supplied:
+ * CyAsHalSleepChannel
+
+ Hardware functions that must be supplied:
+ * CyAsHalWriteRegister
+ * CyAsHalReadRegister
+ * CyAsHalDmaSetupWrite
+ * CyAsHalDmaSetupRead
+ * CyAsHalDmaCancelRequest
+ * CyAsHalDmaRegisterCallback
+ * CyAsHalDmaMaxRequestSize
+ * CyAsHalSetWakeupPin
+ * CyAsHalSyncDeviceClocks
+ * CyAsHalInitDevRegisters
+ * CyAsHalReadRegsBeforeStandby
+ * CyAsHalRestoreRegsAfterStandby
+
+ Operating system functions that must be supplied:
+ * CyAsHalAlloc
+ * CyAsHalFree
+ * CyAsHalCBAlloc
+ * CyAsHalCBFree
+ * CyAsHalMemSet
+ * CyAsHalCreateSleepChannel
+ * CyAsHalDestroySleepChannel
+ * CyAsHalSleepOn
+ * CyAsHalWake
+ * CyAsHalDisableInterrupts
+ * CyAsHalEnableInterrupts
+ * CyAsHalSleep150
+ * CyAsHalSleep
+ * CyAsHalAssert
+ * CyAsHalPrintMessage
+ * CyAsHalIsPolling
+*/
+
+/* Summary
+ This is the type that represents a sleep channel
+
+ Description
+ A sleep channel is an operating system object that, when a thread of control waits on the
+ sleep channel, the thread sleeps until another thread signals the sleep object. This object
+ is generally used when a high level API is called and must wait for a response that is
+ supplied in an interrupt handler. The thread calling the API is put into a sleep state and
+ when the reply arrives via the interrupt handler, the interrupt handler wakes the sleeping
+ thread to indicate that the expect reply is available.
+*/
+typedef struct CyAsHalSleepChannel
+{
+ int m_channel ; /* This structure is filled in with OS specific information
+ to implementat a sleep channel */
+} CyAsHalSleepChannel ;
+
+/* Summary
+ This function is called to write a register value
+
+ Description
+ This function is called to write a specific register to a specific value. The tag identifies the
+ device of interest. The address is relative to the base address of the West Bridge device.
+
+ Returns
+ Nothing
+
+ See Also
+ * CyAsHalDeviceTag
+ * CyAsHalReadRegister
+*/
+EXTERN void
+CyAsHalWriteRegister(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ uint16_t addr, /* The address we are writing to */
+ uint16_t value /* The value to write to the register */
+ ) ;
+
+/* Summary
+ This function is called to read a register value
+
+ Description
+ This function is called to read the contents of a specific register. The tag identifies the
+ device of interest. The address is relative to the base address of the West Bridge device.
+
+ Returns
+ Contents of the register
+
+ See Also
+ * CyAsHalDeviceTag
+ * CyAsHalWriteRegister
+*/
+EXTERN uint16_t
+CyAsHalReadRegister(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ uint16_t addr /* The address we are writing to */
+ ) ;
+
+/* Summary
+ This function initiates a DMA write operation to write to West Bridge
+
+ Description
+ This function initiates a DMA write operation. The request size will not exceed the value the HAL
+ layer returned via CyAsHalDmaMaxRequestSize(). This request size may exceed the size of what the
+ West Bridge device will accept as one packet and the HAL layer may need to divide the request into
+ multiple hardware DMA operations.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalDmaSetupRead
+ * CyAsHalDmaMaxRequestSize
+*/
+EXTERN void
+CyAsHalDmaSetupWrite(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint we are writing to */
+ void * buf_p, /* The data to write via DMA */
+ uint32_t size, /* The size of the data at buf_p */
+ uint16_t maxsize /* The maximum amount of data that the endpoint can accept as one packet */
+ ) ;
+
+/* Summary
+ This function initiates a DMA read operation from West Bridge
+
+ Description
+ This function initiates a DMA read operation. The request size will not exceed the value the
+ HAL layer returned via CyAsHalDmaMaxRequestSize(). This request size may exceed the size of what
+ the Anitoch will accept as one packet and the HAL layer may need to divide the request into multiple
+ hardware DMA operations.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalDmaSetupRead
+ * CyAsHalDmaMaxRequestSize
+*/
+EXTERN void
+CyAsHalDmaSetupRead(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint we are reading from */
+ void * buf_p, /* The buffer to read data into */
+ uint32_t size, /* The amount of data to read */
+ uint16_t maxsize /* The maximum amount of data that the endpoint can provide in one DMA operation */
+ ) ;
+
+/* Summary
+ This function cancels a pending DMA request
+
+ Description
+ This function cancels a pending DMA request that has been passed down to the hardware. The HAL layer
+ can elect to physically cancel the request if possible, or just ignore the results of the request if it
+ is not possible.
+
+ Returns
+ None
+*/
+EXTERN void
+CyAsHalDmaCancelRequest(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyAsEndPointNumber_t ep /* The endpoint we are reading from */
+ ) ;
+
+/* Summary
+ This function registers a callback function to be called when a DMA request is completed
+
+ Description
+ This function registers a callback that is called when a request issued via CyAsHalDmaSetupWrite() or
+ CyAsHalDmaSetupRead() has completed.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalDmaSetupWrite
+ * CyAsHalDmaSetupRead
+*/
+EXTERN void
+CyAsHalDmaRegisterCallback(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyAsHalDmaCompleteCallback cb /* The callback to call when a request has completed */
+ ) ;
+
+/* Summary
+ This function returns the maximum size of a DMA request that can be handled by the HAL.
+
+ Description
+ When DMA requests are passed to the HAL layer for processing, the HAL layer may have a limit
+ on the size of the request that can be handled. This function is called by the DMA manager
+ for an endpoint when DMA is enabled to get the maximum size of data the HAL layer can handle.
+ The DMA manager insures that a request is never sent to the HAL layer that exceeds the size
+ returned by this function.
+
+ Returns
+ the maximum size of DMA request the HAL layer can handle
+*/
+EXTERN uint32_t
+CyAsHalDmaMaxRequestSize(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyAsEndPointNumber_t ep /* The endpoint of interest */
+ ) ;
+
+/* Summary
+ This function sets the WAKEUP pin to a specific state on the West Bridge device.
+
+ Description
+ In order to enter the standby mode, the WAKEUP pin must be de-asserted. In order to resume from
+ standby mode, the WAKEUP pin must be asserted. This function provides the mechanism to do
+ this.
+
+ Returns
+ 1 if the pin was changed, 0 if the HAL layer does not support changing this pin
+*/
+EXTERN uint32_t
+CyAsHalSetWakeupPin(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyBool state /* The desired state of the wakeup pin */
+ ) ;
+
+/* Summary
+ Synchronise the West Bridge device clocks to re-establish device connectivity.
+
+ Description
+ When the Astoria bridge device is working in SPI mode, a long period of inactivity
+ can cause a loss of serial synchronisation between the processor and Astoria. This
+ function is called by the API when it detects such a condition, and is expected to take
+ the action required to re-establish clock synchronisation between the devices.
+
+ Returns
+ CyTrue if the attempt to re-synchronise is successful, CyFalse if not.
+ */
+EXTERN CyBool
+CyAsHalSyncDeviceClocks(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ ) ;
+
+/* Summary
+ Initialize West Bridge device registers that may have been modified while the device
+ was in standby.
+
+ Description
+ The content of some West Bridge registers may be lost when the device is placed in
+ standby mode. This function restores these register contents so that the device can
+ continue to function normally after it wakes up from standby mode.
+
+ This function is required to perform operations only when the API is being used with
+ the Astoria device in one of the PNAND modes or in the PSPI mode. It can be a
+ no-operation in all other cases.
+
+ Returns
+ None
+ */
+EXTERN void
+CyAsHalInitDevRegisters(
+ CyAsHalDeviceTag tag, /* The tag to ID a specific West Bridge device */
+ CyBool is_standby_wakeup /* Indicates whether this is a wake-up from standby. */
+ ) ;
+
+/* Summary
+ This function reads a set of P-port accessible device registers and stores their value
+ for later use.
+
+ Description
+ The West Bridge Astoria device silicon has a known problem when operating in SPI mode
+ on the P-port, where some of the device registers lose their value when the device
+ goes in and out of standby mode. The suggested work-around is to reset the Astoria
+ device as part of the wakeup procedure from standby.
+
+ This requires that the values of some of the P-port accessible registers be restored to
+ their pre-standby values after it has been reset. This HAL function can be used to read
+ and store the values of these registers at the point where the device is being placed
+ in standby mode.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalRestoreRegsAfterStandby
+ */
+EXTERN void
+CyAsHalReadRegsBeforeStandby(
+ CyAsHalDeviceTag tag /* The tag to ID a specific West Bridge device */
+ ) ;
+
+/* Summary
+ This function restores the old values to a set of P-port accessible device registers.
+
+ Description
+ This function is part of the work-around to a known West Bridge Astoria device error when
+ operating in SPI mode on the P-port. This function is used to restore a set of P-port
+ accessible registers to the values they had before the device was placed in standby
+ mode.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalRestoreRegsAfterStandby
+ */
+EXTERN void
+CyAsHalRestoreRegsAfterStandby(
+ CyAsHalDeviceTag tag /* The tag to ID a specific West Bridge device */
+ ) ;
+
+/*
+ * The functions below this comment are part of the HAL layer, as the HAL layer consists of the
+ * abstraction to both the hardware platform and the operating system. However; the functions below
+ * this comment all relate to the operating environment and not specifically to the hardware platform
+ * or specific device.
+ */
+
+/* Summary
+ This function allocates a block of memory
+
+ Description
+ This is the HAL layer equivalent of the malloc() function.
+
+ Returns
+ a pointer to a block of memory
+
+ See Also
+ * CyAsHalFree
+*/
+EXTERN void *
+CyAsHalAlloc(
+ uint32_t size /* The size of the memory block to allocate */
+ ) ;
+
+/* Summary
+ This function frees a previously allocated block of memory
+
+ Description
+ This is the HAL layer equivalent of the free() function.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalAlloc
+*/
+EXTERN void
+CyAsHalFree(
+ void * ptr /* Pointer to a memory block to free */
+ ) ;
+
+/* Summary
+ This function is a malloc equivalent that can be used from an
+ interrupt context.
+
+ Description
+ This function is a malloc equivalent that will be called from the
+ API in callbacks. This function is required to be able to provide
+ memory in interrupt context.
+
+ Notes
+ For platforms where it is not possible to allocate memory in interrupt
+ context, we provide a reference allocator that takes memory during
+ initialization and implements malloc/free using this memory.
+ See the <install>/api/hal/fpga/cyashalblkalloc.[ch] files for the
+ implementation, and the <install>/api/hal/fpga/cyashalfpga.c file
+ for an example of the use of this allocator.
+
+ Returns
+ A pointer to the allocated block of memory
+
+ See Also
+ * CyAsHalCBFree
+ * CyAsHalAlloc
+*/
+EXTERN void *
+CyAsHalCBAlloc(
+ uint32_t size /* The size of the memory block to allocate */
+ ) ;
+
+/* Summary
+ This function frees the memory allocated through the CyAsHalCBAlloc
+ call.
+
+ Description
+ This function frees memory allocated through the CyAsHalCBAlloc
+ call, and is also required to support calls from interrupt
+ context.
+
+ Returns
+ None
+
+ See Also
+ * CyAsHalCBAlloc
+ * CyAsHalFree
+*/
+EXTERN void
+CyAsHalCBFree(
+ void * ptr /* Pointer to the memory block to be freed */
+ ) ;
+
+/* Summary
+ This function sets a block of memory to a specific value
+
+ Description
+ This function is the HAL layer equivalent of the memset() function.
+
+ Returns
+ None
+*/
+EXTERN void
+CyAsMemSet(
+ void * ptr, /* A pointer to a block of memory to set */
+ uint8_t value, /* The value to set the memory to */
+ uint32_t cnt /* The number of bytes to set */
+ ) ;
+
+/* Summary
+ This function creates or initializes a sleep channel
+
+ Description
+ This function creates or initializes a sleep channel. The sleep channel defined using
+ the HAL data structure CyAsHalSleepChannel.
+
+ Returns
+ CyTrue is the initialization was sucessful, and CyFalse otherwise
+
+ See Also
+ * CyAsHalSleepChannel
+ * CyAsHalDestroySleepChannel
+ * CyAsHalSleepOn
+ * CyAsHalWake
+*/
+EXTERN CyBool
+CyAsHalCreateSleepChannel(
+ CyAsHalSleepChannel *chan /* Pointer to the sleep channel to create/initialize */
+ ) ;
+
+/* Summary
+ This function destroys an existing sleep channel
+
+ Description
+ This function destroys an existing sleep channel. The sleep channel is of type
+ CyAsHalSleepChannel.
+
+ Returns
+ CyTrue if the channel was destroyed, and CyFalse otherwise
+
+ See Also
+ * CyAsHalSleepChannel
+ * CyAsHalCreateSleepChannel
+ * CyAsHalSleepOn
+ * CyAsHalWake
+*/
+EXTERN CyBool
+CyAsHalDestroySleepChannel(
+ CyAsHalSleepChannel chan /* The sleep channel to destroy */
+ ) ;
+
+/* Summary
+ This function causes the calling process or thread to sleep until CyAsHalWake() is called
+
+ Description
+ This function causes the calling process or threadvto sleep. When CyAsHalWake() is called
+ on the same sleep channel, this processes or thread is then wakened and allowed to run
+
+ Returns
+ CyTrue if the thread or process is asleep, and CyFalse otherwise
+
+ See Also
+ * CyAsHalSleepChannel
+ * CyAsHalWake
+*/
+EXTERN CyBool
+CyAsHalSleepOn(
+ CyAsHalSleepChannel chan, /* The sleep channel to sleep on */
+ uint32_t ms /* The maximum time to sleep in milli-seconds */
+ ) ;
+
+/* Summary
+ This function casues the process or thread sleeping on the given sleep channel to wake
+
+ Description
+ This function causes the process or thread sleeping on the given sleep channel to wake. The
+ channel
+
+ Returns
+ CyTrue if the thread or process is awake, and CyFalse otherwise
+
+ See Also
+ * CyAsHalSleepChannel
+ * CyAsHalSleepOn
+*/
+EXTERN CyBool
+CyAsHalWake(
+ CyAsHalSleepChannel chan /* The sleep channel to wake */
+ ) ;
+
+/* Summary
+ This function disables interrupts, insuring that short bursts of code can be run without danger of interrupt
+ handlers running.
+
+ Description
+ There are cases within the API when lists must be manipulated by both the API and the associated
+ interrupt handlers. In these cases, interrupts must be disabled to insure the integrity of the list during the
+ modification. This function is used to disable interrupts during the short intervals where these lists are being
+ changed.
+
+ The HAL must have the ability to nest calls to CyAsHalDisableInterrupts and CyAsHalEnableInterrupts.
+
+ Returns
+ Any interrupt related state value which will be passed back into the subsequent CyAsHalEnableInterrupts call.
+
+ See Also
+ * CyAsHalEnableInterrupts
+*/
+EXTERN uint32_t
+CyAsHalDisableInterrupts() ;
+
+/* Summary
+ This function re-enables interrupts after a critical section of code in the API has been completed.
+
+ Description
+ There are cases within the API when lists must be manipulated by both the API and the associated
+ interrupt handlers. In these cases, interrupts must be disabled to insure the integrity of the list during the
+ modification. This function is used to enable interrupts after the short intervals where these lists are being
+ changed.
+
+ See Also
+ * CyAsHalDisableInterrupts
+*/
+EXTERN void
+CyAsHalEnableInterrupts(
+ uint32_t value /* Value returned by the previous CyAsHalDisableInterrupts call. */
+ ) ;
+
+/* Summary
+ This function sleeps for 150 ns.
+
+ Description
+ This function sleeps for 150 ns before allowing the calling function to continue. This function is used for a
+ specific purpose and the sleep required is at least 150 ns.
+*/
+EXTERN void
+CyAsHalSleep150(
+ ) ;
+
+/* Summary
+ This function sleeps for the given number of milliseconds
+
+ Description
+ This function sleeps for at least the given number of milliseonds
+*/
+EXTERN void
+CyAsHalSleep(
+ uint32_t ms
+ ) ;
+
+/* Summary
+ This function asserts when the condition evaluates to zero
+
+ Description
+ Within the API there are conditions which are checked to insure the integrity of the code. These conditions are
+ checked only within a DEBUG build. This function is used to check the condition and if the result evaluates to
+ zero, it should be considered a fatal error that should be reported to Cypress.
+*/
+EXTERN void
+CyAsHalAssert(
+ CyBool cond /* The condition to evaluate */
+ ) ;
+
+/* Summary
+ This function prints a message from the API to a human readable device
+
+ Description
+ There are places within the West Bridge API where printing a message is useful to the debug process. This function
+ provides the mechanism to print a message.
+
+ Returns
+ NONE
+*/
+EXTERN void
+CyAsHalPrintMessage(
+ const char * fmt_p, /* The message to print */
+ ... /* Variable arguments */
+ ) ;
+
+/* Summary
+ This function reports whether the HAL implementation uses polling to service
+ data coming from the West Bridge.
+
+ Description
+ This function reports whether the HAL implementation uses polling to service
+ data coming from the West Bridge.
+
+ Returns
+ CyTrue if the HAL polls the West Bridge Interrupt Status registers to complete operations,
+ CyFalse if the HAL is interrupt driven.
+ */
+EXTERN CyBool
+CyAsHalIsPolling (
+ void) ;
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasmedia.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,49 @@
+/* Cypress West Bridge API header file (cyasmedia.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASMEDIA_H_
+#define _INCLUDED_CYASMEDIA_H_
+
+#include "cyas_cplus_start.h"
+
+
+/* Summary
+ Specifies a specific type of media supported by West Bridge
+
+ Description
+ The West Bridge device supports five specific types of media as storage/IO devices
+ attached to it's S-Port. This type is used to indicate the type of
+ media being referenced in any API call.
+*/
+typedef enum CyAsMediaType
+{
+ CyAsMediaNand = 0x00, /* Flash NAND memory (may be SLC or MLC) */
+ CyAsMediaSDFlash = 0x01, /* An SD flash memory device */
+ CyAsMediaMMCFlash = 0x02, /* An MMC flash memory device */
+ CyAsMediaCEATA = 0x03, /* A CE-ATA disk drive */
+ CyAsMediaSDIO = 0x04, /* SDIO device. */
+ CyAsMediaMaxMediaValue = 0x05
+
+} CyAsMediaType ;
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASMEDIA_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasmisc.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1250 @@
+/* Cypress West Bridge API header file (cyasmisc.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASMISC_H_
+#define _INCLUDED_CYASMISC_H_
+
+#include "cyashal.h"
+#include "cyastypes.h"
+#include "cyasmedia.h"
+
+#include "cyas_cplus_start.h"
+
+#define CY_AS_LEAVE_STANDBY_DELAY_CLOCK (1)
+#define CY_AS_RESET_DELAY_CLOCK (1)
+
+#define CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL (5)
+#define CY_AS_RESET_DELAY_CRYSTAL (5)
+
+/* The maximum number of buses supported */
+#define CY_AS_MAX_BUSES (2)
+
+/* The maximum number of storage devices supported per bus */
+#define CY_AS_MAX_STORAGE_DEVICES (1)
+
+#define CY_AS_FUNCTCBTYPE_DATA_MASK (0x60000000U)
+#define CY_AS_FUNCTCBTYPE_TYPE_MASK (0x1FFFFFFFU)
+
+#define CyAsFunctCBTypeGetType(t) ((CyAsFunctCBType)((t) & CY_AS_FUNCTCBTYPE_TYPE_MASK))
+#define CyAsFunctCBTypeContainsData(t) (((CyAsFunctCBType)((t) & CY_AS_FUNCTCBTYPE_DATA_MASK)) == CY_FUNCT_CB_DATA)
+
+/*****************************************************************************
+ * West Bridge Types
+ ****************************************************************************/
+
+/* Summary
+ Specifies a handle to an West Bridge device
+
+ Description
+ This type represents an opaque handle to an West Bridge device. This handle is
+ created via the CyAsMiscCreateDevice() function and is used in all subsequent
+ calls that communicate to the West Bridge device.
+
+ See Also
+ * CyAsMiscCreateDevice
+ * CyAsMiscDestroyDevice
+*/
+typedef void * CyAsDeviceHandle ;
+
+/* Summary
+ This data type gives the mode for the DACK# signal
+*/
+typedef enum CyAsDeviceDackMode
+{
+ CyAsDeviceDackAck, /* Operate in the ACK mode */
+ CyAsDeviceDackEob /* Operate in the EOB mode */
+} CyAsDeviceDackMode ;
+
+/* Summary
+ This data structure gives the options for all hardware features.
+
+ Description
+ This structure contains the information required to initialize the West Bridge hardware.
+ Any features of the device that can be configured by the caller are specified here.
+
+ See Also
+ * CyAsMiscConfigure
+*/
+typedef struct CyAsDeviceConfig
+{
+ CyBool srammode ; /* If TRUE, the P port is running in SRAM mode. */
+ CyBool sync ; /* If TRUE, the P port is synchronous, otherwise async */
+ CyBool dmaintr ; /* If TRUE, DMA req will be delivered via the interrupt signal */
+ CyAsDeviceDackMode dackmode ; /* Mode for the DACK# signal */
+ CyBool drqpol ; /* If TRUE, the DRQ line is active high, otherwise active low */
+ CyBool dackpol ; /* If TRUE, the DACK line is active high, otherwise active low */
+ CyBool crystal ; /* If TRUE, the clock is connected to a crystal, otherwise it is
+ connected to a clock */
+} CyAsDeviceConfig ;
+
+
+/* Summary
+ Specifies a resource that can be owned by either the West Bridge device or by the processor.
+
+ Description
+ This enumerated type identifies a resource that can be owned either by
+ the West Bridge device, or by the processor attached to the P port of the
+ West Bridge device.
+
+ See Also
+ * CyAsMiscAcquireResource
+ * CyAsMiscReleaseResource
+*/
+typedef enum CyAsResourceType
+{
+ CyAsBusUSB = 0, /* The USB D+ and D- pins */
+ CyAsBus_1 = 1, /* The SDIO bus */
+ CyAsBus_0 = 2 /* The NAND bus (not implemented) */
+} CyAsResourceType;
+
+/* Summary
+ Specifies the reset type for a software reset operation.
+
+ Description
+ When the West Bridge device is reset, there are two types of reset that are
+ possible. This type indicates the type of reset requested.
+
+ Notes
+ Both of these reset types are software based resets; and are distinct from
+ a chip level HARD reset that is applied through the reset pin on the West Bridge.
+
+ The CyAsResetSoft type resets only the on-chip micro-controller in the West Bridge.
+ In this case, the previously loaded firmware will continue running. However,
+ the Storage and USB stack operations will need to be restarted, as any state
+ relating to these would have been lost.
+
+ The CyAsResetHard type resets the entire West Bridge chip, and will need a fresh
+ configuration and firmware download.
+
+ See Also
+ * <LINK CyAsMiscReset>
+ */
+
+typedef enum CyAsResetType
+{
+ CyAsResetSoft, /* Just resets the West Bridge micro-controller */
+ CyAsResetHard /* Resets entire device, firmware must be reloaded and
+ the West Bridge device must be re-initialized */
+} CyAsResetType;
+
+
+
+/* Summary
+ This type specifies the polarity of the SD power pin.
+
+ Description
+ Sets the SD power pin ( port C, bit 6) to active low or active high.
+
+*/
+
+typedef enum CyAsMiscSignalPolarity
+{
+ CyAsMiscActiveHigh,
+ CyAsMiscActiveLow
+
+} CyAsMiscSignalPolarity ;
+
+
+
+/* Summary
+ This type specifies the type of the data returned by a Function Callback.
+
+ Description
+ CY_FUNCT_CB_NODATA - This callback does not return any additional information in the data field.
+ CY_FUNCT_CB_DATA - The data field is used, and the CyAsFunctCBType will also contain the type of this data.
+
+ See Also
+ CyAsFunctionCallback
+*/
+typedef enum CyAsFunctCBType
+{
+ CY_FUNCT_CB_INVALID = 0x0U,
+ CY_FUNCT_CB_MISC_GETFIRMWAREVERSION, /* Data from a CyAsMiscGetFirmwareVersion call. */
+ CY_FUNCT_CB_MISC_HEARTBEATCONTROL, /* Data from a CyAsMiscHeartBeatControl call. */
+ CY_FUNCT_CB_MISC_ACQUIRERESOURCE, /* Data from a CyAsMiscAcquireResource call. */
+ CY_FUNCT_CB_MISC_READMCUREGISTER, /* Data from a CyAsMiscReadMCURegister call. */
+ CY_FUNCT_CB_MISC_WRITEMCUREGISTER, /* Data from a CyAsMiscWriteMCURegister call. */
+ CY_FUNCT_CB_MISC_SETTRACELEVEL, /* Data from a CyAsMiscSetTraceLevel call. */
+ CY_FUNCT_CB_MISC_STORAGECHANGED, /* Data from a CyAsMiscStorageChanged call. */
+ CY_FUNCT_CB_MISC_GETGPIOVALUE, /* Data from a CyAsMiscGetGpioValue call. */
+ CY_FUNCT_CB_MISC_SETGPIOVALUE, /* Data from a CyAsMiscSetGpioValue call. */
+ CY_FUNCT_CB_MISC_DOWNLOADFIRMWARE, /* Data from a CyAsMiscDownloadFirmware call. */
+ CY_FUNCT_CB_MISC_ENTERSTANDBY, /* Data from a CyAsMiscEnterStandby call. */
+ CY_FUNCT_CB_MISC_ENTERSUSPEND, /* Data from a CyAsMiscEnterSuspend call. */
+ CY_FUNCT_CB_MISC_LEAVESUSPEND, /* Data from a CyAsMiscLeaveSuspend call. */
+ CY_FUNCT_CB_MISC_RESET, /* Data from a CyAsMiscReset call. */
+ CY_FUNCT_CB_MISC_SETSDFREQ, /* Data from a CyAsMiscSetLowSpeedSDFreq or CyAsMiscSetHighSpeedSDFreq call. */
+ CY_FUNCT_CB_MISC_RESERVELNABOOTAREA, /* Data from a CyAsMiscSwitchPnandMode call */
+ CY_FUNCT_CB_MISC_SETSDPOLARITY, /* Data from a CyAsMiscSetSDPowerPolarity call */
+
+ CY_FUNCT_CB_STOR_START, /* Data from a CyAsStorageStart call. */
+ CY_FUNCT_CB_STOR_STOP, /* Data from a CyAsStorageStop call. */
+ CY_FUNCT_CB_STOR_CLAIM, /* Data from a CyAsStorageClaim call. */
+ CY_FUNCT_CB_STOR_RELEASE, /* Data from a CyAsStorageRelease call. */
+ CY_FUNCT_CB_STOR_QUERYMEDIA, /* Data from a CyAsStorageQueryMedia call. */
+ CY_FUNCT_CB_STOR_QUERYBUS, /* Data from a CyAsStorageQueryBus call. */
+ CY_FUNCT_CB_STOR_QUERYDEVICE, /* Data from a CyAsStorageQueryDevice call. */
+ CY_FUNCT_CB_STOR_QUERYUNIT, /* Data from a CyAsStorageQueryUnit call. */
+ CY_FUNCT_CB_STOR_DEVICECONTROL, /* Data from a CyAsStorageDeviceControl call. */
+ CY_FUNCT_CB_STOR_SDREGISTERREAD, /* Data from a CyAsStorageSDRegisterRead call. */
+ CY_FUNCT_CB_STOR_PARTITION, /* Data from a CyAsStorageCreatePartition call. */
+ CY_FUNCT_CB_STOR_GETTRANSFERAMOUNT, /* Data from a CyAsStorageGetTransferAmount call. */
+ CY_FUNCT_CB_STOR_ERASE, /* Data from a CyAsStorageErase call. */
+ CY_FUNCT_CB_ABORT_P2S_XFER, /* Data from a CyAsStorageCancelAsync call. */
+ CY_FUNCT_CB_USB_START, /* Data from a CyAsUsbStart call. */
+ CY_FUNCT_CB_USB_STOP, /* Data from a CyAsUsbStop call. */
+ CY_FUNCT_CB_USB_CONNECT, /* Data from a CyAsUsbConnect call. */
+ CY_FUNCT_CB_USB_DISCONNECT, /* Data from a CyAsUsbDisconnect call. */
+ CY_FUNCT_CB_USB_SETENUMCONFIG, /* Data from a CyAsUsbSetEnumConfig call. */
+ CY_FUNCT_CB_USB_GETENUMCONFIG, /* Data from a CyAsUsbGetEnumConfig call. */
+ CY_FUNCT_CB_USB_SETDESCRIPTOR, /* Data from a CyAsUsbSetDescriptor call. */
+ CY_FUNCT_CB_USB_GETDESCRIPTOR, /* Data from a CyAsUsbGetDescriptor call. */
+ CY_FUNCT_CB_USB_COMMITCONFIG, /* Data from a CyAsUsbCommitConfig call. */
+ CY_FUNCT_CB_USB_GETNAK, /* Data from a CyAsUsbGetNak call. */
+ CY_FUNCT_CB_USB_GETSTALL, /* Data from a CyAsUsbGetStall call. */
+ CY_FUNCT_CB_USB_SIGNALREMOTEWAKEUP, /* Data from a CyAsUsbSignalRemoteWakeup call. */
+ CY_FUNCT_CB_USB_CLEARDESCRIPTORS, /* Data from a CyAnUsbClearDescriptors call. */
+ CY_FUNCT_CB_USB_SET_MSREPORT_THRESHOLD, /* Data from a CyAnUsbSetMSReportThreshold call. */
+ CY_FUNCT_CB_MTP_START, /* Data from a CyAsMTPStart call. */
+ CY_FUNCT_CB_MTP_STOP, /* Data from a CyAsMTPStop call. */
+ CY_FUNCT_CB_MTP_INIT_SEND_OBJECT, /* Data from a CyAsMTPInitSendObject call. */
+ CY_FUNCT_CB_MTP_CANCEL_SEND_OBJECT, /* Data from a CyAsMTPCancelSendObject call. */
+ CY_FUNCT_CB_MTP_INIT_GET_OBJECT, /* Data from a CyAsMTPInitGetObject call. */
+ CY_FUNCT_CB_MTP_CANCEL_GET_OBJECT, /* Data from a CyAsMTPCancelGetObject call. */
+ CY_FUNCT_CB_MTP_SEND_BLOCK_TABLE, /* Data from a CyAsMTPSendBlockTable call. */
+ CY_FUNCT_CB_MTP_STOP_STORAGE_ONLY, /* Data from a CyAsMTPStopStorageOnly call. */
+ CY_FUNCT_CB_NODATA = 0x40000000U,
+ CY_FUNCT_CB_DATA = 0x20000000U
+} CyAsFunctCBType ;
+
+/* Summary
+ This type specifies the general West Bridge function callback.
+
+ Description
+ This callback is supplied as an argument to all asynchronous functions in the API. It is
+ called after the asynchronous function has completed.
+
+ See Also
+ CyAsFunctCBType
+*/
+typedef void (*CyAsFunctionCallback)(
+ CyAsDeviceHandle handle,
+ CyAsReturnStatus_t status,
+ uint32_t client,
+ CyAsFunctCBType type,
+ void* data) ;
+
+/* Summary
+ This type specifies the general West Bridge event that has occurred.
+
+ Description
+ This type is used in the West Bridge misc callback function to indicate the type
+ of callback.
+
+ See Also
+*/
+typedef enum CyAsMiscEventType
+{
+ CyAsEventMiscInitialized = 0, /* This event is sent when West Bridge has finished
+ initialization and is ready to respond to
+ API calls. */
+
+ CyAsEventMiscAwake, /* This event is sent when West Bridge has left the
+ standby state and is ready to respond to commands
+ again. */
+
+ CyAsEventMiscHeartBeat, /* This event is sent periodically from the firmware
+ to the processor. */
+
+ CyAsEventMiscWakeup, /* This event is sent when the West Bridge has left the
+ suspend mode and is ready to respond to commands
+ again. */
+
+ CyAsEventMiscDeviceMismatch /* This event is sent when the firmware image downloaded
+ cannot run on the active West Bridge device. */
+} CyAsMiscEventType ;
+
+/* Summary
+ This type is the type of a callback function that is called when a West Bridge misc event occurs.
+
+ Description
+ At times West Bridge needs to inform the P port processor of events that have
+ occurred. These events are asynchronous to the thread of control on the P
+ port processor and as such are generally delivered via a callback function that
+ is called as part of an interrupt handler. This type defines the type of function
+ that must be provided as a callback function for West Bridge misc events.
+
+ See Also
+ * CyAsMiscEventType
+*/
+typedef void (*CyAsMiscEventCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsMiscEventType ev, /* The event type being reported */
+ void * evdata /* The data assocaited with the event being reported */
+) ;
+
+#ifndef __doxygen__
+/* Summary
+ This enum provides info of various firmware trace levels.
+
+ Description
+
+ See Also
+ * CyAsMiscSetTraceLevel
+*/
+enum {
+ CYAS_FW_TRACE_LOG_NONE = 0, /* Log nothing. */
+ CYAS_FW_TRACE_LOG_STATE, /* Log state information. */
+ CYAS_FW_TRACE_LOG_CALLS, /* Log function calls. */
+ CYAS_FW_TRACE_LOG_STACK_TRACE, /* Log function calls with args. */
+ CYAS_FW_TRACE_MAX_LEVEL /* Max trace level sentinel. */
+};
+#endif
+
+/* Summary
+ This enum lists the controllable GPIOs of the West Bridge device.
+
+ Description
+ The West Bridge device has GPIOs that can be used for user defined functions.
+ This enumeration lists the GPIOs that are available on the device.
+
+ Notes
+ All of the GPIOs except UVALID can only be accessed when using West Bridge
+ firmware images that support only SD/MMC/MMC+ storage devices. This
+ functionality is not supported in firmware images that support NAND
+ storage.
+
+ See Also
+ * CyAsMiscGetGpioValue
+ * CyAsMiscSetGpioValue
+ */
+typedef enum {
+ CyAsMiscGpio_0 = 0, /* GPIO[0] pin */
+ CyAsMiscGpio_1, /* GPIO[1] pin */
+ CyAsMiscGpio_Nand_CE, /* NAND_CE pin, output only */
+ CyAsMiscGpio_Nand_CE2, /* NAND_CE2 pin, output only */
+ CyAsMiscGpio_Nand_WP, /* NAND_WP pin, output only */
+ CyAsMiscGpio_Nand_CLE, /* NAND_CLE pin, output only */
+ CyAsMiscGpio_Nand_ALE, /* NAND_ALE pin, output only */
+ CyAsMiscGpio_SD_POW, /* SD_POW pin, output only, do not drive low while storage is active */
+ CyAsMiscGpio_UValid /* UVALID pin */
+} CyAsMiscGpio;
+
+/* Summary
+ This enum lists the set of clock frequencies that are supported for working
+ with low speed SD media.
+
+ Description
+ West Bridge firmware uses a clock frequency less than the maximum possible rate
+ for low speed SD media. This can be changed to a setting equal to the maximum
+ frequency as desired by the user. This enumeration lists the different
+ frequency settings that are supported.
+
+ See Also
+ * CyAsMiscSetLowSpeedSDFreq
+ */
+typedef enum CyAsLowSpeedSDFreq
+{
+ CY_AS_SD_DEFAULT_FREQ = 0, /* Approx. 21.82 MHz, default value */
+ CY_AS_SD_RATED_FREQ /* 24 MHz */
+} CyAsLowSpeedSDFreq ;
+
+/* Summary
+ This enum lists the set of clock frequencies that are supported for working
+ with high speed SD media.
+
+ Description
+ West Bridge firmware uses a 48 MHz clock by default to interface with high speed
+ SD/MMC media. This can be changed to 24 MHz if so desired by the user. This enum
+ lists the different frequencies that are supported.
+
+ See Also
+ * CyAsMiscSetHighSpeedSDFreq
+ */
+typedef enum CyAsHighSpeedSDFreq
+{
+ CY_AS_HS_SD_FREQ_48, /* 48 MHz, default value */
+ CY_AS_HS_SD_FREQ_24 /* 24 MHz */
+} CyAsHighSpeedSDFreq ;
+
+/* Summary
+ Struct encapsulating all information returned by the CyAsMiscGetFirmwareVersion call.
+
+ Description
+ This struct encapsulates all return values from the asynchronous
+ CyAsMiscGetFirmwareVersion call, so that a single data argument can be
+ passed to the user provided callback function.
+
+ See Also
+ * CyAsMiscGetFirmwareVersion
+ */
+typedef struct CyAsGetFirmwareVersionData
+{
+ uint16_t major; /* Return value for major version number for the firmware */
+ uint16_t minor; /* Return value for minor version number for the firmware */
+ uint16_t build; /* Return value for build version number for the firmware */
+ uint8_t mediaType; /* Return value for media types supported in the current firmware */
+ CyBool isDebugMode; /* Return value to indicate the release or debug mode of firmware */
+} CyAsGetFirmwareVersionData ;
+
+
+/*****************************************************************************
+ * West Bridge Functions
+ ****************************************************************************/
+
+/* Summary
+ This function creates a new West Bridge device and returns a handle to the device.
+
+ Description
+ This function initializes the API object that represents the West Bridge device and
+ returns a handle to this device. This handle is required for all West Bridge related
+ functions to identify the specific West Bridge device.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_OUT_OF_MEMORY
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscCreateDevice(
+ CyAsDeviceHandle * handle_p, /* Return value for handle to created device */
+ CyAsHalDeviceTag tag /* The HAL specific tag for this device */
+ ) ;
+
+/* Summary
+ This functions destroys a previously created West Bridge device.
+
+ Description
+ When an West Bridge device is created, an opaque handle is returned that represents
+ the device. This function destroys that handle and frees all resources associated
+ with the handle.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_STILL_RUNNING - The USB or STORAGE stacks are still running, they must be stopped before the device can be destroyed
+ * CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED - the HAL layer failed to destroy a sleep channel
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscDestroyDevice(
+ CyAsDeviceHandle handle /* Handle to the device to destroy */
+ ) ;
+
+/* Summary
+ This function initializes the hardware for basic communication with West Bridge.
+
+ Description
+ This function intializes the hardware to establish basic communication with
+ the West Bridge device. This is always the first function called to initialize
+ communication with the West Bridge device.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the basic initialization was completed
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_IN_STANDBY
+ * CY_AS_ERROR_ALREADY_RUNNING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_NO_ANTIOCH - cannot find the West Bridge device
+ * CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED - the HAL layer falied to create a sleep channel
+
+ See Also
+ * CyAsDeviceConfig
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscConfigureDevice(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsDeviceConfig *config_p /* Configuration information */
+ ) ;
+
+/* Summary
+ This function returns non-zero if West Bridge is in standby and zero otherwise.
+
+ Description
+ West Bridge supports a standby mode. This function is used to query West Bridge to determine
+ if West Bridge is in a standby mode.
+
+ * Valid In Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscInStandby(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyBool *standby /* Return value for standby state */
+ ) ;
+
+/* Summary
+ This function downloads the firmware to West Bridge device.
+
+ Description
+ This function downloads firmware from a given location and with a given size
+ to the West Bridge device. After the firmware is downloaded the West Bridge device is
+ moved out of configuration mode causing the firmware to be executed. It is an
+ error to call this function when the device is not in configuration mode. The
+ device is in configuration mode on power up and may be placed in configuration
+ mode after power up with a hard reset.
+
+ Notes
+ The firmware must be on a word align boundary.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the firmware was sucessfully downloaded
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device was not configured
+ * CY_AS_ERROR_NOT_IN_CONFIG_MODE
+ * CY_AS_ERROR_INVALID_SIZE - the size of the firmware exceeded 32768 bytes
+ * CY_AS_ERROR_ALIGNMENT_ERROR
+ * CY_AS_ERROR_IN_STANDBY - trying to download while in standby mode
+ * CY_AS_ERROR_TIMEOUT
+
+ See Also
+ * CyAsMiscReset
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscDownloadFirmware(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ const void *fw_p, /* Pointer to the firmware to be downloaded */
+ uint16_t size, /* The size of the firmware in bytes */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+
+/* Summary
+ This function returns the version number of the firmware running in the West Bridge device.
+
+ Description
+ This function queries the West Bridge device and retreives the firmware version number. If
+ the firmware is not loaded an error is returned indicated no firmware has been loaded.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the firmware version number was retreived
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been downloaded to the device
+ * CY_AS_ERROR_IN_STANDBY
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscGetFirmwareVersion(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsGetFirmwareVersionData* data, /* Return values indicating the firmware version. */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+#if !defined(__doxygen__)
+
+/* Summary
+ This function reads and returns the contents of an MCU accessible register on the West Bridge.
+
+ Description
+ This function requests the firmware to read and return the contents of an MCU accessible
+ register through the mailboxes.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the register content was retrieved.
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+ * CY_AS_ERROR_INVALID_RESPONSE - the firmware build does not support this command.
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscReadMCURegister(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ uint16_t address, /* Address of the register to read */
+ uint8_t *value, /* Return value for the MCU register content */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function writes to an MCU accessible register on the West Bridge.
+
+ Description
+ This function requests the firmware to write a specified value to an MCU accessible
+ register through the mailboxes.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ This function is only for internal use by the West Bridge API layer. Calling
+ this function directly can cause device malfunction.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the register content was updated.
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+ * CY_AS_ERROR_INVALID_RESPONSE - the firmware build does not support this command.
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscWriteMCURegister(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ uint16_t address, /* Address of the register to write */
+ uint8_t mask, /* Mask to be applied on the register contents. */
+ uint8_t value, /* Data to be ORed with the register contents. */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+#endif
+
+/* Summary
+ This function will reset the West Bridge device and software API.
+
+ Description
+ This function will reset the West Bridge device and software API. The reset operation can be
+ a hard reset or a soft reset. A hard reset will reset all aspects of the West Bridge device.
+ The device will enter the configuration state and the firmware will have to be reloaded. The
+ device will also have to be re-initialized. A soft reset just resets the West Bridge micro-
+ controller.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ When a hard reset is issued, the firmware that may have been previously loaded will be lost
+ and any configuration information set via CyAsMiscConfigureDevice() will be lost. This will be
+ reflected in the API maintained state of the device. In order to re-establish communications
+ with the West Bridge device, CyAsMiscConfigureDevice() and CyAsMiscDownloadFirmware() must be
+ called again.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the device has been reset
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_NOT_YET_SUPPORTED - current soft reset is not supported
+ * CY_AS_ERROR_ASYNC_PENDING - Reset is unable to flush pending async reads/writes in polling mode.
+
+
+ See Also
+ * CyAsMiscReset
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscReset(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsResetType type, /* The type of reset to perform */
+ CyBool flush, /* If true, flush all pending writes to mass storage
+ before performing the reset. */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function acquires a given resource.
+
+ Description
+ There are resources in the system that are shared between the West Bridge device and the processor
+ attached to the P port of the West Bridge device. This API provides a mechanism for the P port
+ processor to acquire ownership of a resource.
+
+ Notes
+ The ownership of the resources controlled by CyAsMiscAcquireResource() and CyAsMiscReleaseResource()
+ defaults to a known state at hardware reset. After the firmware is loaded and begins execution the
+ state of these resources may change. At any point if the P Port processor needs to acquire a resource
+ it should do so explicitly to be sure of ownership.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the p port sucessfully acquired the resource of interest
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_INVALID_RESOURCE
+ * CY_AS_ERROR_RESOURCE_ALREADY_OWNED - the p port already owns this resource
+ * CY_AS_ERROR_NOT_ACQUIRED - the resource cannot be acquired
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+
+ See Also
+ * CyAsResourceType
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscAcquireResource(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsResourceType *resource, /* The resource to acquire */
+ CyBool force, /* If true, force West Bridge to release the resource */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function releases a given resource.
+
+ Description
+ There are resources in the system that are shared between the West Bridge device and the processor
+ attached to the P port of the West Bridge device. This API provides a mechanism for the P port
+ processor to release a resource that has previously been acquired via the CyAsMiscAcquireResource()
+ call.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the p port sucessfully released the resource of interest
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_INVALID_RESOURCE
+ * CY_AS_ERROR_RESOURCE_NOT_OWNED - the p port does not own the resource of interest
+
+ See Also
+ * CyAsResourceType
+ * CyAsMiscAcquireResource
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscReleaseResource(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsResourceType resource /* The resource to release */
+ ) ;
+
+#ifndef __doxygen__
+/* Summary
+ This function sets the trace level for the West Bridge firmware.
+
+ Description
+ The West Bridge firmware has the ability to store information about the state and execution path
+ of the firmware on a mass storage device attached to the West Bridge device. This function
+ configures the specific mass storage device to be used and the type of information to be
+ stored. This state information is used for debugging purposes and must be interpreted by a
+ Cypress provided tool.
+
+ *Trace Level*
+ The trace level indicates the amount of information to output.
+ * 0 = no trace information is output
+ * 1 = state information is output
+ * 2 = function call information is output
+ * 3 = function call, arguments, and return value information is output
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ The media device and unit specified in this call will be overwritten and any data currently stored
+ on this device and unit will be lost.
+
+ * NOT IMPLEMENTED YET
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the trace configuration has been sucessfully changed
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_NO_SUCH_UNIT - the unit specified does not exist
+ * CY_AS_ERROR_INVALID_TRACE_LEVEL - the trace level requested does not exist
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetTraceLevel(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ uint8_t level, /* The trace level */
+ CyAsBusNumber_t bus, /* The bus for the output */
+ uint32_t device, /* The device for the output */
+ uint32_t unit, /* The unit for the output */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+#endif
+
+/* Summary
+ This function places West Bridge into the low power standby mode.
+
+ Description
+ This function places West Bridge into a low power (sleep) mode, and cannot be called while the
+ USB stack is active. This function first instructs the West Bridge firmware that the device is
+ about to be placed into sleep mode. This allows West Bridge to complete any pending storage
+ operations. After the West Bridge device has responded that pending operations are complete,
+ the device is placed in standby mode.
+
+ There are two methods of placing the device in standby mode. If the WAKEUP pin of the West Bridge
+ is connected to a GPIO on the processor, the pin is de-asserted (via the HAL layer) and West Bridge
+ enters into a sleep mode. If the WAKEUP pin is not accessible, the processor can write into
+ the power management control/status register on the West Bridge to put the device into sleep mode.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function completed and West Bridge is in sleep mode
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_ALREADY_STANDBY - the West Bridge device is already in sleep mode
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+ * CY_AS_ERROR_NOT_SUPPORTED - the HAL layer does not support changing the WAKEUP pin
+ * CY_AS_ERROR_USB_RUNNING - The USB stack is still running when the EnterStandby call is made
+ * CY_AS_ERROR_ASYNC_PENDING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_SETTING_WAKEUP_PIN
+ * CY_AS_ERROR_ASYNC_PENDING - In polling mode EnterStandby can not be called until all pending
+ storage read/write requests have finished.
+
+ See Also
+ * CyAsMiscLeaveStandby
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscEnterStandbyEXU(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyBool pin, /* If true, use the wakeup pin, otherwise use the register */
+ CyBool uvalid_special, /* Set true to enable specific usages of the
+ UVALID signal, please refer to AN xx or ERRATA xx */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function is provided for backwards compatibility.
+
+ Description
+ Calling this function is the same as calling CyAsMiscEnterStandbyEx with True for the lowpower parameter.
+
+ See Also
+ * CyAsMiscEnterStandbyEx
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscEnterStandby(CyAsDeviceHandle handle,
+ CyBool pin,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function brings West Bridge out of sleep mode.
+
+ Description
+ This function asserts the WAKEUP pin (via the HAL layer). This brings the West Bridge out of the sleep
+ state and allows the West Bridge firmware to process the event causing the wakeup. When all processing
+ associated with the wakeup is complete, a callback function is called to tell the P port software that
+ the firmware processing associated with wakeup is complete.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns:
+ * CY_AS_ERROR_SUCCESS - the function completed and West Bridge is in sleep mode
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_SETTING_WAKEUP_PIN
+ * CY_AS_ERROR_NOT_IN_STANDBY - the West Bridge device is not in the sleep state
+ * CY_AS_ERROR_TIMEOUT - there was a timeout waiting for a response from the West Bridge firmware
+ * CY_AS_ERROR_NOT_SUPPORTED - the HAL layer does not support changing the WAKEUP pin
+
+ See Also
+ * CyAsMiscEnterStandby
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscLeaveStandby(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsResourceType resource /* The resource causing the wakeup */
+ ) ;
+
+/* Summary
+ This function registers a callback function to be called when an asynchronous West Bridge MISC event occurs.
+
+ Description
+ When asynchronous misc events occur, a callback function can be called to alert the calling program. This
+ functions allows the calling program to register a callback.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns:
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscRegisterCallback(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsMiscEventCallback callback /* The function to call */
+ ) ;
+
+/* Summary
+ This function sets the logging level for log messages.
+
+ Description
+ The API can print messages via the CyAsHalPrintMessage capability. This function sets the
+ level of detail seen when printing messages from the API.
+
+ * Valid In Asynchronous Callback:NO
+*/
+EXTERN void
+CyAsMiscSetLogLevel(
+ uint8_t level /* Level to set, 0 is fewer messages, 255 is all */
+ ) ;
+
+
+/* Summary
+ This function tells West Bridge that SD or MMC media has been inserted or removed.
+
+ Description
+ In some hardware configurations, SD or MMC media detection is handled outside of the
+ West Bridge device. This function is called when a change is detected to inform the
+ West Bridge firmware to check for storage media changes.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns:
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_IN_STANDBY
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsMiscStorageChanged
+
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscStorageChanged(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function instructs the West Bridge firmware to start/stop sending periodic
+ heartbeat messages to the processor.
+
+ Description
+ The West Bridge firmware can send heartbeat messages through the mailbox register
+ once every 500 ms. This message can be an overhead as it causes regular Mailbox
+ interrupts to happen, and is turned off by default. The message can be used to
+ test and verify that the West Bridge firmware is alive. This API can be used to
+ enable or disable the heartbeat message.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function completed successfully
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured yet
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the West Bridge device
+
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscHeartBeatControl(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyBool enable, /* Message enable/disable selection */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function gets the current state of a GPIO pin on the West Bridge device.
+
+ Description
+ The West Bridge device has GPIO pins that can be used for user defined functions.
+ This function gets the current state of the specified GPIO pin. Calling this
+ function will configure the corresponding pin as an input.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ Only GPIO[0], GPIO[1] and UVALID pins can be used as GP inputs. Of these pins,
+ only the UVALID pin is supported by firmware images that include NAND storage
+ support.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function completed successfully
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured yet
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the West Bridge device
+ * CY_AS_ERROR_BAD_INDEX - an invalid GPIO was specified
+ * CY_AS_ERROR_NOT_SUPPORTED - this feature is not supported by the firmware
+
+ See Also
+ * CyAsMiscGpio
+ * CyAsMiscSetGpioValue
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscGetGpioValue(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsMiscGpio pin, /* Id of the GPIO pin to query */
+ uint8_t *value, /* Current value of the GPIO pin */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ This function updates the state of a GPIO pin on the West Bridge device.
+
+ Description
+ The West Bridge device has GPIO pins that can be used for user defined functions.
+ This function updates the output value driven on a specified GPIO pin. Calling this
+ function will configure the corresponding pin as an output.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ All of the pins listed under CyAsMiscGpio can be used as GP outputs. This feature
+ is note supported by firmware images that include NAND storage device support.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function completed successfully
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured yet
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the West Bridge device
+ * CY_AS_ERROR_BAD_INDEX - an invalid GPIO was specified
+ * CY_AS_ERROR_NOT_SUPPORTED - this feature is not supported by firmware.
+
+ See Also
+ * CyAsMiscGpio
+ * CyAsMiscGetGpioValue
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetGpioValue(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsMiscGpio pin, /* Id of the GPIO pin to set */
+ uint8_t value, /* Value to be set on the GPIO pin */
+ CyAsFunctionCallback cb, /* Callback to call when the operation is complete. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ Set the West Bridge device in the low power suspend mode.
+
+ Description
+ The West Bridge device has a low power suspend mode where the USB core and the internal
+ microcontroller are powered down. This function sets the West Bridge device into this
+ low power mode. This mode can only be entered when there is no active USB connection;
+ i.e., when USB has not been connected or is suspended; and there are no pending USB
+ or storage asynchronous calls.
+ The device will exit the suspend mode and resume handling USB and processor requests
+ when any activity is detected on the CE#, D+/D- or GPIO[0] lines.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ The GPIO[0] pin needs to be configured as an input for the gpio wakeup to work.
+ This flag should not be enabled if the pin is being used as a GP output.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the device was placed in suspend mode.
+ * CY_AS_ERROR_INVALID_HANDLE - the West Bridge handle passed in is invalid.
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not yet been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - no firmware has been downloaded to the device.
+ * CY_AS_ERROR_IN_STANDBY - the device is already in sleep mode.
+ * CY_AS_ERROR_USB_CONNECTED - the USB connection is active.
+ * CY_AS_ERROR_ASYNC_PENDING - asynchronous storage/USB calls are pending.
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to allocate memory for the operation.
+ * CY_AS_ERROR_INVALID_RESPONSE - command not recognised by firmware.
+
+ See Also
+ * CyAsMiscLeaveSuspend
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscEnterSuspend(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyBool usb_wakeup_en, /* Control the USB wakeup source */
+ CyBool gpio_wakeup_en, /* Control the GPIO[0] wakeup source */
+ CyAsFunctionCallback cb, /* Callback to call when suspend mode entry is complete */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ Wake up the West Bridge device from suspend mode.
+
+ Description
+ This call wakes up the West Bridge device from suspend mode, and makes it ready
+ for accepting other commands from the API. A CyAsEventMiscWakeup event will
+ be delivered to the callback registered with CyAsMiscRegisterCallback to
+ indicate that the wake up is complete.
+
+ The CyAsEventMiscWakeup event will also be delivered if the wakeup happens
+ due to USB or GPIO activity.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the device was woken up from suspend mode.
+ * CY_AS_ERROR_INVALID_HANDLE - invalid device handle passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the device.
+ * CY_AS_ERROR_NOT_IN_SUSPEND - the device is not in suspend mode.
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to allocate memory for the operation.
+ * CY_AS_ERROR_TIMEOUT - failed to wake up the device.
+
+ See Also
+ * CyAsMiscEnterSuspend
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscLeaveSuspend(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* Callback to call when device has resumed operation. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ Reserve first numzones zones of nand device for storing processor boot image. LNA firmware works
+ on the first numzones zones of nand to enable the processor to boot.
+
+ Description
+ This function reserves first numzones zones of nand device for storing processor boot image.
+ This fonction MUST be completed before starting the storage stack for the setting to be taken
+ into account.
+
+ * Valid In Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - zones are reserved.
+
+*/
+EXTERN CyAsReturnStatus_t
+CyAsMiscReserveLNABootArea(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ uint8_t numzones, /* number of nand zones to reserve */
+ CyAsFunctionCallback cb, /* Callback to call when device has resumed operation. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* Summary
+ Select the clock frequency to be used when talking to low speed (non-high speed)
+ SD media.
+
+ Description
+ West Bridge firmware uses a clock frequency less than the maximum possible rate
+ for low speed SD media. This function selects the frequency setting from between
+ the default speed and the maximum speed. This fonction MUST be completed before
+ starting the storage stack for the setting to be taken into account.
+
+ * Valid in Asynchronous Callback: Yes (if cb is non-zero)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the operation completed successfully.
+ * CY_AS_ERROR_INVALID_HANDLE - invalid device handle passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the device.
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to allocate memory for the operation.
+ * CY_AS_ERROR_IN_SUSPEND - West Bridge is in low power suspend mode.
+ * CY_AS_ERROR_INVALID_PARAMETER - invalid frequency setting desired.
+ * CY_AS_ERROR_TIMEOUT - West Bridge device did not respond to the operation.
+ * CY_AS_ERROR_INVALID_RESPONSE - active firmware does not support the operation.
+
+ See Also
+ * CyAsLowSpeedSDFreq
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetLowSpeedSDFreq(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsLowSpeedSDFreq setting, /* Frequency setting desired for low speed SD cards */
+ CyAsFunctionCallback cb, /* Callback to call on completion */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ Select the clock frequency to be used when talking to high speed SD/MMC media.
+
+ Description
+ West Bridge firmware uses a 48 MHz clock to interface with high speed SD/MMC
+ media. This clock rate can be restricted to 24 MHz if desired. This function
+ selects the frequency setting to be used. This fonction MUST be completed before
+ starting the storage stack for the setting to be taken into account.
+
+ * Valid in Asynchronous Callback: Yes (if cb is non-zero)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the operation completed successfully.
+ * CY_AS_ERROR_INVALID_HANDLE - invalid device handle passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the device.
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to allocate memory for the operation.
+ * CY_AS_ERROR_IN_SUSPEND - West Bridge is in low power suspend mode.
+ * CY_AS_ERROR_INVALID_PARAMETER - invalid frequency setting desired.
+ * CY_AS_ERROR_TIMEOUT - West Bridge device did not respond to the operation.
+ * CY_AS_ERROR_INVALID_RESPONSE - active firmware does not support the operation.
+
+ See Also
+ * CyAsLowSpeedSDFreq
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetHighSpeedSDFreq(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsHighSpeedSDFreq setting, /* Frequency setting desired for high speed SD cards */
+ CyAsFunctionCallback cb, /* Callback to call on completion */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+/* Summary
+ Select the polarity of the SD_POW output driven by West Bridge.
+
+ Description
+ The SD_POW signal driven by West Bridge can be used to control the supply
+ of Vcc to the SD/MMC media connected to the device. This signal is driven
+ as an active high signal by default. This function can be used to change the
+ polarity of this signal if required. This fonction MUST be completed before
+ starting the storage stack for the setting to be taken into account.
+
+ * Valid in Asynchronous Callback: Yes (if cb is non-zero)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the operation completed successfully.
+ * CY_AS_ERROR_INVALID_HANDLE - invalid device handle passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - firmware has not been downloaded to the device.
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to allocate memory for the operation.
+ * CY_AS_ERROR_IN_SUSPEND - West Bridge is in low power suspend mode.
+ * CY_AS_ERROR_INVALID_PARAMETER - invalid frequency setting desired.
+ * CY_AS_ERROR_TIMEOUT - West Bridge device did not respond to the operation.
+ * CY_AS_ERROR_INVALID_RESPONSE - active firmware does not support the operation.
+
+ See Also
+ * CyAsMiscSignalPolarity
+ */
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetSDPowerPolarity(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsMiscSignalPolarity polarity, /* Desired polarity setting to the SD_POW signal. */
+ CyAsFunctionCallback cb, /* Callback to call on completion. */
+ uint32_t client /* Client data to be passed to the callback. */
+ ) ;
+
+/* For supporting deprecated functions */
+#include "cyasmisc_dep.h"
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASMISC_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasmisc_dep.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,53 @@
+/* Cypress West Bridge API header file (cyasmisc_dep.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/* This header will contain Antioch specific declaration
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility with prior releases
+ * of the Antioch SDK.
+ */
+#ifndef __INCLUDED_CYASMISC_DEP_H__
+#define __INCLUDED_CYASMISC_DEP_H__
+
+#ifndef __doxygen__
+
+EXTERN CyAsReturnStatus_t
+CyAsMiscAcquireResource_dep(CyAsDeviceHandle handle,
+ CyAsResourceType resource,
+ CyBool force);
+EXTERN CyAsReturnStatus_t
+CyAsMiscGetFirmwareVersion_dep(CyAsDeviceHandle handle,
+ uint16_t *major,
+ uint16_t *minor,
+ uint16_t *build,
+ uint8_t *mediaType,
+ CyBool *isDebugMode);
+EXTERN CyAsReturnStatus_t
+CyAsMiscSetTraceLevel_dep(CyAsDeviceHandle handle,
+ uint8_t level,
+ CyAsMediaType media,
+ uint32_t device,
+ uint32_t unit,
+ CyAsFunctionCallback cb,
+ uint32_t client);
+#endif /*__doxygen*/
+
+#endif /*__INCLUDED_CYANSTORAGE_DEP_H__*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasmtp.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,602 @@
+/* Cypress West Bridge API header file (cyasmtp.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASMTP_H_
+#define _INCLUDED_CYASMTP_H_
+
+#include "cyasmisc.h"
+
+#include "cyas_cplus_start.h"
+
+/*@@Media Transfer Protocol (MTP) Overview
+ Summary
+ The MTP API has been designed to allow MTP enabled West Bridge devices to implement
+ the MTP protocol while maintaining high performance. West Bridge has the capability
+ to enter into a Turbo mode during a MTP SendObject or GetObject operation enabling
+ it to directly stream the data into or out of the attached SD card with minimal
+ involvement from the Processor.
+
+ Description
+ The MTP API is designed to act as a pass through implementation of the MTP protocol
+ for all operations. Each MTP transaction received from the Host is passed through West Bridge
+ and along to the Processor. The Processor can then respond to the transaction and pass
+ data and/or responses back to the Host through West Bridge.
+
+ The MTP API also allows for a high speed handling of MTP SendObject and GetObject operations,
+ referred to as Turbo MTP. During a Turbo MTP operation West Bridge is responsible for reading
+ or writing the data for the MTP operation directly from or to the SD card with minimal
+ interaction from the Processor. The is done by having the Processor transfer a Block Table
+ to West Bridge which contains the locations on the SD card that need to be read or written.
+ During the handling of a Turbo Operation the Processor will then only periodically need to send
+ a new Block Table to West Bridge when the first is used up. See the CyAsMTPInitSendObject and
+ CyAsMTPInitGetObject functions for more details.
+
+ In order to enable the MTP API you must first have a MTP enabled West Bridge loaded with
+ MTP firmware. You then must start the USB and Storage APIs before starting the MTP API. See
+ CyAsMTPStart for more details.
+*/
+
+/*@@Endpoints
+ Summary
+ When using MTP firmware endpoints 2 and 6 are dedicated to bulk MTP traffic
+ and endpoint 1 is available for MTP events.
+
+ Description
+ When using a MTP enabled West Brdige device endpoints 2 and 6 are made available for
+ use to implement the MTP protocol. These endpoints have a few special restrictions noted
+ below but otherwise the existing USB APIs can be used normally with these endpoints.
+
+ 1. CyAsUsbSetNak, CyAsUsbClearNak, and CyAsUsbGetNak are disabled for these endpoints
+ 2. During a turbo operation CyAsUsbSetStall, CyAsUsbClearStall, and CyAsUsbGetStall are disabled.
+
+*/
+
+
+/* Summary
+ This constants defines the maximum number of
+ entries in the Block Table used to describe
+ the locations for Send/GetObject operations.
+
+ See Also
+ * CyAsMtpSendObject
+ * CyAsMtpGetObject
+*/
+#define CY_AS_MAX_BLOCK_TABLE_ENTRIES 64
+
+/* Summary
+ Endpoint to be used for MTP reads from the USB host.
+ */
+#define CY_AS_MTP_READ_ENDPOINT (2)
+
+/* Summary
+ Endpoint to be used fro MTP writes to the USB host.
+ */
+#define CY_AS_MTP_WRITE_ENDPOINT (6)
+
+/*****************************************************************************
+ * MTP Types
+ ****************************************************************************/
+
+/* Summary
+ The BlockTable used for turbo operations.
+
+ Description
+ This struct is used to specify the blocks
+ to be used for both read/write and send/getObject
+ operations.
+
+ The start block is a starting Logical Block Address
+ and num block is the number of blocks in that contiguous
+ region.
+
+ start_blocks[i]->[-------] <- start_blocks[i] + num_blocks[i]
+
+ If you need fewer than CY_AS_MAX_BLOCK_TABLE_ENTRIES
+ the remainder should be left empty. Empty is defined
+ as num_blocks equal to 0.
+
+ See Also
+ * CyAsMTPInitSendObject
+ * CyAsMTPInitGetObject
+
+*/
+typedef struct CyAsMTPBlockTable
+{
+ uint32_t start_blocks[CY_AS_MAX_BLOCK_TABLE_ENTRIES] ;
+ uint16_t num_blocks[CY_AS_MAX_BLOCK_TABLE_ENTRIES] ;
+} CyAsMTPBlockTable ;
+
+/* Summary
+ This type specifies the type of MTP event that has occurred.
+
+ Description
+ MTP events are used to communicate that West Bridge has
+ either finished the handling of the given operation, or
+ that it requires additional data to complete the operation.
+
+ In no case does West Bridge send any MTP protocol responses,
+ this always remain the responsibility of the client.
+
+ See Also
+ * CyAsMTPInitSendObject
+ * CyAsMTPInitGetObject
+ * CyAsMTPSendBlockTable
+
+*/
+typedef enum CyAsMTPEvent
+{
+ CyAsMTPSendObjectComplete, /* This event is sent when West Bridge
+ has finished writing the data from a
+ SendObject. West Bridge will -not- send
+ the MTP response. */
+ CyAsMTPGetObjectComplete, /* This event is sent when West Bridge
+ has finished sending the data for a
+ GetObject operation. West Bridge will
+ -not- send the MTP response. */
+ CyAsMTPBlockTableNeeded /* This event is called when West Bridge
+ needs a new BlockTable. This is only a
+ notification, to transfer a BlockTable
+ to West Bridge the CyAsMTPSendBlockTable
+ use the function. While West Bridge is waiting
+ for a BlockTable during a SendObject it
+ may need to NAK the Endpoint. It is important
+ that the CyAsMTPSendBlockTable call is made
+ in a timely manner as eventually a delay
+ will result in an USB reset. This event has
+ no data */
+} CyAsMTPEvent ;
+
+/* Summary
+ Data for the CyAsMTPSendObjectComplete event.
+
+ Description
+ Notification that a SendObject operation has been completed. The
+ status of the operation is given (to distinguish between a cancelled
+ and a success for example) as well as the block count. The blocks
+ are used in order based on the current block table. If more than
+ one block table was used for a given SendObject the count will
+ include the total number of blocks written.
+
+ This callback will be made only once per SendObject operation
+ and it will only be called after all of the data has been
+ committed to the SD card.
+
+ See Also
+ * CyAsMTPEvent
+
+ */
+typedef struct CyAsMTPSendObjectCompleteData
+{
+ CyAsReturnStatus_t status ;
+ uint32_t byte_count ;
+ uint32_t transaction_id ;
+} CyAsMTPSendObjectCompleteData ;
+
+/* Summary
+ Data for the CyAsMTPGetObjectComplete event.
+
+ Description
+ Notification that a GetObject has finished. This
+ event allows the P side to know when to send the MTP
+ response for the GetObject operation.
+
+ See Also
+ * CyAsMTPEvent
+
+*/
+typedef struct CyAsMTPGetObjectCompleteData
+{
+ CyAsReturnStatus_t status ;
+ uint32_t byte_count ;
+} CyAsMTPGetObjectCompleteData ;
+
+/* Summary
+ MTP Event callback.
+
+ Description
+ Callback used to communicate that a SendObject
+ operation has finished.
+
+ See Also
+ * CyAsMTPEvent
+*/
+typedef void (*CyAsMTPEventCallback)(
+ CyAsDeviceHandle handle,
+ CyAsMTPEvent evtype,
+ void* evdata
+ ) ;
+
+/* Summary
+ This is the callback function called after asynchronous API functions have completed.
+
+ Description
+ When calling API functions from callback routines (interrupt handlers usually) the async version of
+ these functions must be used. This callback is called when an asynchronous API function has completed.
+*/
+typedef void (*CyAsMTPFunctionCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsReturnStatus_t status, /* The error status of the operation */
+ uint32_t client /* A client supplied 32 bit tag */
+) ;
+
+/*****************************************************************************
+ * MTP Functions
+ ****************************************************************************/
+
+/* Summary
+ This function starts the MTP stack.
+
+ Description
+ Initializes West Bridge for MTP activity and registers the MTP
+ event callback.
+
+ Before calling CyAsMTPStart, CyAsUsbStart and CyAsStorageStart must be
+ called (in either order).
+
+ MTPStart must be called before the device is enumerated. Please
+ see the documentation for CyAsUsbSetEnumConfig and CyAsUsbEnumControl
+ for details on enumerating a device for MTP.
+
+ Calling MTPStart will not affect any ongoing P<->S traffic.
+
+ This requires a MTP firmware image to be loaded on West Bridge.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_IN_SUSPEND
+ * CY_AS_ERROR_INVALID_IN_CALLBACK
+ * CY_AS_ERROR_STARTSTOP_PENDING
+ * CY_AS_ERROR_NOT_RUNNING - CyAsUsbStart or CyAsStorageStart have not been called
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+
+ See Also
+ * CyAsMTPStop
+ * CyAsUsbStart
+ * CyAsStorageStart
+ * CyAsUsbSetEnumConfig
+ * CyAsUsbEnumControl
+*/
+CyAsReturnStatus_t
+CyAsMTPStart(
+ CyAsDeviceHandle handle,
+ CyAsMTPEventCallback eventCB,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+
+/* Summary
+ This function stops the MTP stack.
+
+ Description
+ Stops all MTP activity. Any ongoing transfers are
+ canceled.
+
+ This will not cause a UsbDisconnect but all
+ MTP activity (both pass through and turbo) will
+ stop.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_IN_SUSPEND
+ * CY_AS_ERROR_INVALID_IN_CALLBACK
+ * CY_AS_ERROR_STARTSTOP_PENDING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+
+ See Also
+ * CyAsMTPStart
+*/
+CyAsReturnStatus_t
+CyAsMTPStop(
+ CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function sets up a Turbo SendObject operation.
+
+ Description
+ Calling this function will setup West Bridge to
+ enable Tubo handling of the next SendObject
+ operation received. This will pass down the initial
+ block table to the firmware and setup a direct u->s
+ write for the SendObject operation.
+
+ If this function is not called before a SendObject
+ operation is seen the SendObject operation and data
+ will be passed along to the P port like any other MTP
+ command. It would then be the responsibility of the
+ client to perform a normal StorageWrite call to
+ store the data on the SD card. N.B. This will be
+ very slow compared with the Turbo handling.
+
+ The completion of this function only signals that
+ West Bridge has been set up to receive the next SendObject
+ operation. When the SendObject operation has been fully
+ handled and the data written to the SD card a separate
+ event will be triggered.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_IN_SUSPEND
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_ASYNC_PENDING
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+
+ See Also
+ * CyAsMTPCancelSendObject
+ * CyAsMTPInitGetObject
+ * CyAsMTPEvent
+ * CyAsMTPSendBlockTable
+*/
+CyAsReturnStatus_t
+CyAsMTPInitSendObject(
+ CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* blk_table,
+ uint32_t num_bytes,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function cancels an ongoing MTP operation.
+
+ Description
+ Causes West Bridge to cancel an ongoing SendObject
+ operation. Note this is only a cancel to West Bridge,
+ the MTP operation still needs to be canceled by
+ sending a response.
+
+ West Bridge will automatically set a Stall on the endpoint
+ when the cancel is received.
+
+ This function is only valid after CyAsMTPInitSendObject
+ has been called, but before the CyAsMTPSendObjectComplete
+ event has been sent.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+ * CY_AS_ERROR_NO_OPERATION_PENDING
+
+ See Also
+ * CyAsMTPInitSendObject
+*/
+CyAsReturnStatus_t
+CyAsMTPCancelSendObject(
+ CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function sets up a turbo GetObject operation.
+
+ Description
+ Called by the P in response to a GetObject
+ operation. This provides West Bridge with the block
+ addresses for the Object data that needs to be
+ transferred.
+
+ It is the responsibility of the Processor to send the MTP operation
+ before calling CyAsMTPInitGetObject. West Bridge will then send the
+ data phase of the transaction, automatically creating the required container for
+ Data. Once all of the Data has been transferred a callback will be issued to
+ inform the Processor that the Data phase has completed allowing it to send
+ the required MTP response.
+
+ If an entire Block Table is used then after the
+ last block is transferred the CyAsMTPBtCallback
+ will be called to allow an additional Block Table(s)
+ to be specified.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_IN_SUSPEND
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_ASYNC_PENDING
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+
+ See Also
+ * CyAsMTPInitSendObject
+ * CyAsMTPCancelGetObject
+ * CyAsMTPEvent
+ * CyAsMTPSendBlockTable
+*/
+CyAsReturnStatus_t
+CyAsMTPInitGetObject(
+ CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* table_p,
+ uint32_t num_bytes,
+ uint32_t transaction_id,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function cancels an ongoing turbo GetObject
+ operation.
+
+ Description
+ Causes West Bridge to cancel an ongoing GetObject
+ operation. Note this is only a cancel to West Bridge,
+ the MTP operation still needs to be canceled by
+ sending a response.
+
+ This function is only valid after CyAsMTPGetSendObject
+ has been called, but before the CyAsMTPGetObjectComplete
+ event has been sent.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+ * CY_AS_ERROR_NO_OPERATION_PENDING
+
+ See Also
+ * CyAsMTPInitGetObject
+*/
+CyAsReturnStatus_t
+CyAsMTPCancelGetObject(
+ CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function is used to transfer a BlockTable as part of
+ an ongoing MTP operation.
+
+ Description
+ This function is called in response to the CyAsMTPBlockTableNeeded
+ event. This allows the client to pass in a BlockTable structure to
+ West Bridge.
+
+ The memory associated with the table will be copied and can be
+ safely disposed of when the function returns if called synchronously,
+ or when the callback is made if called asynchronously.
+
+ This function is used for both SendObject and GetObject as both
+ can generate the CyAsMTPBlockTableNeeded event.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_NOT_CONFIGURED
+ * CY_AS_ERROR_NO_FIRMWARE
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_IN_SUSPEND
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_ASYNC_PENDING
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_SUPPORTED - West Bridge is not running firmware with MTP support
+
+ See Also
+ * CyAsMTPInitSendObject
+ * CyAsMTPInitGetObject
+*/
+CyAsReturnStatus_t
+CyAsMTPSendBlockTable(
+ CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* table,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+/* Summary
+ This function is used to mark the start of a storage read/write burst from the
+ P port processor.
+
+ Description
+ This function is used to mark the start of a storage read/write burst from the
+ processor. All USB host access into the mass storage / MTP endpoints will be
+ blocked while the read/write burst is ongoing, and will be allowed to resume
+ only after CyAsMTPStorageOnlyStop is called. The burst mode is used to
+ reduce the firmware overhead due to configuring the internal data paths repeatedly,
+ and can help improve performance when a sequence of read/writes is performed in
+ a burst.
+
+ This function will not generate a special mailbox request, it will only set a flag
+ on the next Storage Read/Write operation. Until such a call is made West Bridge will
+ continue to accept incoming packets from the Host.
+
+ * Valid in Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_INVALID_HANDLE - Invalid West Bridge device handle was passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - Firmware is not active on West Bridge device.
+ * CY_AS_ERROR_NOT_RUNNING - Storage stack is not running.
+ * CY_AS_ERROR_SUCCESS - Burst mode has been started.
+
+ See Also
+ * CyAsStorageReadWriteBurstStop
+ */
+CyAsReturnStatus_t
+CyAsMTPStorageOnlyStart (
+ CyAsDeviceHandle handle /* Handle to the West Bridge device. */
+ );
+
+/* Summary
+ This function is used to mark the end of a storage read/write burst from the
+ P port processor.
+
+ Description
+ This function is used to mark the end of a storage read/write burst from the
+ processor. At this point, USB access to the mass storage / MTP endpoints on
+ the West Bridge device will be re-enabled.
+
+ * Valid in Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_INVALID_HANDLE - Invalid West Bridge device handle was passed in.
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured.
+ * CY_AS_ERROR_NO_FIRMWARE - Firmware is not active on West Bridge device.
+ * CY_AS_ERROR_NOT_RUNNING - Storage stack is not running.
+ * CY_AS_ERROR_INVALID_IN_CALLBACK - This API cannot be called from a callback.
+ * CY_AS_ERROR_OUT_OF_MEMORY - Failed to allocate memory to process the request.
+ * CY_AS_ERROR_TIMEOUT - Failed to send request to firmware.
+ * CY_AS_ERROR_SUCCESS - Burst mode has been stopped.
+
+ See Also
+ * CyAsStorageReadWriteBurstStart
+ */
+CyAsReturnStatus_t
+CyAsMTPStorageOnlyStop (
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device. */
+ CyAsFunctionCallback cb,
+ uint32_t client
+ );
+
+#include "cyas_cplus_end.h"
+
+#endif
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasregs.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,201 @@
+/* Cypress West Bridge API header file (cyasregs.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASREG_H_
+#define _INCLUDED_CYASREG_H_
+
+#if !defined(__doxygen__)
+
+#define CY_AS_MEM_CM_WB_CFG_ID (0x80)
+#define CY_AS_MEM_CM_WB_CFG_ID_VER_MASK (0x000F)
+#define CY_AS_MEM_CM_WB_CFG_ID_HDID_MASK (0xFFF0)
+#define CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE (0xA100)
+#define CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE (0x6800)
+#define CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE (0xA200)
+
+
+#define CY_AS_MEM_RST_CTRL_REG (0x81)
+#define CY_AS_MEM_RST_CTRL_REG_HARD (0x0003)
+#define CY_AS_MEM_RST_CTRL_REG_SOFT (0x0001)
+#define CY_AS_MEM_RST_RSTCMPT (0x0004)
+
+#define CY_AS_MEM_P0_ENDIAN (0x82)
+#define CY_AS_LITTLE_ENDIAN (0x0000)
+#define CY_AS_BIG_ENDIAN (0x0101)
+
+#define CY_AS_MEM_P0_VM_SET (0x83)
+#define CY_AS_MEM_P0_VM_SET_VMTYPE_MASK (0x0007)
+#define CY_AS_MEM_P0_VM_SET_VMTYPE_RAM (0x0005)
+#define CY_AS_MEM_P0_VM_SET_VMTYPE_SRAM (0x0007)
+#define CY_AS_MEM_P0_VM_SET_VMTYPE_VMWIDTH (0x0008)
+#define CY_AS_MEM_P0_VM_SET_VMTYPE_FLOWCTRL (0x0010)
+#define CY_AS_MEM_P0_VM_SET_IFMODE (0x0020)
+#define CY_AS_MEM_P0_VM_SET_CFGMODE (0x0040)
+#define CY_AS_MEM_P0_VM_SET_DACKEOB (0x0080)
+#define CY_AS_MEM_P0_VM_SET_OVERRIDE (0x0100)
+#define CY_AS_MEM_P0_VM_SET_INTOVERD (0x0200)
+#define CY_AS_MEM_P0_VM_SET_DRQOVERD (0x0400)
+#define CY_AS_MEM_P0_VM_SET_DRQPOL (0x0800)
+#define CY_AS_MEM_P0_VM_SET_DACKPOL (0x1000)
+
+
+#define CY_AS_MEM_P0_NV_SET (0x84)
+#define CY_AS_MEM_P0_NV_SET_WPSWEN (0x0001)
+#define CY_AS_MEM_P0_NV_SET_WPPOLAR (0x0002)
+
+#define CY_AS_MEM_PMU_UPDATE (0x85)
+#define CY_AS_MEM_PMU_UPDATE_UVALID (0x0001)
+#define CY_AS_MEM_PMU_UPDATE_USBUPDATE (0x0002)
+#define CY_AS_MEM_PMU_UPDATE_SDIOUPDATE (0x0004)
+
+#define CY_AS_MEM_P0_INTR_REG (0x90)
+#define CY_AS_MEM_P0_INTR_REG_MCUINT (0x0020)
+#define CY_AS_MEM_P0_INTR_REG_DRQINT (0x0800)
+#define CY_AS_MEM_P0_INTR_REG_MBINT (0x1000)
+#define CY_AS_MEM_P0_INTR_REG_PMINT (0x2000)
+#define CY_AS_MEM_P0_INTR_REG_PLLLOCKINT (0x4000)
+
+#define CY_AS_MEM_P0_INT_MASK_REG (0x91)
+#define CY_AS_MEM_P0_INT_MASK_REG_MMCUINT (0x0020)
+#define CY_AS_MEM_P0_INT_MASK_REG_MDRQINT (0x0800)
+#define CY_AS_MEM_P0_INT_MASK_REG_MMBINT (0x1000)
+#define CY_AS_MEM_P0_INT_MASK_REG_MPMINT (0x2000)
+#define CY_AS_MEM_P0_INT_MASK_REG_MPLLLOCKINT (0x4000)
+
+#define CY_AS_MEM_MCU_MB_STAT (0x92)
+#define CY_AS_MEM_P0_MCU_MBNOTRD (0x0001)
+
+#define CY_AS_MEM_P0_MCU_STAT (0x94)
+#define CY_AS_MEM_P0_MCU_STAT_CARDINS (0x0001)
+#define CY_AS_MEM_P0_MCU_STAT_CARDREM (0x0002)
+
+#define CY_AS_MEM_PWR_MAGT_STAT (0x95)
+#define CY_AS_MEM_PWR_MAGT_STAT_WAKEUP (0x0001)
+
+#define CY_AS_MEM_P0_RSE_ALLOCATE (0x98)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_SDIOAVI (0x0001)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_SDIOALLO (0x0002)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_NANDAVI (0x0004)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_NANDALLO (0x0008)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_USBAVI (0x0010)
+#define CY_AS_MEM_P0_RSE_ALLOCATE_USBALLO (0x0020)
+
+#define CY_AS_MEM_P0_RSE_MASK (0x9A)
+#define CY_AS_MEM_P0_RSE_MASK_MSDIOBUS_RW (0x0003)
+#define CY_AS_MEM_P0_RSE_MASK_MNANDBUS_RW (0x00C0)
+#define CY_AS_MEM_P0_RSE_MASK_MUSBBUS_RW (0x0030)
+
+#define CY_AS_MEM_P0_DRQ (0xA0)
+#define CY_AS_MEM_P0_DRQ_EP2DRQ (0x0004)
+#define CY_AS_MEM_P0_DRQ_EP3DRQ (0x0008)
+#define CY_AS_MEM_P0_DRQ_EP4DRQ (0x0010)
+#define CY_AS_MEM_P0_DRQ_EP5DRQ (0x0020)
+#define CY_AS_MEM_P0_DRQ_EP6DRQ (0x0040)
+#define CY_AS_MEM_P0_DRQ_EP7DRQ (0x0080)
+#define CY_AS_MEM_P0_DRQ_EP8DRQ (0x0100)
+#define CY_AS_MEM_P0_DRQ_EP9DRQ (0x0200)
+#define CY_AS_MEM_P0_DRQ_EP10DRQ (0x0400)
+#define CY_AS_MEM_P0_DRQ_EP11DRQ (0x0800)
+#define CY_AS_MEM_P0_DRQ_EP12DRQ (0x1000)
+#define CY_AS_MEM_P0_DRQ_EP13DRQ (0x2000)
+#define CY_AS_MEM_P0_DRQ_EP14DRQ (0x4000)
+#define CY_AS_MEM_P0_DRQ_EP15DRQ (0x8000)
+
+#define CY_AS_MEM_P0_DRQ_MASK (0xA1)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP2DRQ (0x0004)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP3DRQ (0x0008)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP4DRQ (0x0010)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP5DRQ (0x0020)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP6DRQ (0x0040)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP7DRQ (0x0080)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP8DRQ (0x0100)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP9DRQ (0x0200)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP10DRQ (0x0400)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP11DRQ (0x0800)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP12DRQ (0x1000)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP13DRQ (0x2000)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP14DRQ (0x4000)
+#define CY_AS_MEM_P0_DRQ_MASK_MEP15DRQ (0x8000)
+
+#define CY_AS_MEM_P0_EP2_DMA_REG (0xA2)
+#define CY_AS_MEM_P0_EPn_DMA_REG_COUNT_MASK (0x7FF)
+#define CY_AS_MEM_P0_EPn_DMA_REG_DMAVAL (1 << 12)
+#define CY_AS_MEM_P0_EP3_DMA_REG (0xA3)
+#define CY_AS_MEM_P0_EP4_DMA_REG (0xA4)
+#define CY_AS_MEM_P0_EP5_DMA_REG (0xA5)
+#define CY_AS_MEM_P0_EP6_DMA_REG (0xA6)
+#define CY_AS_MEM_P0_EP7_DMA_REG (0xA7)
+#define CY_AS_MEM_P0_EP8_DMA_REG (0xA8)
+#define CY_AS_MEM_P0_EP9_DMA_REG (0xA9)
+#define CY_AS_MEM_P0_EP10_DMA_REG (0xAA)
+#define CY_AS_MEM_P0_EP11_DMA_REG (0xAB)
+#define CY_AS_MEM_P0_EP12_DMA_REG (0xAC)
+#define CY_AS_MEM_P0_EP13_DMA_REG (0xAD)
+#define CY_AS_MEM_P0_EP14_DMA_REG (0xAE)
+#define CY_AS_MEM_P0_EP15_DMA_REG (0xAF)
+
+#define CY_AS_MEM_IROS_SLB_DATARET (0xC0)
+
+#define CY_AS_MEM_IROS_IO_CFG (0xC1)
+#define CY_AS_MEM_IROS_IO_CFG_GPIODRVST_MASK (0x0003)
+#define CY_AS_MEM_IROS_IO_CFG_GPIOSLEW_MASK (0x0004)
+#define CY_AS_MEM_IROS_IO_CFG_PPIODRVST_MASK (0x0018)
+#define CY_AS_MEM_IROS_IO_CFG_PPIOSLEW_MASK (0x0020)
+#define CY_AS_MEM_IROS_IO_CFG_SSIODRVST_MASK (0x0300)
+#define CY_AS_MEM_IROS_IO_CFG_SSIOSLEW_MASK (0x0400)
+#define CY_AS_MEM_IROS_IO_CFG_SNIODRVST_MASK (0x1800)
+#define CY_AS_MEM_IROS_IO_CFG_SNIOSLEW_MASK (0x2000)
+
+#define CY_AS_MEM_IROS_PLL_CFG (0xC2)
+
+#define CY_AS_MEM_IROS_PXB_DATARET (0xC3)
+
+#define CY_AS_MEM_PLL_LOCK_LOSS_STAT (0xC4)
+#define CY_AS_MEM_PLL_LOCK_LOSS_STAT_PLLSTAT (0x0800)
+
+#define CY_AS_MEM_IROS_SLEEP_CFG (0xC5)
+
+#define CY_AS_MEM_PNAND_CFG (0xDA)
+#define CY_AS_MEM_PNAND_CFG_IOWIDTH_MASK (0x0001)
+#define CY_AS_MEM_PNAND_CFG_IOWIDTH_8BIT (0x0000)
+#define CY_AS_MEM_PNAND_CFG_IOWIDTH_16BIT (0x0001)
+#define CY_AS_MEM_PNAND_CFG_BLKTYPE_MASK (0x0002)
+#define CY_AS_MEM_PNAND_CFG_BLKTYPE_SMALL (0x0002)
+#define CY_AS_MEM_PNAND_CFG_BLKTYPE_LARGE (0x0000)
+#define CY_AS_MEM_PNAND_CFG_EPABYTE_POS (4)
+#define CY_AS_MEM_PNAND_CFG_EPABYTE_MASK (0x0030)
+#define CY_AS_MEM_PNAND_CFG_EPABIT_POS (6)
+#define CY_AS_MEM_PNAND_CFG_EPABIT_MASK (0x00C0)
+#define CY_AS_MEM_PNAND_CFG_LNAEN_MASK (0x0100)
+
+#define CY_AS_MEM_P0_MAILBOX0 (0xF0)
+#define CY_AS_MEM_P0_MAILBOX1 (0xF1)
+#define CY_AS_MEM_P0_MAILBOX2 (0xF2)
+#define CY_AS_MEM_P0_MAILBOX3 (0xF3)
+
+#define CY_AS_MEM_MCU_MAILBOX0 (0xF8)
+#define CY_AS_MEM_MCU_MAILBOX1 (0xF9)
+#define CY_AS_MEM_MCU_MAILBOX2 (0xFA)
+#define CY_AS_MEM_MCU_MAILBOX3 (0xFB)
+
+#endif /* !defined(__doxygen__) */
+
+#endif /* _INCLUDED_CYASREG_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasstorage.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,2018 @@
+/* Cypress West Bridge API header file (cyasstorage.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASSTORAGE_H_
+#define _INCLUDED_CYASSTORAGE_H_
+
+#include "cyasmedia.h"
+#include "cyasmisc.h"
+#include "cyas_cplus_start.h"
+
+
+/*@@Storage APIs
+ Summary
+ This section documents the storage APIs supported by the West Bridge API.
+
+ Description
+ The storage API is based on some specific concepts which are referenced here.
+ * <LINK Storage API Overview>
+ * Addressing
+ * Ownership
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+
+/*@@Storage API Overview
+ Summary
+ Storage devices are identified by media type. Each media type is considered a
+ single logical device.
+
+ Description
+ Each media type has a consistent block size and consists
+ of a set of logical blocks numbered from 0 to N - 1 where N is the size of the
+ media type in blocks. The mass storage APIs defined below provide the
+ capability to query for devices that are present, and read/write data to/from
+ these devices.
+*/
+
+/*@@Addressing
+ Summary
+ Blocks within a storage device are address by a hierarchal block address. This
+ address consists of the bus number, physical device, logical unit, and finally
+ block address.
+
+ Description
+ While currently only a single device of each media type is supported, the address
+ space reserves space in the future for multiple devices of each type. Therefore
+ the second element of the address is the specific device being addressed within
+ a given device type. For this release of the software, this value will always be
+ zero to address the first device.
+
+ The third element of the address is the logical unit. A device being managed
+ by West Bridge can be partitioned into multiple logical units. This partition
+ information is stored on each device itself. Currently, one of the storage devices
+ managed by West Bridge can be partitioned into two logical units.
+
+ Finally a logical block address is given within the logical unit to address an
+ individual block.
+*/
+
+/*@@Ownership
+ Summary
+ While West Bridge supports concurrent block level operations from both the USB port and
+ the processor port, this is not desirable in most situations as the file system
+ contained on the storage media cannot be accessed concurrently. To insure access
+ by only one of USB and the processor, the West Bridge API provides for ownership of storage
+ devices based on media type.
+
+ Description
+ The processor requests ownership of a given media type by calling CyAsStorageClaim().
+ The firmware in West Bridge releases control of the media and signals the processor through
+ the event callback registered with CyAsStorageRegisterCallback(). The specific event is
+ the CyAsStorageProcessor. The processor can later release the media via a call to
+ CyAsStorageRelease(). This call is immediate and no callback is required.
+
+ If the processor has claimed storage and the USB port is connected, West Bridge will need to
+ claim the storage to manage the mass storage device. West Bridge requests the storage through
+ the event callback registered with CyAsStorageRegisterCallback(). The specific event is
+ CyAsStorageAntioch and is named as such to reflect the USB view of storage. This callback
+ is a request for the processor to release storage. The storage is not actually released
+ until the processor calls CyAsStorageRelease().
+
+ Note that the CyAsStorageAntioch is only sent when the USB storage device is enumerated and
+ NOT at every USB operation. The ownership of a given storage media type is assumed to belong
+ to the processor until the USB connection is established. At that point, the storage ownership
+ is transferred to West Bridge. After the USB connection is broken, ownership can be transferred
+ back to the processor.
+*/
+
+/*@@Asynchronous Versus Synchronous Operation
+ Summary
+ When read or write operations are performed to the storage devices, these operations may be
+ synchronous or asynchronous. A synchronous operation is an operation where the read or write
+ operation is requested and the function does not return until the operation is complete. This
+ type of function is the easiest to use but does not provide for optimal usage of the P port
+ processor time.
+
+ Description
+ An asynchronous operation is one where the function returns as soon as the request is started.
+ The specific read and write request will complete at some time in the future and the P port
+ processor will be notified via a callback function. While asynchronous functions provide for
+ much better usage of the CPU, these function have more stringent requirements for use. First,
+ any buffer use for data transfer must be valid from the function call to request the operation
+ through when the callback function is called. This basically implies that stack based buffers
+ are not acceptable for asynchronous calls. Second, error handling must be deferred until the
+ callback function is called indicating any kind of error that may have occurred.
+*/
+
+/*@@Partitioning
+ Summary
+ West Bridge API and firmware support the creation of up to two logical partitions on one
+ of the storage devices that are managed by West Bridge. The partitions are managed through
+ the CyAsStorageCreatePPartition and CyAsStorageRemovePPartition APIs.
+
+ Description
+ The CyAsStorageCreatePPartition API is used to divide the total storage on a storage
+ device into two logical units or partitions. Since the partition information is stored
+ on the storage device in a custom format, partitions should only be created on fixed
+ storage devices (i.e., no removable SD/MMC cards). Any data stored on the device
+ before the creation of the partition, is liable to be lost when a partition is created.
+
+ The CyAsStorageRemovePPartition API is used to remove the stored partition information,
+ so that all of the device's capacity is treated as a single partition again.
+
+ When a storage device with two partitions (units) is being enumerated as a mass storage
+ device through the West Bridge, it is possible to select the partitions to be made
+ visible to the USB host. This is done through the CyAsUsbSelectMSPartitions API.
+*/
+
+/*****************************************************************************
+ * West Bridge Constants
+ ****************************************************************************/
+
+/* Summary
+ This constants indicates a raw device access to the read/write functions
+
+ Description
+ When performing reading and writing operations on the storage devices attached
+ to West Bridge, there are cases where writes need to happen to raw devices, versus
+ the units contained within a device. This is specifically required to manage
+ the partitions within physical devices. This constant is used in calls to
+ CyAsStorageRead(), CyAsStorageReadAsync(), CyAsStorageWrite() and
+ CyAsStorageWriteAsync(), to indicate that the raw physical device is being
+ accessed and not any specific unit on the device.
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageReadAsync
+ * CyAsStorageWrite
+ * CyAsStorageWriteAsync
+*/
+#define CY_AS_LUN_PHYSICAL_DEVICE (0xffffffff)
+
+/* Summary
+ This constant represents the maximum DMA burst length supported on a storage
+ endpoint
+
+ Description
+ West Bridge reserves separate endpoints for accessing storage media through the
+ CyAsStorageRead() and CyAsStorageWrite() calls. The maximum size of these
+ endpoints is always 512 bytes, regardless of status and speed of the USB
+ connection.
+*/
+#define CY_AS_STORAGE_EP_SIZE (512)
+
+/*****************************************************************************
+ * West Bridge Types
+ ****************************************************************************/
+
+/* Summary
+ This type indicates the type of event in an event callback from West Bridge
+
+ Description
+ At times West Bridge needs to inform the P port processor of events that have
+ occurred. These events are asynchronous to the thread of control on the P
+ port processor and as such are generally delivered via a callback function that
+ is called as part of an interrupt handler. This type indicates the resonse for
+ the call to the callback function.
+
+ See Also
+ * CyAsStorageEventCallback
+ * CyAsStorageRegisterCallback
+*/
+typedef enum CyAsStorageEvent
+{
+ CyAsStorageAntioch, /* This event occurs when the West Bridge device has
+ detected a USB connect and has enumerated the
+ storage controlled by West Bridge to the USB port.
+ This event is the signal that the processor
+ needs to release the storage media. West Bridge will
+ not have control of the storage media until the
+ processor calls CyAsReleaseStorage() to release
+ the specific media. */
+
+ CyAsStorageProcessor, /* This event occurs when the processor has requested
+ ownership of a given media type and West Bridge has
+ released the media. This event is an indicator
+ that the transfer of ownership is complete and the
+ processor now owns the given media type. */
+
+ CyAsStorageRemoved, /* This event occurs when a removable media type has
+ been removed. */
+
+ CyAsStorageInserted, /* This event occurs when a removable media type has
+ been inserted. */
+
+ CyAsSdioInterrupt /* This event occurs when the West Bridge device ercieves an
+ interrrupt from an SDIO card */
+
+} CyAsStorageEvent ;
+
+/* Summary
+ This type gives the type of the operation in a storage operation callback
+
+ Description
+ This type is used in the callback function for asynchronous operation. This type
+ indicates whether it is a CyAsStorageRead() or CyAsStorageWrite() operation that
+ has completed.
+
+ See Also
+ * <LINK Asynchronous Versus Synchronous Operation>
+ * CyAsStorageRead
+ * CyAsStorageWrite
+*/
+typedef enum CyAsOperType
+{
+ CyAsOpRead, /* A data read operation */
+ CyAsOpWrite /* A data write operation */
+} CyAsOperType ;
+
+/* Summary
+ This data structure describes a specific type of media
+
+ Description
+ This data structure is the return value from the CyAsStorageQueryDevice
+ function. This structure provides information about the specific storage
+ device being queried.
+
+ See Also
+ * CyAsStorageQueryDevice
+*/
+typedef struct CyAsDeviceDesc
+{
+ CyAsMediaType type ; /* Type of device */
+ CyBool removable ; /* Is the device removable */
+ CyBool writeable ; /* Is the device writeable */
+ uint16_t block_size ; /* Basic block size for device */
+ uint32_t number_units ; /* Number of LUNs on the device */
+ CyBool locked ; /* Is the device password locked */
+ uint32_t erase_unit_size ; /* Size in bytes of an Erase Unit. Block erase operation
+ is only supported for SD storage, and the erase_unit_size
+ is invalid for all other kinds of storage. */
+} CyAsDeviceDesc ;
+
+/* Summary
+ This data structure describes a specific unit on a specific type of media
+
+ Description
+ This data structure is the return value from the CyAsStorageQueryUnit
+ function. This structure provides information about the specific unit.
+
+ See Also
+ * CyAsStorageQueryUnit
+*/
+typedef struct CyAsUnitDesc
+{
+ CyAsMediaType type ; /* Type of device */
+ uint16_t block_size ; /* Basic block size for device */
+ uint32_t start_block ; /* Physical start block for LUN */
+ uint32_t unit_size ; /* Number of blocks in the LUN */
+} CyAsUnitDesc ;
+
+/* Summary
+ This function type defines a callback to be called after an asynchronous operation
+
+ Description
+ This function type defines a callback function that is called at the completion of any
+ asynchronous read or write operation.
+
+ See Also
+ * CyAsStorageReadAsync()
+ * CyAsStorageWriteAsync()
+*/
+typedef void (*CyAsStorageCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device completing the storage operation */
+ CyAsBusNumber_t bus, /* The bus completing the operation */
+ uint32_t device, /* The device completing the operation */
+ uint32_t unit, /* The unit completing the operation */
+ uint32_t block_number, /* The block number of the completed operation */
+ CyAsOperType op, /* The type of operation */
+ CyAsReturnStatus_t status /* The error status */
+ ) ;
+
+/* Summary
+ This function type defines a callback to be called in the event of a storage related event
+
+ Description
+ At times West Bridge needs to inform the P port processor of events that have
+ occurred. These events are asynchronous to the thread of control on the P
+ port processor and as such are generally delivered via a callback function that
+ is called as part of an interrupt handler. This type defines the type of function
+ that must be provided as a callback function.
+
+ See Also
+ * CyAsStorageEvent
+ * CyAsStorageRegisterCallback
+*/
+typedef void (*CyAsStorageEventCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device sending the event notification */
+ CyAsBusNumber_t bus, /* The bus where the event happened */
+ uint32_t device, /* The device where the event happened */
+ CyAsStorageEvent evtype, /* The event type */
+ void *evdata /* Event related data */
+ ) ;
+
+/* Summary
+ This function type defines a callback to be called after an asynchronous sdio operation
+
+ Description
+ The Callback function is called at the completion of an asynchronous sdio read or write operation.
+
+ See Also
+ * CyAsSdioExtendedRead()
+ * CyAsSdioExtendedWrite()
+*/
+typedef void (*CyAsSdioCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device completing the storage operation */
+ CyAsBusNumber_t bus, /* The bus completing the operation */
+ uint32_t device, /* The device completing the operation */
+ uint32_t function, /* The function number of the completing the operation.
+ If the status of the operation is either CY_AS_ERROR_IO_ABORTED
+ or CY_AS_IO_SUSPENDED then the most significant word parameter will
+ contain the number of blocks still pending. */
+ uint32_t address, /* The base address of the completed operation */
+ CyAsOperType op, /* The type of operation */
+ CyAsReturnStatus_t status /* The status of the operation */
+ ) ;
+
+/* Summary
+ Enumeration of SD/MMC card registers that can be read through the API.
+
+ Description
+ Some of the registers on the SD/MMC card(s) attached to the West Bridge can be read
+ through the API layers. This type enumerates the registers that can be read.
+
+ See Also
+ * CyAsStorageSDRegisterRead
+ */
+typedef enum CyAsSDCardRegType
+{
+ CyAsSDReg_OCR = 0,
+ CyAsSDReg_CID,
+ CyAsSDReg_CSD
+} CyAsSDCardRegType ;
+
+/* Summary
+ Struct encapsulating parameters and return values for a CyAsStorageQueryDevice
+ call.
+
+ Description
+ This struct holds the input parameters and the return values for an asynchronous
+ CyAsStorageQueryDevice call.
+
+ See Also
+ * CyAsStorageQueryDevice
+ */
+typedef struct CyAsStorageQueryDeviceData
+{
+ CyAsBusNumber_t bus ; /* The bus with the device to query */
+ uint32_t device ; /* The logical device number to query */
+ CyAsDeviceDesc desc_p ; /* The return value for the device descriptor */
+} CyAsStorageQueryDeviceData ;
+
+
+/* Summary
+ Struct encapsulating parameters and return values for a CyAsStorageQueryUnit
+ call.
+
+ Description
+ This struct holds the input parameters and the return values for an asynchronous
+ CyAsStorageQueryUnit call.
+
+ See Also
+ * CyAsStorageQueryUnit
+ */
+typedef struct CyAsStorageQueryUnitData
+{
+ CyAsBusNumber_t bus ; /* The bus with the device to query */
+ uint32_t device ; /* The logical device number to query */
+ uint32_t unit ; /* The unit to query on the device */
+ CyAsUnitDesc desc_p ; /* The return value for the unit descriptor */
+} CyAsStorageQueryUnitData ;
+
+/* Summary
+ Struct encapsulating the input parameter and return values for a
+ CyAsStorageSDRegisterRead call.
+
+ Description
+ This struct holds the input parameter and return values for an asynchronous
+ CyAsStorageSDRegisterRead call.
+
+ See Also
+ * CyAsStorageSDRegisterRead
+ */
+typedef struct CyAsStorageSDRegReadData
+{
+ uint8_t *buf_p; /* Pointer to the result buffer. */
+ uint8_t length; /* Length of data to be copied in bytes. */
+} CyAsStorageSDRegReadData ;
+
+/* Summary
+ Controls which pins are used for card detection
+
+ Description
+ When a StorageDeviceControl call is made to enable or disable
+ card detection this enum is passed in to control which pin
+ is used for the detection.
+
+ See Also
+ * CyAsStorageDeviceControl
+*/
+typedef enum CyAsStorageCardDetect
+{
+ CyAsStorageDetect_GPIO,
+ CyAsStorageDetect_SDAT_3
+} CyAsStorageCardDetect ;
+
+#ifndef __doxygen__
+#define CyAsStorageDetect_GPIO_0 CyAsStorageDetect_GPIO
+
+#define CY_AS_SD_REG_OCR_LENGTH (4) /* Length of OCR value in bytes. */
+#define CY_AS_SD_REG_CID_LENGTH (16) /* Length of CID value in bytes. */
+#define CY_AS_SD_REG_CSD_LENGTH (16) /* Length of CSD value in bytes. */
+#define CY_AS_SD_REG_MAX_RESP_LENGTH (10) /* Max. length of register response in words. */
+
+#endif
+
+/* Summary
+ This data structure is the data passed via the evdata paramater on a usb event
+ callback for the mass storage device progress event.
+
+ Description
+ This data structure reports the number of sectors that have been written and read
+ on the USB mass storage device since the last event report. The corresponding
+ event is only sent when either the number of writes, or the number of reads has
+ crossed a pre-set threshold.
+
+ See Also
+ * CyAsUsbEventCallback
+ * CyAsUsbRegisterCallback
+*/
+typedef struct CyAsMSCProgressData
+{
+ uint32_t wr_count; /* Number of sectors written since the last event. */
+ uint32_t rd_count; /* Number of sectors read since the last event. */
+} CyAsMSCProgressData ;
+
+/* Summary
+Flag to set Direct Write operation to read back from the address written to.
+
+
+ See Also
+ *CyAsSdioDirectWrite()
+*/
+#define CY_SDIO_RAW (0x01)
+
+
+/* Summary
+Flag to set Extended Read and Write to perform IO using a FIFO
+i.e. read or write from the specified address only.
+
+ See Also
+ *CyAsSdioExtendedRead()
+ *CyAsSdioExtendedWrite()
+*/
+#define CY_SDIO_OP_FIFO (0x00)
+
+/* Summary
+Flag to set Extended Read and Write to perform incremental
+IO using the address provided as the base address.
+
+
+ See Also
+ *CyAsSdioExtendedRead()
+ *CyAsSdioExtendedWrite()
+*/
+#define CY_SDIO_OP_INCR (0x02)
+
+/* Summary
+Flag to set Extended Read and Write to Block Mode operation
+
+ See Also
+ *CyAsSdioExtendedRead()
+ *CyAsSdioExtendedWrite()
+*/
+#define CY_SDIO_BLOCKMODE (0x04)
+
+/* Summary
+Flag to set Extended Read and Write to Byte Mode operation
+
+ See Also
+ *CyAsSdioExtendedRead()
+ *CyAsSdioExtendedWrite()
+*/
+#define CY_SDIO_BYTEMODE (0x00)
+
+/* Summary
+Flag to force re/initialization of a function.
+
+Description
+If not set a call to CyAsSdioInitFunction()
+will not initialize a function that has been previously initialized.
+ See Also
+ *CyAsSdioInitFunction()
+ */
+#define CY_SDIO_FORCE_INIT (0x40)
+
+/* Summary
+Flag to re-enable the SDIO interrupts.
+
+Description
+Used with a direct read or direct write
+after the Interrupt triggerred by SDIO has been serviced and cleared to
+reset the West Bridge Sdio Interrupt.
+ See Also
+ *CyAsSdioDirectRead()
+ *CyAsSdioDirectWrite()
+*/
+
+#define CY_SDIO_REARM_INT (0x80)
+
+
+/* Summary
+ Flag to check if 4 bit support is enabled on a low speed card
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_4BLS (0x80)
+
+/* Summary
+ Flag to check if card is a low speed card
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_LSC (0x40)
+
+/* Summary
+ Flag to check if interrupt during multiblock data transfer is enabled
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_E4MI (0x20)
+
+/* Summary
+ Flag to check if interrupt during multiblock data transfer is supported
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_S4MI (0x10)
+
+/* Summary
+ Flag to check if card supports function suspending.
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_SBS (0x08)
+
+/* Summary
+ Flag to check if card supports SDIO Read-Wait
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_SRW (0x04)
+
+/* Summary
+ Flag to check if card supports multi-block transfers
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_SMB (0x02)
+
+/* Summary
+ Flag to check if card supports Direct IO commands during execution of an Extended
+ IO function
+ See Also
+ <link CyAsSDIOCard::card_capability> */
+#define CY_SDIO_SDC (0x01)
+
+/* Summary
+ Flag to check if function has a CSA area.
+ See Also
+ <link CyAsSDIOFunc::csa_bits> */
+#define CY_SDIO_CSA_SUP (0x40)
+
+/* Summary
+ Flag to check if CSA access is enabled.
+ See Also
+ <link CyAsSDIOFunc::csa_bits> */
+#define CY_SDIO_CSA_EN (0x80)
+
+/* Summary
+ Flag to check if CSA is Write protected.
+ See Also
+ <link CyAsSDIOFunc::csa_bits> */
+#define CY_SDIO_CSA_WP (0x01)
+
+/* Summary
+ Flag to check if CSA formatting is prohibited.
+ See Also
+ <link CyAsSDIOFunc::csa_bits> */
+#define CY_SDIO_CSA_NF (0x02)
+
+/* Summary
+ Flag to check if the function allows wake-up from low
+ power mode using some vendor specific method.
+ See Also
+ <link CyAsSDIOFunc::wakeup_support> */
+#define CY_SDIO_FN_WUS (0x01)
+
+
+/* Summary
+ This data structure stores SDIO function 0 parameters for a SDIO card
+*/
+typedef struct CyAsSDIOCard
+{
+ uint8_t num_functions; /* Number of functions present on the card. */
+ uint8_t memory_present; /* Memory present(Combo card) or not */
+ uint16_t manufacturer_Id; /* 16 bit manufacturer ID */
+ uint16_t manufacturer_info; /* Additional vendor specific info */
+ uint16_t maxblocksize; /* Max Block size for function 0 */
+ uint16_t blocksize; /* Block size used for function 0 */
+ uint8_t sdio_version; /* SDIO version supported by the card */
+ uint8_t card_capability; /* Card capability flags */
+} CyAsSDIOCard;
+
+/* Summary
+ This data structure stores SDIO function 1-7 parameters for a SDIO card
+*/
+typedef struct CyAsSDIOFunc
+{
+ uint8_t function_code; /* SDIO function code. 0 if non standard function */
+ uint8_t extended_func_code; /* Extended function type code for non-standard function */
+ uint16_t maxblocksize; /* Max IO Blocksize supported by the function */
+ uint16_t blocksize; /* IO Blocksize used by the function */
+ uint32_t card_psn; /* 32 bit product serial number for the function */
+ uint8_t csa_bits; /* Code storage area variables */
+ uint8_t wakeup_support; /* Function wake-up support */
+}CyAsSDIOFunc;
+
+/*****************************************************************************
+ * West Bridge Functions
+ ****************************************************************************/
+
+/* Summary
+ This function starts the West Bridge storage module.
+
+ Description
+ This function initializes the West Bridge storage software stack and readies this
+ module to service storage related requests. If the stack is already running,
+ the reference count for the stack is incremented.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the module started sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsStorageStop
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageStart(
+ CyAsDeviceHandle handle, /* Handle to the device */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function stops the West Bridge storage module.
+
+ Description
+ This function decrements the reference count for the storage stack and if this count
+ is zero, the storage stack is shut down. The shutdown frees all resources associated
+ with the storage stack.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ While all resources associated with the storage stack will be freed is a shutdown occurs,
+ resources associated with underlying layers of the software will not be freed if they
+ are shared by the USB stack and the USB stack is active. Specifically the DMA manager,
+ the interrupt manager, and the West Bridge communications module are all shared by both the
+ USB stack and the storage stack.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING
+ * CY_AS_ERROR_ASYNC_PENDING
+ * CY_AS_ERROR_OUT_OF_MEMORY
+
+ See Also
+ * CyAsStorageStart
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageStop(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function is used to register a callback function for the storage API.
+
+ Description
+ At times West Bridge needs to inform the P port processor of events that have
+ occurred. These events are asynchronous to the thread of control on the P
+ port processor and as such are generally delivered via a callback function that
+ is called as part of an interrupt handler. This function registers the callback
+ function that is called when an event occurs. Each call to this function
+ replaces any old callback function with a new callback function supplied on
+ the most recent call. This function can also be called with a callback function
+ of NULL in order to remove any existing callback function
+
+ * Valid In Asynchronous Callback:YES
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the function was registered sucessfully
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+
+ See Also
+ * CyAsStorageEventCallback
+ * CyAsStorageEvent
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageRegisterCallback(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageEventCallback callback /* The callback function to call for async storage events */
+ ) ;
+
+/* Summary
+ This function claims a given media type.
+
+ Description
+ This function communicates to West Bridge that the processor wants control of the
+ given storage media type. Each media type can be claimed or released by the
+ processor independently. As the processor is the master for the storage,
+ West Bridge should release control of the requested media as soon as possible and
+ signal the processor via the CyAsStorageProcessor event.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ This function just notifies West Bridge that the storage is desired. The storage
+ has not actually been released by West Bridge until the registered callback function
+ is called with the CyAsStorageProcessor event
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - this request was sucessfully transmitted to the West Bridge device
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_MEDIA
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_ACQUIRED
+
+ See Also:
+ * CyAsStorageClaim
+ * CyAsStorageRelease
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageClaim(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to claim */
+ uint32_t device, /* The device to claim */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function releases a given media type.
+
+ Description
+ This function communicates to West Bridge that the processor has released control of
+ the given storage media type. Each media type can be claimed or released by the
+ processor independently. As the processor is the master for the storage, West Bridge
+ can now assume ownership of the media type. No callback or event is generated.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media was sucessfully released
+ * CY_AS_ERROR_MEDIA_NOT_CLAIMED - the media was not claimed by the P port
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_MEDIA
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsStorageClaim
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageRelease(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to release */
+ uint32_t device, /* The device to release */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function information about the number of devices present on a given bus
+
+ Description
+ This function retrieves information about how many devices on on the given
+ West Bridge bus.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ While the current implementation of West Bridge only supports one of logical device of
+ each media type, future versions WestBridge/Antioch may support multiple devices.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsStorageQueryDevice
+ * CyAsStorageQueryUnit
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryBus(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to query */
+ uint32_t * count, /* The return value containing the number of
+ devices present for this media type */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function information about the number of devices present for a given media type
+
+ Description
+ This function retrieves information about how many devices of a given media type
+ are attached to West Bridge.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ While the current implementation of West Bridge only supports one of logical device of
+ each media type, future versions West Bridge may support multiple devices.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsStorageQueryMedia
+ * CyAsMediaType
+ * CyAsStorageQueryDevice
+ * CyAsStorageQueryUnit
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryMedia(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to query */
+ uint32_t * count, /* The return value containing the number of
+ devices present for this media type */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function returns information about a given device of a specific media type
+
+ Description
+ This function retrieves information about a device of a given type of media. The
+ function is called with a given media type and device and a pointer to a media descriptor
+ (CyAsDeviceDesc). This function fills in the data in the media descriptor to provide
+ information about the attributes of the device of the given device.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ Currently this API only supports a single logical device of each media type. Therefore
+ the only acceptable value for the parameter device is zero (0).
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_NO_SUCH_MEDIA
+ * CY_AS_ERROR_NO_SUCH_DEVICE
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsMediaType
+ * CyAsStorageQueryMedia
+ * CyAsStorageQueryUnit
+ * CyAsDeviceDesc
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryDevice(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageQueryDeviceData* data, /* Parameters and return value for the query call */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function returns information about a given unit on a specific device
+
+ Description
+ This function retrieves information about a device of a given logical unit. The
+ function is called with a given media type, device address, unit address, and a
+ pointer to a unit descriptor (CyAsUnitDesc). This function fills in the data in
+ the unit descriptor to provide information about the attributes of the device of
+ the given logical unit.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_NO_SUCH_DEVICE
+ * CY_AS_ERROR_NO_SUCH_UNIT
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+
+ See Also
+ * CyAsMediaType
+ * CyAsStorageQueryMedia
+ * CyAsStorageQueryDevice
+ * CyAsUnitDesc
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryUnit(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageQueryUnitData* data_p, /* Parameters and return value for the query call */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function enables/disables the handling of SD/MMC card detection and SD/MMC
+ write protection in West Bridge Firmware.
+
+ Description
+ If the detection of SD/MMC card insertion or removal is being done by the Processor
+ directly, the West Bridge firmware needs to be instructed to disable the card detect
+ feature. Also, if the hardware design does not use the SD_WP GPIO of the West Bridge to
+ handle SD card's write protect notch, the handling of write protection if firmware
+ should be disabled. This API is used to enable/disable the card detect and write
+ protect support in West Bridge firmware.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the feature controls were set successfully
+ * CY_AS_ERROR_NO_SUCH_BUS - the specified bus is invalid
+ * CY_AS_ERROR_NOT_SUPPORTED - function not supported on the device in the specified bus
+ * CY_AS_ERROR_IN_SUSPEND - the West Brdige device is in suspended mode
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageDeviceControl(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsBusNumber_t bus, /* The bus to control */
+ uint32_t device, /* The device to control */
+ CyBool card_detect_en, /* Enable/disable control for card detection */
+ CyBool write_prot_en, /* Enable/disable control for write protect handling */
+ CyAsStorageCardDetect config_detect, /* Control which pin is used for card detection */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+/* Summary
+ This function reads one or more blocks of data from the storage system.
+
+ Description
+ This function synchronously reads one or more blocks of data from the given media
+ type/device and places the data into the data buffer given. This function does not
+ return until the data is read and placed into the buffer.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ If the Samsung CEATA drive is the target for a read/write operation, the maximum
+ number of sectors that can be accessed through a single API call is limited to 2047.
+ Longer accesses addressed to a Samsung CEATA drive can result in time-out errors.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_NO_SUCH_UNIT - the unit specified does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected
+ * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater than 4095 logic blocks are not allowed
+
+ See Also
+ * CyAsStorageReadAsync
+ * CyAsStorageWrite
+ * CyAsStorageWriteAsync
+ * CyAsStorageCancelAsync
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageRead(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where data will be placed */
+ uint16_t num_blocks /* The number of blocks to be read */
+ ) ;
+
+/* Summary
+ This function asynchronously reads one or more blocks of data from the storage system.
+
+ Description
+ This function asynchronously reads one or more blocks of data from the given media
+ type/device and places the data into the data buffer given. This function returns
+ as soon as the request is transmitted to the West Bridge device but before the data is
+ available. When the read is complete, the callback function is called to indicate the
+ data has been placed into the data buffer. Note that the data buffer must remain
+ valid from when the read is requested until the callback function is called.
+
+ * Valid In Asynchronous Callback: YES
+
+ Notes
+ If the Samsung CEATA drive is the target for a read/write operation, the maximum
+ number of sectors that can be accessed through a single API call is limited to 2047.
+ Longer accesses addressed to a Samsung CEATA drive can result in time-out errors.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected
+ * CY_AS_ERROR_QUERY_DEVICE_NEEDED - Before an asynchronous read can be issued
+ a call to CyAsStorageQueryDevice must be made
+ * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater than 4095 logic blocks are not allowed
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageWriteAsync
+ * CyAsStorageCancelAsync
+ * CyAsStorageQueryDevice
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageReadAsync(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where data will be placed */
+ uint16_t num_blocks, /* The number of blocks to be read */
+ CyAsStorageCallback callback /* The function to call when the read is complete
+ or an error occurs */
+ ) ;
+
+/* Summary
+ This function writes one or more blocks of data to the storage system.
+
+ Description
+ This function synchronously writes one or more blocks of data to the given media/device.
+ This function does not return until the data is written into the media.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ If the Samsung CEATA drive is the target for a read/write operation, the maximum
+ number of sectors that can be accessed through a single API call is limited to 2047.
+ Longer accesses addressed to a Samsung CEATA drive can result in time-out errors.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_NO_SUCH_UNIT - the unit specified does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected
+ * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater than 4095 logic blocks are not allowed
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageReadAsync
+ * CyAsStorageWriteAsync
+ * CyAsStorageCancelAsync
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageWrite(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer containing the data to be written */
+ uint16_t num_blocks /* The number of blocks to be written */
+ ) ;
+
+/* Summary
+ This function asynchronously writes one or more blocks of data to the storage system
+
+ Description
+ This function asynchronously writes one or more blocks of data to the given media type/device.
+ This function returns as soon as the request is transmitted to the West Bridge device
+ but before the data is actually written. When the write is complete, the callback
+ function is called to indicate the data has been physically written into the media.
+
+ * Valid In Asynchronous Callback: YES
+
+ Notes
+ If the Samsung CEATA drive is the target for a read/write operation, the maximum
+ number of sectors that can be accessed through a single API call is limited to 2047.
+ Longer accesses addressed to a Samsung CEATA drive can result in time-out errors.
+
+ Notes
+ The data buffer must remain valid from when the write is requested until the callback
+ function is called.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected
+ * CY_AS_ERROR_QUERY_DEVICE_NEEDED - A query device call is required before async writes are allowed
+ * CY_AS_ERROR_INVALID_PARAMETER - Reads/Writes greater than 4095 logic blocks are not allowed
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageWrite
+ * CyAsStorageReadAsync
+ * CyAsStorageCancelAsync
+ * CyAsStorageQueryDevice
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageWriteAsync(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* The bus to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where the data to be written is stored */
+ uint16_t num_blocks, /* The number of blocks to be written */
+ CyAsStorageCallback callback /* The function to call when the write is complete
+ or an error occurs */
+ ) ;
+
+/* Summary
+ This function aborts any outstanding asynchronous operation
+
+ Description
+ This function aborts any asynchronous block read or block write operation. As only a
+ single asynchronous block read or write operation is possible at one time, this aborts
+ the single operation in progress.
+
+ * Valid In Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_OPERATION_PENDING - no asynchronous operation is pending
+
+ See Also
+ * CyAsStorageRead
+ * CyAsStorageReadAsync
+ * CyAsStorageWrite
+ * CyAsStorageWriteAsync
+ * <LINK Asynchronous Versus Synchronous Operation>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageCancelAsync(
+ CyAsDeviceHandle handle /* Handle to the device with outstanding async request */
+ ) ;
+
+/* Summary
+ This function is used to read the content of SD registers
+
+ Description
+ This function is used to read the contents of CSD, CID and CSD registers of the SD Card.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the read operation was successful
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in suspend mode
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_INVALID_PARAMETER - The register type is invalid or the media is not supported on the bus
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to process request
+ * CY_AS_ERROR_INVALID_RESPONSE - communication failure with West Bridge firmware
+
+ See Also
+ * CyAsStorageSDRegReadData
+ */
+EXTERN CyAsReturnStatus_t
+CyAsStorageSDRegisterRead(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device. */
+ CyAsBusNumber_t bus, /* The bus to query */
+ uint8_t device, /* The device to query */
+ CyAsSDCardRegType regType, /* The type of register to read. */
+ CyAsStorageSDRegReadData *data_p, /* Output data buffer and length. */
+ CyAsFunctionCallback cb, /* Callback function to call when done. */
+ uint32_t client /* Call context to send to the cb function. */
+ ) ;
+
+/* Summary
+ Creates a partition starting at the given block and using the
+ remaining blocks on the card.
+
+ Description
+ Storage devices attached to West Bridge can be partitioned into two units.
+ The visibility of these units through the mass storage interface can be
+ individually controlled. This API is used to partition a device into two.
+
+ * Valid in Asynchronous Callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the partition was successfully created
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in suspend mode
+ * CY_AS_ERROR_USB_RUNNING - Partition cannot be created while USB stack is active
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to process request
+ * CY_AS_ERROR_INVALID_REQUEST - feature not supported by active device or firmware
+ * CY_AS_ERROR_INVALID_RESPONSE - communication failure with West Bridge firmware
+ * CY_AS_ERROR_ALREADY_PARTITIONED - the storage device already has been partitioned
+ * CY_AS_ERROR_INVALID_BLOCK - Size specified for the partition exceeds the actual device capacity
+
+ See Also
+ * <LINK Partitioning>
+ * CyAsStorageRemovePPartition
+ */
+EXTERN CyAsReturnStatus_t
+CyAsStorageCreatePPartition(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* Bus on which the device to be partitioned is connected */
+ uint32_t device, /* Device number to be partitioned */
+ uint32_t size, /* Size of partition number 0 in blocks */
+ CyAsFunctionCallback cb, /* Callback in case of async call */
+ uint32_t client /* Client context to pass to the callback */
+ );
+
+/* Summary
+ Removes the partition table on a storage device connected to the West Bridge.
+
+ Description
+ Storage devices attached to West Bridge can be partitioned into two units.
+ This partition information is stored on the device and is non-volatile. This
+ API is used to remove the stored partition information and make the entire
+ device visible as a single partition (unit).
+
+ * Valid in Asynchronous Callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the partition was successfully deleted
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_IN_SUSPEND - The West Bridge device is in suspend mode
+ * CY_AS_ERROR_USB_RUNNING - Partition cannot be created while USB stack is active
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to process request
+ * CY_AS_ERROR_INVALID_REQUEST - operation not supported by active device/firmware
+ * CY_AS_ERROR_NO_SUCH_UNIT - the addressed device is not partitioned
+
+ See Also
+ * <LINK Partitioning>
+ * CyAsStorageCreatePPartition
+ */
+EXTERN CyAsReturnStatus_t
+CyAsStorageRemovePPartition(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* Bus on which device of interest is connected */
+ uint32_t device, /* Device number of interest */
+ CyAsFunctionCallback cb, /* Callback in case of async call */
+ uint32_t client /* Client context to pass to the callback */
+ );
+
+/* Summary
+ Returns the amount of data read/written to the given device from the USB host.
+
+ Description
+
+ * Valid in Asynchronous Callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - API call completed successfully
+ * CY_AS_ERROR_INVALID_HANDLE - Invalid West Bridge device handle
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - No firmware image has been loaded on West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - Storage stack has not been started
+ * CY_AS_ERROR_NOT_SUPPORTED - This function is not supported by active firmware version
+ * CY_AS_ERROR_OUT_OF_MEMORY - Failed to get memory to process the request
+ * CY_AS_ERROR_TIMEOUT - West Bridge firmware did not respond to request
+ * CY_AS_ERROR_INVALID_RESPONSE - Unexpected reply from West Bridge firmware
+
+ See Also
+ * CyAsUsbSetMSReportThreshold
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageGetTransferAmount(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* Bus on which device of interest is connected */
+ uint32_t device, /* Device number of interest */
+ CyAsMSCProgressData *data_p, /* Return value containing read/write sector counts. */
+ CyAsFunctionCallback cb, /* Callback in case of async call */
+ uint32_t client /* Client context to pass to the callback */
+ ) ;
+
+/* Summary
+ Performs a Sector Erase on an attached SD Card
+
+ Description
+ This allows you to erase an attached SD card. The area to erase
+ is specified in terms of a starting Erase Unit and a number of
+ Erase Units. The size of each Erase Unit is defined in the
+ DeviceDesc returned from a StorageQueryDevice call and it can
+ differ between SD cards.
+
+ A large erase can take a while to complete depending on the SD
+ card. In such a case it is reccomended that an async call is made.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - API call completed successfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_MEDIA_WRITE_PROTECTED - the media is write protected
+ * CY_AS_ERROR_QUERY_DEVICE_NEEDED - A query device call is required before erase is allowed
+ * CY_AS_ERROR_NO_SUCH_BUS
+ * CY_AS_ERROR_NO_SUCH_DEVICE
+ * CY_AS_ERROR_NOT_SUPPORTED - Erase is currenly only supported on SD and using SD only firmware
+ * CY_AS_ERROR_OUT_OF_MEMORY
+
+ See Also
+ * CyAsStorageSDRegisterRead
+*/
+EXTERN CyAsReturnStatus_t
+CyAsStorageErase(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus, /* Bus on which device of interest is connected */
+ uint32_t device, /* Device number of interest */
+ uint32_t erase_unit, /* Erase Unit to start the erase */
+ uint16_t num_erase_units, /* Number of Erase Units to erase */
+ CyAsFunctionCallback cb, /* Callback in case of async call */
+ uint32_t client /* Client context to pass to the callback */
+ ) ;
+
+/* Summary
+ This function is used to read a Tuple from the SDIO CIS area.
+
+ Description
+ This function is used to read a Tuple from the SDIO CIS area.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_INVALID_REQUEST - an invalid IO request type was made
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_INVALID_ENDPOINT - A DMA request was made to an invalid endpoint
+ * CY_AS_ERROR_ENDPOINT_DISABLED - A DMA request was made to a disabled endpoint
+
+*/
+CyAsReturnStatus_t
+CyAsSdioGetCISInfo(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint16_t tupleId, /* Id of tuple to be fetched */
+ uint8_t * data_p /* Buffer to hold tuple read from card.
+ Should be at least 256 bytes in size */
+ );
+
+
+/* Summary
+ This function is used to read properties of the SDIO card.
+
+ Description
+ This function is used to read properties of the SDIO card into a CyAsSDIOCard structure.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_SUCCESS - the card information was returned
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+
+*/
+CyAsReturnStatus_t
+CyAsSdioQueryCard(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ CyAsSDIOCard *data_p /* Buffer to store card properties */
+ );
+
+/* Summary
+ This function is used to reset a SDIO card.
+
+ Description
+ This function is used to reset a SDIO card by writing to the reset bit in the CCCR
+ and reinitializing the card.This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ */
+CyAsReturnStatus_t
+CyAsSdioResetCard(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device /* Device number */
+ );
+
+/* Summary
+ This function performs a Synchronous 1 byte read from the sdio device function.
+
+ Description
+ This function is used to perform a synchronous 1 byte read from an SDIO card function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which read was attempted is in suspend
+*/
+CyAsReturnStatus_t
+CyAsSdioDirectRead(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint32_t address, /* Address for IO */
+ uint8_t miscBuf, /* Set to CY_SDIO_REARM_INT to reinitialize SDIO interrupt */
+ uint8_t * data_p /* Buffer to hold byte read from card */
+ );
+
+/* Summary
+ This function performs a Synchronous 1 byte write to the sdio device function.
+
+ Description
+ This function is used to perform a synchronous 1 byte write to an SDIO card function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which write was attempted is in suspend
+*/
+CyAsReturnStatus_t
+CyAsSdioDirectWrite(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint32_t address, /* Address for IO */
+ uint8_t miscBuf, /* Set to CY_SDIO_REARM_INT to reinitialize SDIO interrupt,
+ Set to CY_SDIO_RAW for Read after Write */
+ uint16_t argument, /* Byte to write */
+ uint8_t * data_p /* Buffer to hold byte read from card in Read after write mode */
+ );
+
+/* Summary
+ This function is used to set the blocksize of an SDIO function.
+
+ Description
+ This function is used to set the blocksize of an SDIO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize was passed to the function.
+ * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which write was attempted is in suspend
+*/
+CyAsReturnStatus_t
+CyAsSdioSetBlocksize(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint16_t blocksize /* Block size to set. */
+ );
+
+/* Summary
+ This function is used to read Multibyte/Block data from a IO function.
+
+ Description
+ This function is used to read Multibyte/Block data from a IO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: YES
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize or block count was passed to the function.
+ * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which write was attempted is in suspend
+ * CY_AS_ERROR_IO_ABORTED - The IO operation was aborted
+ * CY_AS_ERROR_IO_SUSPENDED - The IO operation was suspended
+ * CY_AS_ERROR_INVALID_REQUEST - An invalid request was passed to the card.
+
+*/
+CyAsReturnStatus_t
+CyAsSdioExtendedRead(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint32_t address, /* Base Address for IO */
+ uint8_t miscBuf, /* Set to CY_SDIO_BLOCKMODE for block IO,
+ CY_SDIO_BYTEMODE for multibyte IO,
+ CY_SDIO_OP_FIFO to read multiple bytes from the same address,
+ CY_SDIO_OP_INCR to read bytes from the incrementing addresses */
+ uint16_t argument, /* Block/Byte count to read */
+ uint8_t * data_p, /* Buffer to hold data read from card */
+ CyAsSdioCallback callback /* Callback in case of Asyncronous call. 0 if Synchronous */
+ );
+
+/* Summary
+ This function is used to write Multibyte/Block data to a IO function.
+
+ Description
+ This function is used to write Multibyte/Block data to a IO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: YES
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_INVALID_BLOCKSIZE - An incorrect blocksize or block count was passed to the function.
+ * CY_AS_ERROR_FUNCTION_SUSPENDED - The function to which write was attempted is in suspend
+ * CY_AS_ERROR_IO_ABORTED - The IO operation was aborted
+ * CY_AS_ERROR_IO_SUSPENDED - The IO operation was suspended
+ * CY_AS_ERROR_INVALID_REQUEST - An invalid request was passed to the card.
+*/
+CyAsReturnStatus_t
+CyAsSdioExtendedWrite(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint32_t address, /* Base Address for IO */
+ uint8_t miscBuf, /* Set to CY_SDIO_BLOCKMODE for block IO,
+ CY_SDIO_BYTEMODE for multibyte IO,
+ CY_SDIO_OP_FIFO to write multiple bytes to the same address,
+ CY_SDIO_OP_INCR to write multiple bytes to incrementing addresses */
+ uint16_t argument, /* Block/Byte count to write
+ In case of byte mode the count should not exceed the block size
+ or 512, whichever is smaller.
+ In case of Block mode, maximum number of blocks is 511. */
+ uint8_t * data_p, /* Buffer to hold data to be written to card. */
+ CyAsSdioCallback callback /* Callback in case of Asyncronous call. 0 if Synchronous */
+ );
+
+/* Summary
+ This function is used to initialize a SDIO card function.
+
+ Description
+ This function is used to initialize a SDIO card function (1 - 7).
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+*/
+CyAsReturnStatus_t
+CyAsSdioInitFunction(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ uint8_t miscBuf /* Set to CY_SDIO_FORCE_INIT to reinitialize function */
+ );
+
+/* Summary
+ This function is used to get properties of a SDIO card function.
+
+ Description
+ This function is used to get properties of a SDIO card function(1 - 7) into a CyAsSDIOFunc structure.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the media specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO request was made to an invalid function
+*/
+CyAsReturnStatus_t
+CyAsSdioQueryFunction(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ CyAsSDIOFunc* data_p /* Buffer to store function properties */
+ );
+
+/* Summary
+ This function is used to Abort the current IO function.
+
+ Description
+ This function is used to Abort the current IO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+*/
+CyAsReturnStatus_t
+CyAsSdioAbortFunction(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo /* IO function Number */
+ );
+
+/* Summary
+ This function is used to Disable IO to an SDIO function.
+
+ Description
+ This function is used to Disable IO to an SDIO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+*/
+CyAsReturnStatus_t
+CyAsSdioDeInitFunction(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo /* IO function Number */
+ );
+
+/* Summary
+ This function is used to Suspend the current IO function.
+
+ Description
+ This function is used to Suspend the current IO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+*/
+CyAsReturnStatus_t
+CyAsSdioSuspend(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo /* IO function Number */
+ );
+
+/* Summary
+ This function is used to resume a Suspended IO function.
+
+ Description
+ This function is used to resume a Suspended IO function.
+ This function is to be used only for IO to an SDIO card as
+ other media will not respond to the SDIO command set.
+
+ * Valid in Asynchronous Callback: NO
+ * Valid on Antioch device: NO
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_NOT_RUNNING - the storage stack has not been started
+ * CY_AS_ERROR_INVALID_HANDLE - an invalid handle was passed in
+ * CY_AS_ERROR_IN_SUSPEND - the West Bridge device is in suspend mode
+ * CY_AS_ERROR_SUCCESS - the media information was returned
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the stack is not running
+ * CY_AS_ERROR_NO_SUCH_BUS - the bus specified does not exist
+ * CY_AS_ERROR_NO_SUCH_DEVICE - the specified media/device pair does not exist
+ * CY_AS_ERROR_ASYNC_PENDING - an async operation is pending
+ * CY_AS_ERROR_OUT_OF_MEMORY - insufficient memory available
+ * CY_AS_ERROR_INVALID_RESPONSE - an error message was recieved from the firmware
+ * CY_AS_ERROR_MEDIA_ACCESS_FAILURE - there was error in reading from the media
+ * CY_AS_ERROR_INVALID_FUNCTION - An IO attempt was made to an invalid function
+ * CY_AS_ERROR_IO_ABORTED - The IO operation was aborted
+ * CY_AS_ERROR_IO_SUSPENDED - The IO operation was suspended
+ * CY_AS_ERROR_INVALID_REQUEST - An invalid request was passed to the card.
+
+*/
+CyAsReturnStatus_t
+CyAsSdioResume(
+ CyAsDeviceHandle handle, /* Handle to the Westbridge device */
+ CyAsBusNumber_t bus, /* Bus to use */
+ uint32_t device, /* Device number */
+ uint8_t nFunctionNo, /* IO function Number */
+ CyAsOperType op, /* Operation to resume (Read or Write) */
+ uint8_t miscBuf, /* Micellaneous buffer same as for Extended read and Write */
+ uint16_t pendingblockcount, /* Number of pending blocks for IO. Should be less
+ than or equal to the maximum defined for Extended
+ read and write */
+ uint8_t *data_p /* Buffer to continue the Suspended IO operation */
+ );
+
+
+
+/* For supporting deprecated functions */
+#include "cyasstorage_dep.h"
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASSTORAGE_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasstorage_dep.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,228 @@
+/* Cypress West Bridge API header file (cyanstorage_dep.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/* This header will contain Antioch specific declaration
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility
+ */
+#ifndef __INCLUDED_CYANSTORAGE_DEP_H__
+#define __INCLUDED_CYANSTORAGE_DEP_H__
+
+#ifndef __doxygen__
+
+typedef void (*CyAsStorageCallback_dep)(
+ CyAsDeviceHandle handle, /* Handle to the device completing the storage operation */
+ CyAsMediaType type, /* The media type completing the operation */
+ uint32_t device, /* The device completing the operation */
+ uint32_t unit, /* The unit completing the operation */
+ uint32_t block_number, /* The block number of the completed operation */
+ CyAsOperType op, /* The type of operation */
+ CyAsReturnStatus_t status /* The error status */
+ ) ;
+
+typedef void (*CyAsStorageEventCallback_dep)(
+ CyAsDeviceHandle handle, /* Handle to the device sending the event notification */
+ CyAsMediaType type, /* The media type */
+ CyAsStorageEvent evtype, /* The event type */
+ void *evdata /* Event related data */
+ ) ;
+
+typedef struct CyAsStorageQueryDeviceData_dep
+{
+ CyAsMediaType type ; /* The type of media to query */
+ uint32_t device ; /* The logical device number to query */
+ CyAsDeviceDesc desc_p ; /* The return value for the device descriptor */
+} CyAsStorageQueryDeviceData_dep ;
+
+typedef struct CyAsStorageQueryUnitData_dep
+{
+ CyAsMediaType type ; /* The type of media to query */
+ uint32_t device ; /* The logical device number to query */
+ uint32_t unit ; /* The unit to query on the device */
+ CyAsUnitDesc desc_p ; /* The return value for the unit descriptor */
+} CyAsStorageQueryUnitData_dep ;
+
+
+/************ FUNCTIONS *********************/
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageRegisterCallback_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageEventCallback_dep callback /* The callback function to call for async storage events */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageClaim_dep(CyAsDeviceHandle handle,
+ CyAsMediaType type
+ );
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageClaim_dep_EX(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType* type, /* The type of media to claim */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageRelease_dep(CyAsDeviceHandle handle,
+ CyAsMediaType type
+ );
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageRelease_dep_EX(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType* type, /* The type of media to release */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryDevice_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsDeviceDesc *desc_p
+ );
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryDevice_dep_EX(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageQueryDeviceData_dep* data, /* Parameters and return value for the query call */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryUnit_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to query */
+ uint32_t device, /* The logical device number to query */
+ uint32_t unit, /* The unit to query on the device */
+ CyAsUnitDesc * unit_p /* The return value for the unit descriptor */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageQueryUnit_dep_EX(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsStorageQueryUnitData_dep* data_p, /* Parameters and return value for the query call */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageDeviceControl_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyBool card_detect_en, /* Enable/disable control for card detection */
+ CyBool write_prot_en, /* Enable/disable control for write protect handling */
+ CyAsFunctionCallback cb, /* Callback to be called when the operation is complete */
+ uint32_t client /* Client data to be passed to the callback */
+ ) ;
+
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageRead_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where data will be placed */
+ uint16_t num_blocks /* The number of blocks to be read */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageReadAsync_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where data will be placed */
+ uint16_t num_blocks, /* The number of blocks to be read */
+ CyAsStorageCallback_dep callback/* The function to call when the read is complete
+ or an error occurs */
+ ) ;
+EXTERN CyAsReturnStatus_t
+CyAsStorageWrite_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer containing the data to be written */
+ uint16_t num_blocks /* The number of blocks to be written */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageWriteAsync_dep(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsMediaType type, /* The type of media to access */
+ uint32_t device, /* The device to access */
+ uint32_t unit, /* The unit to access */
+ uint32_t block, /* The first block to access */
+ void * data_p, /* The buffer where the data to be written is stored */
+ uint16_t num_blocks, /* The number of blocks to be written */
+ CyAsStorageCallback_dep callback /* The function to call when the write is complete
+ or an error occurs */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageSDRegisterRead_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType type,
+ uint8_t device,
+ CyAsSDCardRegType regType,
+ uint8_t readLen,
+ uint8_t *data_p
+ );
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageSDRegisterRead_dep_EX(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device. */
+ CyAsMediaType type, /* The type of media to query */
+ uint8_t device, /* The device to query */
+ CyAsSDCardRegType regType, /* The type of register to read. */
+ CyAsStorageSDRegReadData *data_p, /* Output data buffer and length. */
+ CyAsFunctionCallback cb, /* Callback function to call when done. */
+ uint32_t client /* Call context to send to the cb function. */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageCreatePPartition_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ uint32_t size,
+ CyAsFunctionCallback cb,
+ uint32_t client) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsStorageRemovePPartition_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client) ;
+
+#endif /*__doxygen*/
+
+#endif /*__INCLUDED_CYANSTORAGE_DEP_H__*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastfw_sd_mmc_rel_nopport.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1091 @@
+#define CYASTFW_SD_MMC_REL_NOPPORT_SIZE 17314
+union {
+ uint8_t fw_image[CYASTFW_SD_MMC_REL_NOPPORT_SIZE] ;
+ uint16_t dummy_for_word_alignment ;
+} cyastfw_sd_mmc_rel_nopport_array = {
+ {
+ 0x02, 0x11, 0xe5, 0x02, 0x3c, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x3d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x42, 0xa9, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x20, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3a, 0xa4, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xe7, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x46, 0xe7, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x3e,
+ 0x88, 0x82, 0x8c, 0x83, 0xe7, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x32, 0xe3, 0x09, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x78, 0xe3, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x70, 0x88, 0x82, 0x8c, 0x83,
+ 0xe3, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x64, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x58, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x4c,
+ 0x80, 0xd2, 0x80, 0xfa, 0x80, 0xc6, 0x80, 0xd4, 0x80, 0x69, 0x80, 0xf2, 0x80, 0x33, 0x80, 0x10,
+ 0x80, 0xa6, 0x80, 0xea, 0x80, 0x9a, 0x80, 0xa8, 0x80, 0xda, 0x80, 0xe2, 0x80, 0xca, 0x80, 0x33,
+ 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83,
+ 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xe9, 0xde, 0xe7, 0x80,
+ 0x0d, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf6, 0x08, 0xdf, 0xf9, 0xec, 0xfa, 0xa9, 0xf0,
+ 0xed, 0xfb, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc,
+ 0xc5, 0x83, 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xea, 0xde,
+ 0xe8, 0x80, 0xdb, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf2, 0x08, 0xdf, 0xf9, 0x80, 0xcc,
+ 0x88, 0xf0, 0xef, 0x60, 0x01, 0x0e, 0x4e, 0x60, 0xc3, 0x88, 0xf0, 0xed, 0x24, 0x02, 0xb4, 0x04,
+ 0x00, 0x50, 0xb9, 0xf5, 0x82, 0xeb, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xaf, 0x23, 0x23, 0x45,
+ 0x82, 0x23, 0x90, 0x0a, 0x90, 0x73, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0x22, 0x50,
+ 0x02, 0xe7, 0x22, 0xbb, 0xfe, 0x02, 0xe3, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0x22, 0xbb,
+ 0x01, 0x0c, 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe0, 0x22, 0x50, 0x06,
+ 0xe9, 0x25, 0x82, 0xf8, 0xe6, 0x22, 0xbb, 0xfe, 0x06, 0xe9, 0x25, 0x82, 0xf8, 0xe2, 0x22, 0xe5,
+ 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe4, 0x93, 0x22, 0xf8, 0xbb, 0x01, 0x0d,
+ 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe8, 0xf0, 0x22, 0x50, 0x06, 0xe9,
+ 0x25, 0x82, 0xc8, 0xf6, 0x22, 0xbb, 0xfe, 0x05, 0xe9, 0x25, 0x82, 0xc8, 0xf2, 0x22, 0xef, 0x8d,
+ 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, 0x2e, 0xfe, 0x22,
+ 0xc5, 0xf0, 0xf8, 0xa3, 0xe0, 0x28, 0xf0, 0xc5, 0xf0, 0xf8, 0xe5, 0x82, 0x15, 0x82, 0x70, 0x02,
+ 0x15, 0x83, 0xe0, 0x38, 0xf0, 0x22, 0xef, 0x2b, 0xff, 0xee, 0x3a, 0xfe, 0xed, 0x39, 0xfd, 0xec,
+ 0x38, 0xfc, 0x22, 0xc3, 0xef, 0x9b, 0xff, 0xee, 0x9a, 0xfe, 0xed, 0x99, 0xfd, 0xec, 0x98, 0xfc,
+ 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, 0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c,
+ 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, 0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0,
+ 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, 0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc,
+ 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, 0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd,
+ 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, 0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22,
+ 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, 0xf0, 0xe8, 0x9c, 0x45, 0xf0,
+ 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, 0xee, 0x13, 0xfe, 0xef, 0x13,
+ 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33,
+ 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xa1, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x51, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x5d,
+ 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x69, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xd9, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xa3, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xaf,
+ 0x22, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x22, 0xe0, 0xf8, 0xa3,
+ 0xe0, 0xf9, 0xa3, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83,
+ 0x02, 0x0c, 0xad, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x79, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02,
+ 0x0d, 0x86, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x93, 0xec, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xa8, 0x82, 0x85, 0x83, 0xf0, 0xd0, 0x83, 0xd0, 0x82, 0x12, 0x0c,
+ 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0xe4, 0x73, 0xe4, 0x93, 0xa3, 0xc5,
+ 0x83, 0xc5, 0xf0, 0xc5, 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0xf0, 0xa3, 0xc5, 0x83, 0xc5, 0xf0, 0xc5,
+ 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5,
+ 0x83, 0x22, 0xeb, 0xf0, 0xa3, 0xea, 0xf0, 0xa3, 0xe9, 0xf0, 0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8,
+ 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, 0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93,
+ 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, 0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80,
+ 0xdf, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x08, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe2, 0xfc, 0x08,
+ 0xe2, 0xfd, 0x08, 0xe2, 0xfe, 0x08, 0xe2, 0xff, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd,
+ 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, 0xf9, 0x08, 0xe6,
+ 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xe2, 0xfb, 0x08, 0xe2, 0xf9, 0x08, 0xe2, 0xfa, 0x08, 0xe2,
+ 0xcb, 0xf8, 0x22, 0xe4, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf9, 0x74, 0x02, 0x93, 0xfa, 0x74, 0x03,
+ 0x93, 0xfb, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, 0xf6, 0x08, 0xef, 0xf6, 0x22, 0xec,
+ 0xf2, 0x08, 0xed, 0xf2, 0x08, 0xee, 0xf2, 0x08, 0xef, 0xf2, 0x22, 0xc1, 0x23, 0x41, 0x00, 0x60,
+ 0x00, 0x41, 0x00, 0x61, 0x00, 0x42, 0x00, 0xa9, 0x00, 0x40, 0x41, 0x00, 0xab, 0x00, 0x41, 0x00,
+ 0xac, 0x7c, 0x01, 0x4f, 0x00, 0x41, 0x00, 0xae, 0x00, 0xc1, 0x21, 0x02, 0x50, 0x00, 0x00, 0x41,
+ 0x00, 0xaf, 0x00, 0x42, 0x00, 0xb1, 0x00, 0x00, 0xc1, 0x22, 0x02, 0x52, 0x00, 0xb3, 0x41, 0x00,
+ 0xb0, 0x00, 0xc1, 0x24, 0x41, 0x00, 0xad, 0x00, 0x44, 0x04, 0x96, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x04, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x04, 0x87, 0x03, 0x90, 0x4a, 0x04, 0x89, 0x03,
+ 0x40, 0x03, 0x48, 0x03, 0x50, 0x03, 0x90, 0x00, 0x00, 0x48, 0x04, 0x6c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x83, 0x00, 0x41, 0x04, 0x84, 0x00, 0x41, 0x04, 0x85, 0x00,
+ 0x41, 0x04, 0x86, 0x00, 0x02, 0x20, 0x00, 0x00, 0x41, 0x04, 0xa5, 0x00, 0xc1, 0x26, 0xc1, 0x28,
+ 0x41, 0x04, 0x30, 0x16, 0x41, 0x04, 0x31, 0x0a, 0x01, 0x14, 0x01, 0x01, 0x15, 0x01, 0x02, 0x16,
+ 0x00, 0x68, 0x41, 0x04, 0x9f, 0x00, 0x41, 0x04, 0xa0, 0x00, 0x41, 0x04, 0xa1, 0x00, 0x41, 0x04,
+ 0xa4, 0x01, 0x42, 0x00, 0xb7, 0x00, 0x00, 0xc1, 0x1e, 0x00, 0x74, 0x00, 0xc0, 0xe0, 0xc0, 0xe0,
+ 0x32, 0x00, 0x00, 0x00, 0x0b, 0x08, 0x03, 0x05, 0x24, 0x00, 0x02, 0x3a, 0x00, 0x03, 0x03, 0x00,
+ 0x03, 0x11, 0x00, 0x03, 0x12, 0x00, 0x05, 0x20, 0x00, 0x05, 0x21, 0x00, 0x05, 0x26, 0x00, 0x06,
+ 0x28, 0x00, 0x05, 0x04, 0x02, 0x06, 0x29, 0x00, 0x07, 0x27, 0x00, 0x05, 0x39, 0x00, 0xff, 0xff,
+ 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0x4a, 0x00, 0x00, 0xe3, 0x4b, 0x00, 0x00, 0xe3,
+ 0x4c, 0x00, 0x00, 0xe3, 0x4d, 0xe3, 0x4e, 0xe3, 0x4f, 0xe3, 0x38, 0xe3, 0x39, 0xe3, 0x3a, 0xe3,
+ 0x3b, 0xe3, 0x18, 0xe3, 0x19, 0xe3, 0x1a, 0xe3, 0x1b, 0xe3, 0x12, 0xe3, 0x13, 0xe3, 0x14, 0xe3,
+ 0x15, 0x12, 0x38, 0x8b, 0x78, 0x80, 0xe2, 0x44, 0x04, 0xf2, 0xe2, 0x54, 0xf7, 0xf2, 0x22, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0x24, 0x02, 0xf9, 0xe4, 0x3e, 0x22, 0x90, 0xe6, 0x48, 0x74, 0x88, 0xf0, 0x22,
+ 0x02, 0x20, 0x08, 0x00, 0x02, 0x30, 0x47, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x30, 0x08, 0x00,
+ 0x02, 0x20, 0xd5, 0x00, 0x02, 0x20, 0x4c, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x30, 0x4d, 0x00, 0x02, 0x30, 0x51, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x37, 0x8f, 0x00,
+ 0x02, 0x37, 0xf4, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00, 0x02, 0x27, 0xf8, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0xe4, 0xfe, 0x7d, 0x02, 0xef, 0x5d, 0x90, 0x00,
+ 0xb9, 0xf0, 0x90, 0xe6, 0x12, 0x70, 0x0b, 0x74, 0x22, 0xf0, 0x90, 0xe6, 0x14, 0x74, 0x62, 0xf0,
+ 0x80, 0x09, 0x74, 0xa2, 0xf0, 0x90, 0xe6, 0x14, 0x74, 0xe2, 0xf0, 0x90, 0x00, 0xb9, 0xe0, 0x30,
+ 0xe1, 0x01, 0x0e, 0x30, 0x19, 0x04, 0x30, 0x1a, 0x01, 0x0e, 0xee, 0x14, 0xff, 0x22, 0xff, 0xea,
+ 0x3c, 0xfe, 0xad, 0x07, 0xfc, 0xf0, 0xa3, 0xed, 0xf0, 0xf5, 0x82, 0x8e, 0x83, 0xe0, 0x22, 0x22,
+ 0x00, 0x00, 0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0xb4, 0x04, 0x17, 0x47, 0x02, 0x00,
+ 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00,
+ 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00, 0x00, 0x02,
+ 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x00, 0x02, 0x00, 0x07, 0x05, 0x86, 0x02, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00,
+ 0x00, 0x02, 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x07, 0x05, 0x86,
+ 0x02, 0x40, 0x00, 0x00, 0x04, 0x03, 0x09, 0x04, 0x1a, 0x03, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00,
+ 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x30, 0x00,
+ 0x31, 0x00, 0x10, 0x03, 0x43, 0x00, 0x79, 0x00, 0x70, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00,
+ 0x73, 0x00, 0x18, 0x03, 0x57, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x42, 0x00,
+ 0x72, 0x00, 0x69, 0x00, 0x64, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x78,
+ 0x8a, 0xf2, 0x78, 0xb5, 0xf2, 0x71, 0x3e, 0x75, 0x4f, 0x01, 0x75, 0x52, 0x00, 0x75, 0x53, 0xb3,
+ 0xe5, 0x53, 0x30, 0xe0, 0x08, 0x05, 0x53, 0xe5, 0x53, 0x70, 0x02, 0x05, 0x52, 0x22, 0x34, 0x01,
+ 0xfe, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0,
+ 0xa3, 0xf0, 0x22, 0xe4, 0x78, 0x5c, 0xf2, 0x78, 0x5e, 0xf2, 0x22, 0x90, 0xe2, 0xa4, 0xf0, 0xe4,
+ 0x90, 0xe2, 0xa6, 0xf0, 0x22, 0xf0, 0xd1, 0x03, 0x90, 0xe6, 0x04, 0x74, 0x08, 0xf0, 0x22, 0x32,
+ 0x01, 0x00, 0x00, 0x24, 0x00, 0x80, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72,
+ 0x65, 0x73, 0x73, 0x00, 0x41, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x4e, 0x41, 0x4e, 0x44,
+ 0x20, 0x20, 0x20, 0x00, 0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x80,
+ 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x41, 0x73,
+ 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x53, 0x44, 0x20, 0x43, 0x61, 0x72, 0x64, 0x00, 0x30, 0x30,
+ 0x30, 0x31, 0x00, 0x00, 0x90, 0xe6, 0x82, 0xe0, 0x44, 0xc0, 0xf0, 0x43, 0x87, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x22, 0x74, 0x00, 0xf5, 0x86, 0x90, 0xfd, 0xa5, 0x7c, 0x05, 0xa3, 0xe5, 0x82,
+ 0x45, 0x83, 0x70, 0xf9, 0x22, 0x74, 0x00, 0xf5, 0x86, 0x90, 0xff, 0xe1, 0x02, 0x11, 0x6d, 0x74,
+ 0x00, 0xf5, 0x86, 0x90, 0xff, 0x41, 0x02, 0x11, 0x6d, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x61, 0xa8,
+ 0x61, 0xe5, 0x9a, 0xf6, 0x15, 0x61, 0xa8, 0x61, 0xe5, 0x9b, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22,
+ 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x61, 0xa8, 0x61, 0xe5, 0x9d, 0xf6, 0x15, 0x61, 0xa8, 0x61, 0xe5,
+ 0x9e, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0xa8, 0x61, 0xe6, 0xf5, 0x9b,
+ 0x05, 0x61, 0xa8, 0x61, 0xe6, 0xf5, 0x9a, 0x05, 0x61, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00,
+ 0xc0, 0xe0, 0xa8, 0x61, 0xe6, 0xf5, 0x9e, 0x05, 0x61, 0xa8, 0x61, 0xe6, 0xf5, 0x9d, 0x05, 0x61,
+ 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0x78, 0x7f, 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x92, 0xe6, 0x75, 0x81,
+ 0x61, 0x02, 0x12, 0x2f, 0x02, 0x3b, 0x5a, 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0x40, 0x03,
+ 0xf6, 0x80, 0x01, 0xf2, 0x08, 0xdf, 0xf4, 0x80, 0x29, 0xe4, 0x93, 0xa3, 0xf8, 0x54, 0x07, 0x24,
+ 0x0c, 0xc8, 0xc3, 0x33, 0xc4, 0x54, 0x0f, 0x44, 0x20, 0xc8, 0x83, 0x40, 0x04, 0xf4, 0x56, 0x80,
+ 0x01, 0x46, 0xf6, 0xdf, 0xe4, 0x80, 0x0b, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x90,
+ 0x0d, 0xbb, 0xe4, 0x7e, 0x01, 0x93, 0x60, 0xbc, 0xa3, 0xff, 0x54, 0x3f, 0x30, 0xe5, 0x09, 0x54,
+ 0x1f, 0xfe, 0xe4, 0x93, 0xa3, 0x60, 0x01, 0x0e, 0xcf, 0x54, 0xc0, 0x25, 0xe0, 0x60, 0xa8, 0x40,
+ 0xb8, 0xe4, 0x93, 0xa3, 0xfa, 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8,
+ 0xca, 0xc5, 0x83, 0xca, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xdf, 0xe9,
+ 0xde, 0xe7, 0x80, 0xbe, 0xe4, 0xf5, 0x27, 0xef, 0x70, 0x11, 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40,
+ 0x51, 0x12, 0x38, 0x8b, 0x75, 0x4f, 0x03, 0x11, 0xe3, 0x80, 0x47, 0xe5, 0x4f, 0x24, 0xfd, 0x60,
+ 0x0c, 0x24, 0xfe, 0x60, 0x03, 0x04, 0x70, 0x37, 0x75, 0x27, 0x10, 0x80, 0x35, 0x90, 0xe2, 0xa6,
+ 0x74, 0x30, 0xf0, 0x74, 0x10, 0x11, 0xeb, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x53, 0x91, 0xef, 0x78,
+ 0x5c, 0x74, 0x3b, 0xf2, 0x12, 0x0e, 0xe1, 0x75, 0x4f, 0x04, 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x03,
+ 0x12, 0x33, 0x08, 0x7f, 0x02, 0x12, 0x21, 0xb6, 0x78, 0x5e, 0x74, 0x1b, 0xf2, 0x80, 0x03, 0x75,
+ 0x27, 0x1b, 0xaf, 0x27, 0x22, 0x8d, 0x27, 0xac, 0x03, 0xe4, 0xfe, 0x12, 0x0f, 0xb8, 0xae, 0x07,
+ 0x90, 0x00, 0xb9, 0xe0, 0x90, 0x00, 0xac, 0x60, 0x1e, 0xe0, 0x44, 0x80, 0xff, 0xf0, 0xec, 0x54,
+ 0x1f, 0x25, 0xe0, 0x25, 0xe0, 0xfd, 0xef, 0x54, 0x83, 0x4d, 0xff, 0xf0, 0xee, 0x54, 0x03, 0xfe,
+ 0xef, 0x54, 0xfc, 0x4e, 0xf0, 0x80, 0x03, 0x74, 0x7c, 0xf0, 0x90, 0x00, 0x74, 0x12, 0x0e, 0xef,
+ 0x89, 0x82, 0xf5, 0x83, 0xec, 0xf0, 0x90, 0x00, 0x76, 0x12, 0x0e, 0xef, 0xf5, 0x83, 0x89, 0x82,
+ 0xec, 0xf0, 0xe5, 0x27, 0x70, 0x0b, 0x75, 0x4f, 0x03, 0x90, 0x00, 0xae, 0x74, 0x02, 0xf0, 0x80,
+ 0x0a, 0x75, 0x4f, 0x03, 0x90, 0x00, 0xae, 0x74, 0x01, 0x71, 0xf4, 0x7f, 0x00, 0x22, 0x90, 0x00,
+ 0x66, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x22, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x44, 0xf0,
+ 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x64, 0xf0, 0x90, 0x00, 0x74, 0x74, 0x10, 0xf0, 0xa3, 0x74,
+ 0x2b, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x4d, 0x71, 0xf4, 0x74, 0x00, 0x24, 0x02, 0xff,
+ 0xe4, 0x90, 0x00, 0x62, 0x11, 0xce, 0x7c, 0x10, 0x7d, 0x02, 0x7b, 0x12, 0x7a, 0x00, 0x91, 0x6f,
+ 0x74, 0x00, 0x24, 0x22, 0xff, 0xe4, 0x90, 0x00, 0x64, 0x11, 0xce, 0x7c, 0x10, 0x7d, 0x16, 0x7b,
+ 0x0a, 0x7a, 0x00, 0x91, 0x6f, 0x7c, 0x01, 0x7d, 0x00, 0xed, 0x24, 0x42, 0xfe, 0xe4, 0x3c, 0x90,
+ 0x00, 0x72, 0xf0, 0xa3, 0xce, 0xf0, 0xed, 0x24, 0xc2, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x70, 0xf0,
+ 0xa3, 0xce, 0xf0, 0x74, 0x00, 0x24, 0x42, 0xfe, 0x74, 0x01, 0x34, 0x01, 0x90, 0x00, 0x78, 0xf0,
+ 0xa3, 0xce, 0xf0, 0x90, 0x00, 0x6a, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xac, 0x06, 0x90, 0x00, 0x99,
+ 0xec, 0x12, 0x0f, 0xf5, 0xfb, 0x7a, 0x00, 0xed, 0x2b, 0x90, 0x00, 0x9b, 0x12, 0x0f, 0xee, 0x2d,
+ 0x90, 0x00, 0x9d, 0x12, 0x0f, 0xee, 0x2d, 0xfe, 0xea, 0x3c, 0x90, 0x00, 0x9f, 0xf0, 0xa3, 0xce,
+ 0x11, 0xd6, 0x01, 0xdc, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x00, 0x6c, 0xcf,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x00, 0x6e, 0xcf, 0xf0,
+ 0xa3, 0xef, 0xf0, 0x22, 0xe4, 0xf5, 0x26, 0x90, 0xe2, 0x77, 0xf0, 0x90, 0xe2, 0x76, 0xf0, 0x7f,
+ 0xff, 0x12, 0x21, 0xd2, 0x43, 0x26, 0x02, 0x7d, 0x01, 0x7f, 0x02, 0x12, 0x22, 0x1e, 0x11, 0xae,
+ 0xe4, 0xfb, 0x7d, 0x01, 0xaf, 0x26, 0x51, 0xd5, 0xe4, 0x90, 0xe6, 0x10, 0xf0, 0x00, 0xa3, 0xf0,
+ 0x00, 0x90, 0xe3, 0x4a, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3,
+ 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0x90, 0xe3, 0x38, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00,
+ 0xa3, 0xf0, 0x00, 0x7f, 0x01, 0x41, 0x74, 0x7b, 0x11, 0x7c, 0xe2, 0x7d, 0x08, 0x7a, 0x00, 0x8e,
+ 0x32, 0x8f, 0x33, 0x8c, 0x34, 0x8d, 0x35, 0x8a, 0x36, 0x8b, 0x37, 0x12, 0x37, 0x6a, 0x31, 0xa0,
+ 0xe5, 0x32, 0xf5, 0x9a, 0xe5, 0x33, 0xf5, 0x9b, 0xe5, 0x34, 0xf5, 0x9d, 0xe5, 0x35, 0xf5, 0x9e,
+ 0xe5, 0x37, 0x15, 0x37, 0xae, 0x36, 0x70, 0x02, 0x15, 0x36, 0x4e, 0x60, 0x08, 0x78, 0x7c, 0xe2,
+ 0x78, 0x7b, 0xf2, 0x80, 0xeb, 0x31, 0xce, 0x31, 0xb7, 0x85, 0x5e, 0xe8, 0x22, 0x8f, 0x2d, 0xe4,
+ 0xf5, 0x2e, 0x75, 0x2f, 0x3f, 0xf5, 0x54, 0x12, 0x41, 0x26, 0x12, 0x2c, 0xaf, 0xe5, 0x2d, 0xb4,
+ 0x02, 0x0e, 0x30, 0x2b, 0x03, 0x75, 0x55, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xa4, 0x80, 0x09,
+ 0x75, 0x55, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x04, 0xb1, 0x89, 0x12, 0x27, 0x96, 0xef, 0x60,
+ 0x02, 0xa1, 0x88, 0xe5, 0x2d, 0xb4, 0x02, 0x09, 0x90, 0xe2, 0x0a, 0xe0, 0x20, 0xe5, 0x0e, 0x80,
+ 0x08, 0x90, 0xe2, 0x0a, 0xe0, 0x64, 0xfe, 0x60, 0x04, 0x75, 0x54, 0x88, 0x22, 0xe5, 0x2e, 0x70,
+ 0x50, 0xe5, 0x2f, 0x60, 0x4c, 0xe5, 0x2d, 0x64, 0x02, 0x70, 0x1b, 0xf5, 0x55, 0xf5, 0x56, 0x12,
+ 0x27, 0xe3, 0xef, 0x70, 0x73, 0x30, 0x2b, 0x03, 0x75, 0x55, 0x40, 0x75, 0x56, 0x3c, 0xe4, 0xfb,
+ 0x7d, 0x26, 0x7f, 0xa4, 0x80, 0x0f, 0x75, 0x55, 0x40, 0x75, 0x56, 0xff, 0x75, 0x57, 0x80, 0xe4,
+ 0xfb, 0x7d, 0x26, 0x7f, 0x04, 0xb1, 0x89, 0x12, 0x27, 0x96, 0xef, 0x70, 0x4b, 0x90, 0xe2, 0x08,
+ 0xe0, 0x54, 0x02, 0xf5, 0x2e, 0x70, 0xb6, 0x7f, 0x64, 0xfe, 0x12, 0x2f, 0x36, 0x15, 0x2f, 0x80,
+ 0xac, 0xe5, 0x2e, 0x70, 0x04, 0x75, 0x54, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x45, 0x7b, 0x05, 0x91,
+ 0x69, 0x90, 0xe2, 0x08, 0xe0, 0x30, 0xe0, 0x06, 0x90, 0x04, 0x39, 0x74, 0x01, 0xf0, 0x12, 0x3f,
+ 0xe4, 0x31, 0x7f, 0x12, 0x2c, 0xaf, 0xe4, 0xfb, 0x7d, 0x7e, 0x7f, 0x08, 0x12, 0x27, 0xe8, 0xef,
+ 0x70, 0x06, 0x7e, 0x04, 0x7f, 0x4a, 0x91, 0x67, 0x22, 0xae, 0x07, 0x12, 0x40, 0x8c, 0x90, 0xe2,
+ 0x1a, 0xed, 0xf0, 0xd1, 0x03, 0xe5, 0x55, 0x54, 0xc0, 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4e,
+ 0x90, 0xe2, 0x00, 0xf0, 0xd1, 0x03, 0xe5, 0x55, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x56, 0x90,
+ 0xe2, 0x01, 0x12, 0x42, 0xf4, 0xe5, 0x56, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x57, 0xc4, 0x13,
+ 0x13, 0x54, 0x03, 0x4f, 0x90, 0xe2, 0x02, 0xf0, 0xd1, 0x03, 0xe5, 0x57, 0x25, 0xe0, 0x25, 0xe0,
+ 0xff, 0xe5, 0x58, 0x90, 0xe2, 0x03, 0x12, 0x42, 0xf4, 0xe5, 0x58, 0x25, 0xe0, 0x25, 0xe0, 0x90,
+ 0xe2, 0x04, 0xb1, 0xf2, 0xeb, 0x44, 0x01, 0x90, 0xe2, 0x21, 0xf0, 0x80, 0x16, 0x90, 0xe2, 0x00,
+ 0x74, 0x30, 0xf0, 0xd1, 0x03, 0x90, 0xe2, 0x22, 0x74, 0xff, 0xf0, 0xd1, 0x03, 0x90, 0xe2, 0x31,
+ 0x74, 0xff, 0xf0, 0x90, 0x00, 0xe4, 0xe0, 0xff, 0xef, 0x60, 0x04, 0x00, 0x1f, 0x80, 0xf9, 0x22,
+ 0x12, 0x43, 0x7f, 0xe4, 0xf5, 0x54, 0x12, 0x39, 0x81, 0xef, 0x60, 0x05, 0x75, 0x54, 0x0c, 0xe1,
+ 0x34, 0x12, 0x27, 0x84, 0x12, 0x2a, 0x15, 0x12, 0x37, 0x61, 0x4e, 0x70, 0x02, 0xe1, 0x34, 0x12,
+ 0x37, 0x7c, 0xe5, 0x34, 0x60, 0x06, 0x20, 0x24, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x15, 0xe4,
+ 0x30, 0x15, 0x0d, 0x12, 0x40, 0x94, 0x90, 0xe2, 0x34, 0x11, 0xf5, 0x12, 0x42, 0xfe, 0x80, 0x0a,
+ 0x12, 0x40, 0x85, 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x80, 0xf0, 0xb1, 0xf5, 0x12, 0x27, 0x84, 0x12,
+ 0x32, 0x04, 0x30, 0x15, 0x7d, 0x11, 0xf8, 0x12, 0x3f, 0xd2, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x02,
+ 0xa3, 0xe0, 0x70, 0x02, 0xe1, 0x05, 0xe5, 0x54, 0x60, 0x02, 0xe1, 0x05, 0x12, 0x2f, 0xed, 0x90,
+ 0xe2, 0x42, 0x74, 0x25, 0xf0, 0x90, 0xe2, 0x41, 0xe0, 0x70, 0x03, 0x00, 0x80, 0xf7, 0x7b, 0x04,
+ 0x7d, 0x26, 0x7f, 0x44, 0xb1, 0x89, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x0b, 0xe5, 0x58, 0x24, 0x01,
+ 0xf5, 0x58, 0xe4, 0x35, 0x57, 0x80, 0x09, 0xe4, 0x25, 0x58, 0xf5, 0x58, 0xe5, 0x57, 0x34, 0x02,
+ 0xf5, 0x57, 0xe4, 0x35, 0x56, 0xf5, 0x56, 0xe4, 0x35, 0x55, 0xf5, 0x55, 0x12, 0x43, 0x5c, 0x12,
+ 0x27, 0x96, 0x7f, 0x10, 0x12, 0x3e, 0xfe, 0x12, 0x33, 0x08, 0x12, 0x28, 0x08, 0xef, 0x60, 0x07,
+ 0xe5, 0x54, 0x70, 0x03, 0x75, 0x54, 0x99, 0x12, 0x0e, 0xf9, 0x00, 0xf0, 0x00, 0x11, 0xf8, 0x00,
+ 0x80, 0x88, 0xc2, 0x29, 0x90, 0x00, 0xe2, 0x12, 0x43, 0x0b, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x48,
+ 0x12, 0x27, 0xe8, 0x7f, 0x10, 0x12, 0x3e, 0xfe, 0xb1, 0xed, 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0,
+ 0xd1, 0x03, 0x12, 0x27, 0x96, 0xc2, 0x29, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0x7f, 0xf0, 0x00, 0xe4,
+ 0x90, 0xe2, 0x33, 0xf0, 0x00, 0x90, 0xe2, 0x31, 0x74, 0xff, 0xf0, 0x00, 0x90, 0x00, 0xe8, 0xe0,
+ 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0x00, 0xe5, 0x54, 0x60, 0x08, 0xb4, 0x99, 0x02, 0xff,
+ 0x22, 0x75, 0x54, 0x37, 0xe5, 0x34, 0x60, 0x1b, 0x85, 0x54, 0x5f, 0xe5, 0x54, 0x60, 0x07, 0xc2,
+ 0x16, 0x12, 0x2a, 0x42, 0x80, 0x0a, 0x90, 0x04, 0x96, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00,
+ 0x12, 0x2a, 0x3b, 0xaf, 0x54, 0x22, 0xc2, 0x20, 0xef, 0x60, 0x22, 0x12, 0x22, 0x17, 0x12, 0x42,
+ 0xd0, 0x30, 0x24, 0x0e, 0xe4, 0x90, 0xe6, 0x1b, 0xf0, 0xd2, 0x20, 0x74, 0xe0, 0x12, 0x37, 0x4b,
+ 0xf1, 0x95, 0xf1, 0x95, 0x90, 0xe6, 0x1a, 0x74, 0x48, 0xf0, 0x02, 0x38, 0x82, 0xe4, 0x90, 0xe6,
+ 0x1b, 0x11, 0xf5, 0xd1, 0x03, 0x74, 0x88, 0xf1, 0x9f, 0x12, 0x0e, 0xf9, 0xd1, 0x03, 0x90, 0xe6,
+ 0x1b, 0x74, 0x48, 0xf0, 0x22, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0xd1, 0x03, 0x74, 0x86, 0x90,
+ 0xe6, 0x48, 0xf0, 0xc1, 0x03, 0x12, 0x2a, 0x61, 0x12, 0x22, 0x17, 0x12, 0x42, 0xd0, 0x00, 0x90,
+ 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0xd1, 0x03, 0x74, 0xe2, 0x12,
+ 0x37, 0x4b, 0x12, 0x28, 0x90, 0xd1, 0x03, 0x90, 0xe6, 0x15, 0x74, 0x62, 0xf0, 0xd1, 0x03, 0x12,
+ 0x43, 0x04, 0x12, 0x38, 0x82, 0xc2, 0x20, 0x22, 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40, 0x03, 0x12,
+ 0x38, 0x8b, 0x12, 0x41, 0xa5, 0x12, 0x42, 0x25, 0xe4, 0x90, 0xe3, 0x12, 0xf0, 0x00, 0xa3, 0xf0,
+ 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x7f, 0x03, 0x75, 0xf0, 0x02, 0xef, 0x90, 0x0e, 0xb1, 0x12,
+ 0x0d, 0x16, 0x74, 0x01, 0x93, 0x70, 0x02, 0xe4, 0x93, 0x60, 0x0a, 0x11, 0x35, 0x12, 0x42, 0x1e,
+ 0x8c, 0x83, 0xe4, 0xf0, 0x00, 0x0f, 0xbf, 0x10, 0xdf, 0x90, 0xe2, 0xeb, 0x74, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xe4, 0xf0, 0x7e, 0xe2, 0x7f, 0x86, 0x7b, 0x1c, 0xfa, 0xfd, 0x12, 0x36, 0x60, 0x12,
+ 0x10, 0xe3, 0xf5, 0x4f, 0x22, 0xef, 0x75, 0xf0, 0x02, 0x90, 0x0e, 0xb1, 0x12, 0x0d, 0x16, 0xe4,
+ 0x93, 0x22, 0xef, 0x14, 0x60, 0x15, 0x14, 0x60, 0x1a, 0x24, 0x81, 0x60, 0x12, 0x24, 0xfb, 0x60,
+ 0x16, 0x24, 0x86, 0x70, 0x1c, 0x11, 0xa7, 0xe4, 0xf0, 0x80, 0x35, 0x78, 0xa1, 0x80, 0x0a, 0x78,
+ 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0xe2, 0x54, 0x01, 0x11, 0xa7, 0xf0, 0x80,
+ 0x1f, 0x53, 0x07, 0x0f, 0x11, 0x35, 0xfc, 0x74, 0x01, 0x93, 0x4c, 0x70, 0x03, 0x7f, 0x15, 0x22,
+ 0x11, 0x35, 0x91, 0xc4, 0xe0, 0x7f, 0x00, 0x30, 0xe1, 0x02, 0x7f, 0x01, 0x11, 0xa7, 0xef, 0xf0,
+ 0x11, 0xa7, 0xa3, 0xe4, 0xf0, 0x78, 0x8b, 0x74, 0x02, 0xf2, 0xe5, 0x52, 0x78, 0xb3, 0xf2, 0xe5,
+ 0x53, 0x78, 0xb4, 0xf2, 0x7f, 0x00, 0x22, 0x85, 0x53, 0x82, 0x85, 0x52, 0x83, 0x22, 0x78, 0xb8,
+ 0xe2, 0xf5, 0x3f, 0x78, 0xb9, 0xe2, 0xf5, 0x40, 0x78, 0xba, 0xe2, 0xf5, 0x41, 0x78, 0xbb, 0xe2,
+ 0xf5, 0x42, 0x78, 0xbc, 0xe2, 0xf5, 0x43, 0xe5, 0x3f, 0x54, 0x03, 0xff, 0xc2, 0x17, 0xc2, 0x18,
+ 0xe5, 0x3f, 0x54, 0x60, 0x90, 0x00, 0xaf, 0xf0, 0xc2, 0x21, 0x64, 0x20, 0x60, 0x05, 0xe0, 0x64,
+ 0x40, 0x70, 0x76, 0x90, 0x00, 0xac, 0xe0, 0x20, 0xe7, 0x02, 0x61, 0xdf, 0x54, 0x7c, 0x13, 0x13,
+ 0x54, 0x3f, 0x65, 0x43, 0x60, 0x02, 0x61, 0xdf, 0xef, 0x64, 0x01, 0x60, 0x02, 0x61, 0xdf, 0xd2,
+ 0x17, 0xe5, 0x40, 0x24, 0x02, 0x60, 0x33, 0x14, 0x60, 0x02, 0x61, 0xdf, 0xe5, 0x3f, 0x64, 0x21,
+ 0x60, 0x02, 0x61, 0xdf, 0xe5, 0x41, 0x60, 0x02, 0x61, 0xdf, 0x78, 0xbe, 0xe2, 0x60, 0x02, 0x61,
+ 0xdf, 0x53, 0x91, 0xef, 0x75, 0xa1, 0x01, 0x90, 0x00, 0xab, 0xf0, 0x7e, 0x00, 0x7f, 0x7a, 0x7b,
+ 0x1f, 0xfa, 0xfd, 0x12, 0x36, 0x60, 0xc2, 0x00, 0x61, 0x9b, 0xe5, 0x3f, 0x64, 0xa1, 0x60, 0x02,
+ 0x61, 0xdf, 0xe5, 0x41, 0x60, 0x02, 0x61, 0xdf, 0x78, 0xbe, 0xe2, 0x64, 0x01, 0x60, 0x02, 0x61,
+ 0xdf, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0x41, 0xe6, 0x90, 0x00, 0xae, 0xe0, 0x64, 0x02, 0x60,
+ 0x02, 0x41, 0x37, 0xe5, 0x40, 0xb4, 0x09, 0x04, 0xf1, 0x96, 0x80, 0x14, 0xe5, 0x40, 0x70, 0x10,
+ 0xe5, 0x3f, 0xb4, 0x82, 0x0b, 0xd2, 0x17, 0xaf, 0x43, 0x11, 0x42, 0xef, 0x60, 0x02, 0x61, 0xdf,
+ 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02, 0x41, 0x2e, 0x90, 0x00, 0xac, 0xe0, 0x30, 0xe7, 0x38, 0xe5,
+ 0x40, 0x64, 0x06, 0x70, 0x2b, 0xe5, 0x42, 0x64, 0x02, 0x60, 0x06, 0xe5, 0x42, 0x64, 0x07, 0x70,
+ 0x1f, 0xd2, 0x21, 0x90, 0x00, 0x76, 0x91, 0xcd, 0x30, 0x24, 0x06, 0xe5, 0x42, 0x64, 0x02, 0x60,
+ 0x08, 0x20, 0x24, 0x13, 0xe5, 0x42, 0xb4, 0x07, 0x0e, 0x90, 0x00, 0x74, 0x91, 0xcd, 0x80, 0x07,
+ 0xe5, 0x40, 0xb4, 0x0b, 0x02, 0x91, 0xe1, 0xe5, 0x40, 0x64, 0x03, 0x70, 0x32, 0xe5, 0x3f, 0xb4,
+ 0x02, 0x15, 0xe5, 0x41, 0x70, 0x11, 0xe5, 0x43, 0x64, 0x02, 0x60, 0x05, 0xe5, 0x43, 0xb4, 0x86,
+ 0x06, 0xd2, 0x17, 0xaf, 0x43, 0x91, 0x5d, 0xe5, 0x3f, 0x70, 0x14, 0xe5, 0x41, 0xb4, 0x01, 0x08,
+ 0x90, 0x00, 0xb0, 0x74, 0x03, 0xf0, 0x80, 0x07, 0xe5, 0x41, 0xb4, 0x02, 0x02, 0xd2, 0x17, 0xe5,
+ 0x40, 0x64, 0x01, 0x70, 0x29, 0xe5, 0x3f, 0xb4, 0x02, 0x15, 0xe5, 0x41, 0x70, 0x11, 0xe5, 0x43,
+ 0x64, 0x02, 0x60, 0x05, 0xe5, 0x43, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x43, 0x71, 0xe7, 0xe5,
+ 0x3f, 0x70, 0x0b, 0xe5, 0x41, 0xb4, 0x01, 0x06, 0x90, 0x00, 0xb0, 0x74, 0x01, 0xf0, 0x30, 0x17,
+ 0x02, 0x61, 0x9b, 0xd2, 0x18, 0x61, 0x9b, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02, 0x61, 0xdf, 0xd2,
+ 0x17, 0xe5, 0x40, 0x12, 0x0d, 0x2b, 0x1b, 0x10, 0x00, 0x1b, 0x39, 0x01, 0x1b, 0x70, 0x03, 0x1a,
+ 0x62, 0x06, 0x1b, 0x06, 0x08, 0x1a, 0xf6, 0x09, 0x1a, 0xe2, 0x0a, 0x1a, 0xec, 0x0b, 0x00, 0x00,
+ 0x1b, 0xdf, 0xe5, 0x42, 0x24, 0xfe, 0x60, 0x29, 0x14, 0x60, 0x3b, 0x24, 0xfd, 0x60, 0x13, 0x14,
+ 0x60, 0x29, 0x24, 0x06, 0x60, 0x02, 0x61, 0xdf, 0x78, 0x8b, 0x74, 0x12, 0xf2, 0x90, 0x00, 0x62,
+ 0x80, 0x08, 0x78, 0x8b, 0x74, 0x0a, 0xf2, 0x90, 0x00, 0x64, 0xe0, 0x78, 0xb3, 0xf2, 0xa3, 0x80,
+ 0x12, 0x90, 0x00, 0x6c, 0x91, 0xf0, 0x90, 0x00, 0x6d, 0x80, 0x08, 0x90, 0x00, 0x6e, 0x91, 0xf0,
+ 0x90, 0x00, 0x6f, 0xe0, 0x61, 0x2b, 0xe5, 0x41, 0xc3, 0x94, 0x08, 0x50, 0x15, 0xe5, 0x41, 0x25,
+ 0xe0, 0x24, 0x99, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x4e,
+ 0x70, 0x06, 0xd2, 0x18, 0xc2, 0x17, 0x61, 0x9b, 0x8e, 0x46, 0x8f, 0x47, 0x8e, 0x48, 0x8f, 0x49,
+ 0x85, 0x49, 0x82, 0x85, 0x48, 0x83, 0xe0, 0x78, 0x8b, 0xf2, 0xe5, 0x46, 0x78, 0xb3, 0xf2, 0xef,
+ 0x80, 0x49, 0x90, 0x00, 0x60, 0xe0, 0x91, 0xb1, 0xe5, 0x53, 0x80, 0x3f, 0x91, 0xe1, 0x90, 0x00,
+ 0x60, 0xe5, 0x41, 0xf0, 0x61, 0x9b, 0xad, 0x41, 0x7f, 0x05, 0xb1, 0x0b, 0x90, 0x00, 0x61, 0xe5,
+ 0x41, 0xf0, 0xf1, 0x96, 0x61, 0x9b, 0x90, 0x00, 0x61, 0xe0, 0x91, 0xb1, 0xe5, 0x53, 0x80, 0x1b,
+ 0xe5, 0x3f, 0x24, 0x7f, 0x60, 0x09, 0x14, 0x60, 0x17, 0x24, 0x02, 0x60, 0x02, 0x61, 0xdf, 0x11,
+ 0xa7, 0xe4, 0xf0, 0xa3, 0xf0, 0x74, 0x02, 0x91, 0xba, 0xe5, 0x53, 0x78, 0xb4, 0xf2, 0x80, 0x6b,
+ 0xaf, 0x43, 0x11, 0x42, 0xef, 0x60, 0x64, 0x61, 0xdf, 0xe5, 0x3f, 0xb4, 0x02, 0x1f, 0xe5, 0x41,
+ 0x70, 0x1b, 0xaf, 0x43, 0x71, 0xe7, 0xef, 0x60, 0x02, 0x61, 0xdf, 0xe5, 0x43, 0x64, 0x02, 0x60,
+ 0x0c, 0xe5, 0x43, 0x64, 0x86, 0x60, 0x06, 0xad, 0x43, 0x7f, 0x07, 0xb1, 0x0b, 0xe5, 0x3f, 0x70,
+ 0x3a, 0xe5, 0x41, 0x64, 0x01, 0x70, 0x34, 0x90, 0x00, 0xb0, 0xe0, 0x54, 0xfd, 0xf0, 0x80, 0x2b,
+ 0xe5, 0x3f, 0x24, 0xfe, 0x60, 0x1a, 0x24, 0x02, 0x70, 0x65, 0xe5, 0x41, 0xb4, 0x01, 0x09, 0x90,
+ 0x00, 0xb0, 0xe0, 0x44, 0x02, 0xf0, 0x80, 0x13, 0xe5, 0x41, 0x64, 0x02, 0x60, 0x0d, 0x80, 0x4f,
+ 0xe5, 0x41, 0x70, 0x4b, 0xaf, 0x43, 0x91, 0x5d, 0xef, 0x70, 0x44, 0x30, 0x18, 0x37, 0x30, 0x22,
+ 0x11, 0xe4, 0x90, 0x04, 0x81, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90, 0x00, 0xb1, 0xf0, 0xa3, 0xf0,
+ 0xc2, 0x23, 0xf1, 0xbd, 0xe5, 0x3f, 0x20, 0xe7, 0x18, 0x78, 0xbf, 0xe2, 0x90, 0x00, 0xb1, 0xf0,
+ 0x78, 0xbe, 0xe2, 0xa3, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x02, 0xd2,
+ 0x23, 0xd2, 0x22, 0xb1, 0xdf, 0x30, 0x17, 0x0e, 0x78, 0xa0, 0xe2, 0x44, 0x80, 0xf2, 0x22, 0x90,
+ 0xe6, 0xa0, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0xad, 0x07, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x60, 0x50,
+ 0x24, 0xfe, 0x60, 0x18, 0x24, 0x81, 0x60, 0x0e, 0x24, 0xfb, 0x60, 0x20, 0x24, 0x85, 0x70, 0x27,
+ 0xe4, 0x78, 0xa1, 0xf2, 0x80, 0x3a, 0xe4, 0x78, 0xa2, 0xf2, 0x80, 0x34, 0x90, 0x00, 0xab, 0xe0,
+ 0x70, 0x2e, 0x78, 0xa3, 0xf2, 0x7f, 0x02, 0x12, 0x21, 0xb6, 0x80, 0x24, 0x90, 0x00, 0xab, 0xe0,
+ 0x70, 0x1e, 0x78, 0xa5, 0xf2, 0x80, 0x19, 0xec, 0x11, 0x36, 0xfe, 0x74, 0x01, 0x93, 0x4e, 0x70,
+ 0x03, 0x7f, 0x15, 0x22, 0x75, 0xf0, 0x02, 0xec, 0x11, 0x39, 0x91, 0xc4, 0xe0, 0x54, 0xfd, 0xf0,
+ 0xed, 0x30, 0xe7, 0x03, 0x43, 0x04, 0x10, 0x91, 0xd6, 0xe0, 0x30, 0xe7, 0x0d, 0xed, 0x54, 0x0f,
+ 0xfc, 0xed, 0x20, 0xe7, 0x03, 0x43, 0x04, 0x10, 0x91, 0xd6, 0x7f, 0x00, 0x22, 0xef, 0x54, 0x0f,
+ 0xfe, 0xef, 0x14, 0x60, 0x1a, 0x14, 0x60, 0x1f, 0x24, 0x82, 0x60, 0x0b, 0x14, 0x60, 0x14, 0x24,
+ 0xfb, 0x60, 0x18, 0x24, 0x86, 0x70, 0x1b, 0x78, 0xa0, 0xe2, 0x44, 0x01, 0xf2, 0x80, 0x2f, 0x78,
+ 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0x74, 0x01, 0xf2,
+ 0x80, 0x1c, 0x75, 0xf0, 0x02, 0xee, 0x11, 0x39, 0xfc, 0x74, 0x01, 0x93, 0x4c, 0x70, 0x03, 0x7f,
+ 0x15, 0x22, 0x75, 0xf0, 0x02, 0xee, 0x11, 0x39, 0x91, 0xc4, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x00,
+ 0x22, 0x85, 0x53, 0x82, 0x85, 0x52, 0x83, 0xf0, 0x74, 0x01, 0x78, 0x8b, 0xf2, 0xe5, 0x52, 0x78,
+ 0xb3, 0xf2, 0xfe, 0x22, 0xfe, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0x8e, 0x50, 0xf5, 0x51, 0x22, 0x90, 0xe6, 0x83, 0xec, 0xf0, 0x44, 0x20, 0xf0, 0xec, 0xf0,
+ 0x22, 0x78, 0x83, 0x74, 0x02, 0xf2, 0x74, 0x22, 0xf2, 0x74, 0x16, 0xf2, 0x74, 0x36, 0xf2, 0x22,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0xac, 0x06, 0x8c, 0x44, 0xf5, 0x45, 0x85, 0x45, 0x82, 0x85, 0x44, 0x83,
+ 0xa3, 0xa3, 0xe0, 0x78, 0x8b, 0xf2, 0xee, 0x78, 0xb3, 0xf2, 0x22, 0xae, 0x07, 0xb1, 0x2e, 0xf1,
+ 0xbd, 0x90, 0xe2, 0x66, 0xee, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xed, 0xf0, 0xe4, 0x12, 0x10, 0xdc,
+ 0xf1, 0x23, 0x74, 0x0b, 0xf0, 0x7f, 0x01, 0xa1, 0xd2, 0xf0, 0x7f, 0x00, 0xb1, 0xd2, 0x22, 0x8f,
+ 0x3f, 0x8b, 0x40, 0x8a, 0x41, 0x89, 0x42, 0x12, 0x11, 0x89, 0xaa, 0x41, 0xa9, 0x42, 0xae, 0x02,
+ 0xee, 0xf5, 0x9a, 0xaf, 0x01, 0xef, 0xf5, 0x9b, 0xe5, 0x3f, 0xd3, 0x94, 0x04, 0x50, 0x20, 0xb1,
+ 0x2e, 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0x04, 0x86, 0xd1, 0x43, 0xd1, 0xd3,
+ 0x90, 0x04, 0x84, 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xb1, 0xd2, 0x02, 0x11, 0xb7, 0xb1,
+ 0x2e, 0xe4, 0x90, 0xe2, 0x67, 0xf0, 0xe5, 0x3f, 0x04, 0xc3, 0x13, 0x04, 0x90, 0xe2, 0x66, 0xf0,
+ 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x04, 0x86, 0xd1, 0x53, 0x90, 0x04, 0x83,
+ 0xe0, 0x90, 0xe2, 0x65, 0xf0, 0xb1, 0xc8, 0x15, 0x3f, 0x15, 0x3f, 0xb1, 0x2e, 0x90, 0xe6, 0x7b,
+ 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0x7b, 0xd1, 0x43, 0xe5, 0x3f, 0xd3, 0x94, 0x06, 0x50,
+ 0x05, 0xd1, 0xd3, 0x75, 0x3f, 0x06, 0xb1, 0xc8, 0x74, 0xfa, 0x25, 0x3f, 0xf5, 0x3f, 0x70, 0xdb,
+ 0x12, 0x11, 0xb7, 0xd2, 0xe8, 0xd2, 0xe9, 0x22, 0x90, 0x04, 0x84, 0xe0, 0x90, 0xe2, 0x64, 0xf0,
+ 0x7f, 0x00, 0x15, 0x61, 0xa8, 0x61, 0xa6, 0x07, 0xa8, 0x61, 0xe4, 0xf6, 0x05, 0x61, 0x22, 0xd1,
+ 0xb9, 0x74, 0x05, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x08, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0xe6,
+ 0xb8, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x90, 0xe6, 0xb9, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90, 0xe2,
+ 0x65, 0x74, 0x43, 0xf0, 0x90, 0xe2, 0x64, 0x74, 0x0c, 0xb1, 0x29, 0x90, 0xe6, 0xba, 0xe0, 0x90,
+ 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0xbb, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0xbc, 0xe0, 0x90,
+ 0xe2, 0x69, 0xf0, 0x90, 0xe6, 0xbd, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0xbe, 0xe0, 0x90,
+ 0xe2, 0x6b, 0xf0, 0x90, 0xe6, 0xbf, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0xf1, 0x23, 0x74, 0x0c, 0xf0,
+ 0x0f, 0x80, 0x8f, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x69, 0xf0,
+ 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x6b, 0xf0,
+ 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x22, 0xae, 0x07, 0xd1, 0xb9, 0x74, 0x04, 0xf0,
+ 0xe4, 0xa3, 0xf0, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0x03, 0x50, 0xe0, 0x90,
+ 0xe2, 0x69, 0xf0, 0x90, 0x03, 0x53, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90, 0x03, 0x52, 0xe0, 0x90,
+ 0xe2, 0x6b, 0xf0, 0x74, 0x02, 0xf1, 0x25, 0x04, 0xb1, 0x29, 0x90, 0x03, 0x55, 0xe0, 0x90, 0xe2,
+ 0x66, 0xf0, 0x90, 0x03, 0x54, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xee, 0xf0, 0xe4, 0x12, 0x10,
+ 0xdc, 0xf1, 0xcd, 0x74, 0x03, 0xf0, 0x0f, 0xa1, 0xd2, 0xb1, 0x2e, 0x90, 0xe2, 0x66, 0x22, 0xd1,
+ 0xb9, 0xed, 0x12, 0x10, 0xd6, 0xef, 0x54, 0x0f, 0xd1, 0xd7, 0xe4, 0x90, 0xe2, 0x64, 0xf0, 0x7f,
+ 0x01, 0xa1, 0xd2, 0x90, 0x04, 0x83, 0xe0, 0x44, 0x80, 0x90, 0xe2, 0x65, 0xf0, 0x22, 0xd1, 0xb9,
+ 0xef, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xeb, 0xf0, 0xa3, 0xe5, 0x29, 0xf0, 0xa3, 0xe5, 0x2a, 0xf0,
+ 0xa3, 0xe5, 0x2b, 0xf0, 0x74, 0xc0, 0xf1, 0xcf, 0x74, 0x7f, 0xf0, 0x7f, 0x01, 0xa1, 0xd2, 0xd1,
+ 0xb9, 0xe5, 0x37, 0xf0, 0xa3, 0xe5, 0x36, 0xf0, 0xa3, 0xe5, 0x39, 0xf0, 0xa3, 0xe5, 0x38, 0xf0,
+ 0xa3, 0xe5, 0x3b, 0xf0, 0xa3, 0xe5, 0x3a, 0xf0, 0xe5, 0x34, 0xf1, 0x6d, 0xe5, 0x35, 0xf0, 0x7f,
+ 0x01, 0xa1, 0xd2, 0x74, 0xc3, 0x90, 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0xb1, 0x2e, 0x74,
+ 0x10, 0xf1, 0xc5, 0xef, 0xf0, 0xe4, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe2, 0x68, 0xed, 0xf1, 0x6a,
+ 0x74, 0x09, 0xf0, 0x7f, 0x01, 0xa1, 0xd2, 0xe4, 0xfe, 0xed, 0x30, 0xe0, 0x05, 0x90, 0x04, 0x9f,
+ 0xe0, 0xfe, 0xed, 0x30, 0xe1, 0x06, 0x90, 0x04, 0xa0, 0xe0, 0x42, 0x06, 0xb1, 0x2e, 0xed, 0xf1,
+ 0xc5, 0xee, 0xf1, 0x6a, 0xef, 0xf0, 0x7f, 0x01, 0xa1, 0xd2, 0xf0, 0x74, 0xc2, 0x90, 0xe2, 0x65,
+ 0xf0, 0x90, 0xe2, 0x64, 0x22, 0xb1, 0x2e, 0x90, 0x04, 0x6d, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90,
+ 0x04, 0x6c, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xe4, 0x12, 0x10, 0xda, 0xef, 0x44, 0x80, 0xf1, 0x6d,
+ 0x74, 0x01, 0xf0, 0xff, 0xa1, 0xd2, 0x90, 0x00, 0xba, 0xe0, 0xf4, 0xff, 0x90, 0x00, 0xb9, 0xe0,
+ 0xfe, 0x5f, 0xfd, 0x75, 0x4f, 0x05, 0xee, 0x60, 0x13, 0x90, 0x00, 0xad, 0x74, 0x01, 0xf0, 0xed,
+ 0x60, 0x04, 0x7f, 0x0a, 0xf1, 0x47, 0x20, 0x24, 0x03, 0x12, 0x22, 0x84, 0x22, 0x90, 0x04, 0xa5,
+ 0xe0, 0x44, 0x08, 0xf0, 0x22, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe2, 0x66, 0x22, 0x74, 0x82, 0x90,
+ 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0xb1, 0x2e, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x66,
+ 0xf0, 0x90, 0x03, 0x50, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0xa3, 0xf0, 0xf1,
+ 0xcd, 0x74, 0x10, 0xf0, 0x7f, 0x01, 0xa1, 0xd2, 0x90, 0xe6, 0x80, 0xe0, 0x44, 0x08, 0xf0, 0x78,
+ 0x68, 0x74, 0x0b, 0xf2, 0x22, 0xc2, 0xdc, 0x32, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82,
+ 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0,
+ 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x12, 0x18, 0xae, 0x11, 0x45, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05,
+ 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83,
+ 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0x53, 0x91, 0xef, 0x75, 0xa1, 0x00, 0x22, 0xc0, 0xe0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0xe6, 0x80, 0xe0, 0x30, 0xe7, 0x22, 0x90, 0x00, 0x66, 0xe0,
+ 0xff, 0xa3, 0xe0, 0xcf, 0x31, 0xae, 0x90, 0x00, 0x68, 0x12, 0x14, 0x07, 0x90, 0x00, 0xa9, 0x74,
+ 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x7d, 0x01, 0x7f, 0x06, 0x12, 0x1d, 0x0b, 0xd2, 0x24, 0x90, 0x00,
+ 0x6c, 0xe0, 0xfe, 0xa3, 0xe0, 0xf9, 0x11, 0xc9, 0x90, 0x00, 0x6e, 0xe0, 0xfe, 0xa3, 0xe0, 0xf9,
+ 0x74, 0x07, 0x11, 0xcd, 0x90, 0x00, 0xa9, 0xe0, 0x78, 0x24, 0xf2, 0xa3, 0xe0, 0x78, 0x25, 0xf2,
+ 0x11, 0x45, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00,
+ 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x7b, 0x01, 0x74, 0x02, 0xaa, 0x06, 0x90,
+ 0x00, 0x01, 0x02, 0x0b, 0x7c, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00,
+ 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07,
+ 0x11, 0x45, 0x90, 0x00, 0xab, 0xe4, 0xf0, 0x78, 0xa3, 0xf2, 0x78, 0xa5, 0xf2, 0x78, 0x1a, 0x74,
+ 0x40, 0xf2, 0x78, 0x48, 0x74, 0x86, 0xf2, 0x00, 0xf2, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x7f,
+ 0x02, 0x31, 0xb6, 0x12, 0x41, 0xa5, 0x12, 0x42, 0x25, 0x90, 0x00, 0xa9, 0xe4, 0xf0, 0xa3, 0x74,
+ 0x40, 0xf0, 0x78, 0x24, 0xe4, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x25, 0x74, 0x40, 0xf2, 0x90, 0x00,
+ 0x60, 0xe4, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee, 0x31, 0xae,
+ 0x90, 0x00, 0x66, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x00, 0x6e, 0xec, 0xf0, 0xa3, 0xed, 0xf0,
+ 0xa9, 0x07, 0x11, 0xc9, 0xaa, 0x04, 0xa9, 0x05, 0x90, 0x00, 0x01, 0x74, 0x07, 0x12, 0x0b, 0x7c,
+ 0x30, 0x22, 0x0b, 0xc2, 0x23, 0x90, 0x04, 0x81, 0xe4, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90, 0x00,
+ 0xad, 0xe4, 0xf0, 0xc2, 0x24, 0xc2, 0x21, 0xc2, 0x22, 0xc2, 0x00, 0x90, 0x04, 0x94, 0xf0, 0x90,
+ 0x04, 0x93, 0xf0, 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40, 0x0b, 0xe4, 0xfd, 0x7f, 0x04, 0x12, 0x1d,
+ 0x0b, 0xd2, 0x28, 0xd2, 0x0d, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0,
+ 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x00,
+ 0x6c, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xef, 0x44, 0x80, 0xfe, 0x51, 0x17, 0x00, 0xef, 0xf0, 0x00,
+ 0xe4, 0xf0, 0x00, 0x90, 0xe6, 0x49, 0xee, 0xf0, 0x00, 0xf0, 0x30, 0x1d, 0x04, 0x00, 0xf0, 0x00,
+ 0xf0, 0x22, 0x8f, 0x27, 0x90, 0x00, 0xe3, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xf4, 0x55,
+ 0x27, 0x70, 0x03, 0x7f, 0x10, 0x22, 0x7f, 0x01, 0x12, 0x32, 0xe9, 0xe5, 0x27, 0x54, 0x1e, 0x60,
+ 0x0c, 0x51, 0x17, 0x12, 0x11, 0x7f, 0xaf, 0x27, 0x12, 0x2f, 0x88, 0x51, 0x7a, 0x20, 0x1d, 0x04,
+ 0x7f, 0x04, 0x31, 0xb6, 0x51, 0x17, 0x00, 0x74, 0x06, 0xf0, 0x00, 0x74, 0x08, 0xf0, 0x00, 0xe4,
+ 0xf0, 0x12, 0x33, 0x08, 0x7f, 0x00, 0x22, 0x90, 0xe6, 0x04, 0x74, 0x80, 0xf0, 0x22, 0x8f, 0x27,
+ 0xe5, 0x60, 0x55, 0x27, 0x60, 0x03, 0x7f, 0x00, 0x22, 0xe5, 0x27, 0xf4, 0xff, 0x90, 0x00, 0xba,
+ 0xe0, 0x5f, 0xf0, 0xed, 0x60, 0x2d, 0xe0, 0x45, 0x27, 0xf0, 0x30, 0x24, 0x3a, 0x20, 0x1d, 0x37,
+ 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x31, 0x51, 0x17, 0x12, 0x11, 0x7f, 0xd2, 0x1d, 0xe4, 0x90, 0xe6,
+ 0x18, 0xf0, 0x00, 0x90, 0xe6, 0x12, 0x74, 0xa0, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x51,
+ 0x7a, 0x80, 0x14, 0x12, 0x31, 0x4d, 0xff, 0x60, 0x0c, 0x90, 0x00, 0xc7, 0xe0, 0x5f, 0x70, 0x05,
+ 0x7f, 0x01, 0x12, 0x33, 0x3f, 0x51, 0x84, 0x7f, 0x01, 0x22, 0x7f, 0x02, 0x31, 0xb6, 0xe4, 0x90,
+ 0xe6, 0x04, 0xf0, 0x22, 0x30, 0x1d, 0x2d, 0x51, 0x17, 0x7f, 0x02, 0x31, 0xb6, 0xe4, 0x90, 0xe6,
+ 0x18, 0xf0, 0x90, 0xe6, 0x12, 0x74, 0xa2, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x00, 0x90,
+ 0xe6, 0x13, 0x74, 0x22, 0xf0, 0x00, 0x90, 0xe6, 0x19, 0x74, 0x20, 0xf0, 0x00, 0xe4, 0x90, 0xe6,
+ 0x04, 0xf0, 0xc2, 0x1d, 0x22, 0x7e, 0x32, 0xef, 0x60, 0x30, 0x51, 0x17, 0x30, 0x24, 0x02, 0x7e,
+ 0x0a, 0xaf, 0x06, 0x1e, 0xef, 0x60, 0x08, 0x90, 0x00, 0x7a, 0xe0, 0xf5, 0x3a, 0x80, 0xf2, 0xe5,
+ 0xaa, 0x20, 0xe0, 0x09, 0x90, 0xe6, 0x49, 0x74, 0x02, 0xf0, 0x00, 0x80, 0xf2, 0x90, 0xe6, 0x18,
+ 0x74, 0x30, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0xd3, 0xed, 0x94, 0x01, 0xec, 0x94,
+ 0x00, 0x40, 0x1c, 0x90, 0xe6, 0xa4, 0xe0, 0x20, 0xe3, 0x04, 0x30, 0x1f, 0xf6, 0x22, 0x71, 0x29,
+ 0x12, 0x16, 0x03, 0x71, 0x29, 0x12, 0x16, 0x03, 0x90, 0xe6, 0x19, 0x74, 0x30, 0xf0, 0x22, 0x90,
+ 0xe6, 0xa4, 0xe0, 0x30, 0xe2, 0x04, 0x30, 0x1f, 0xf6, 0x22, 0x90, 0xe6, 0x94, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0xfd, 0xed, 0xc3, 0x9b, 0xee, 0x9a, 0x40, 0xf1, 0x90, 0xe6, 0x49, 0x74, 0x04, 0xf0, 0x22,
+ 0x12, 0x43, 0x7f, 0x75, 0x38, 0x64, 0xe4, 0xf5, 0x39, 0xf5, 0x54, 0xe5, 0x34, 0x60, 0x03, 0x12,
+ 0x42, 0x7f, 0x90, 0x04, 0x32, 0xe0, 0x54, 0x03, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x70,
+ 0x0a, 0xb1, 0x1a, 0x74, 0x0d, 0xf0, 0x75, 0x54, 0x38, 0x81, 0xee, 0xf1, 0x84, 0x12, 0x39, 0x81,
+ 0xef, 0x60, 0x05, 0x75, 0x54, 0x0c, 0x81, 0xee, 0xf1, 0x84, 0x12, 0x2a, 0x15, 0x12, 0x37, 0x61,
+ 0x4e, 0x70, 0x02, 0x81, 0xee, 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x34, 0x70, 0x02, 0x81, 0x4a,
+ 0x30, 0x24, 0x02, 0x81, 0x4a, 0xf1, 0x84, 0x12, 0x32, 0x04, 0xe4, 0x78, 0x18, 0xf2, 0x78, 0x15,
+ 0x74, 0x22, 0xf2, 0xe4, 0x78, 0x1b, 0xf2, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x49, 0x74, 0x88,
+ 0xf2, 0xf2, 0x12, 0x3f, 0xd2, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x64, 0x12, 0x15, 0x89, 0x80, 0x74,
+ 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x6e, 0xe5, 0x54, 0x70, 0x6a, 0x12, 0x10,
+ 0xf8, 0x12, 0x43, 0x76, 0x12, 0x43, 0x91, 0xfd, 0x90, 0xe6, 0xa3, 0xe0, 0x30, 0xe2, 0x03, 0x30,
+ 0x1f, 0xf6, 0x90, 0xe6, 0x91, 0xe0, 0xc3, 0x94, 0x40, 0x50, 0x03, 0x30, 0x1f, 0xf4, 0x20, 0x1f,
+ 0x20, 0x7a, 0xf0, 0x79, 0x00, 0x74, 0xf0, 0x12, 0x28, 0x01, 0x7f, 0x40, 0xae, 0x07, 0x1f, 0xee,
+ 0x60, 0x05, 0x12, 0x43, 0x6d, 0x80, 0xf5, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0x0d, 0xbd, 0x08,
+ 0xc7, 0x90, 0xe6, 0x9c, 0x74, 0x02, 0xf0, 0xe4, 0xa3, 0xf0, 0x12, 0x3e, 0xf5, 0x8f, 0x39, 0xf1,
+ 0xed, 0x12, 0x37, 0x52, 0x7d, 0x26, 0x7f, 0x34, 0x12, 0x15, 0x89, 0x12, 0x43, 0x5c, 0xe5, 0x39,
+ 0x60, 0x02, 0xf5, 0x54, 0xf1, 0x96, 0x80, 0x88, 0x12, 0x2f, 0xf8, 0x78, 0x04, 0x74, 0x08, 0xf2,
+ 0x78, 0x48, 0x74, 0x88, 0xf2, 0xf2, 0xf1, 0x5b, 0xe5, 0x54, 0x60, 0x02, 0x81, 0xde, 0x90, 0x04,
+ 0x96, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x81, 0xde, 0x90, 0x00, 0xe1, 0x12, 0x43, 0x0b,
+ 0x20, 0x2a, 0x29, 0xf1, 0x84, 0x12, 0x32, 0x04, 0xe4, 0xfb, 0x7d, 0x26, 0xaf, 0x38, 0xf1, 0xe8,
+ 0xef, 0x70, 0x29, 0x12, 0x43, 0x66, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0,
+ 0x60, 0x1a, 0xb1, 0x1a, 0x74, 0x01, 0xf0, 0x75, 0x54, 0x37, 0x80, 0x62, 0x12, 0x2c, 0xaf, 0xf1,
+ 0xed, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x34, 0xf1, 0xe8, 0xef, 0x70, 0x21, 0x90, 0x04, 0x2a, 0xe0,
+ 0xfc, 0xa3, 0xe0, 0xfd, 0x7b, 0x00, 0x7a, 0x02, 0xaf, 0x34, 0x51, 0xb5, 0x12, 0x3e, 0xf5, 0xe5,
+ 0x54, 0x70, 0x0a, 0x90, 0x04, 0x96, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x34, 0x60,
+ 0x10, 0xe5, 0x54, 0x70, 0x0c, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x80, 0x60,
+ 0x1b, 0xf1, 0x5b, 0xef, 0x70, 0x18, 0x12, 0x43, 0x66, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3,
+ 0xe0, 0x54, 0xe0, 0x60, 0x09, 0xb1, 0x17, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x2a, 0xe4, 0x90,
+ 0xe6, 0x18, 0xf0, 0xa3, 0x74, 0x20, 0xf0, 0xe5, 0x54, 0x60, 0x03, 0x75, 0x54, 0x37, 0x12, 0x43,
+ 0x51, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x34, 0x60, 0x15, 0x20, 0x1f, 0x12, 0x12,
+ 0x39, 0x44, 0xec, 0x4d, 0x4e, 0x4f, 0x60, 0x03, 0x12, 0x39, 0xac, 0x85, 0x54, 0x5f, 0x12, 0x2a,
+ 0x3b, 0x12, 0x42, 0x97, 0xaf, 0x54, 0x22, 0x75, 0x54, 0x8c, 0x90, 0x04, 0x9e, 0xe0, 0x24, 0x93,
+ 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0x8f, 0x26, 0xa2, 0x11, 0xb3, 0x92, 0x12, 0x90,
+ 0x00, 0x89, 0xe0, 0xf5, 0x27, 0xe4, 0xff, 0xfe, 0xfd, 0xfc, 0x90, 0x04, 0x96, 0x12, 0x29, 0xe4,
+ 0xc3, 0x60, 0x01, 0xd3, 0x92, 0x13, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0xff, 0xe5, 0x26, 0xd3,
+ 0x9f, 0x40, 0x02, 0xe1, 0x40, 0xaf, 0x26, 0x12, 0x3a, 0x47, 0x8f, 0x29, 0x74, 0xc5, 0x2f, 0x12,
+ 0x31, 0x51, 0xf5, 0x2a, 0x30, 0x2a, 0x24, 0x90, 0x04, 0x9e, 0xe0, 0xb5, 0x26, 0x1b, 0xe5, 0x27,
+ 0xb4, 0x2a, 0x16, 0x90, 0x00, 0x8b, 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x2c, 0x12, 0x29, 0xe4, 0x70,
+ 0x08, 0x90, 0x00, 0x91, 0xe0, 0x64, 0x80, 0x60, 0x02, 0xf1, 0x5b, 0x90, 0x04, 0x9e, 0xe5, 0x26,
+ 0xf0, 0xb1, 0x1e, 0xe0, 0xf5, 0x2b, 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0xe4, 0xf0, 0xe5, 0x27,
+ 0x12, 0x0d, 0x2b, 0x26, 0x3f, 0x00, 0x26, 0x6f, 0x03, 0x26, 0x04, 0x12, 0x26, 0xf0, 0x1a, 0x26,
+ 0xbf, 0x1b, 0x26, 0xd8, 0x1e, 0x26, 0x14, 0x23, 0x26, 0x14, 0x25, 0x25, 0xcb, 0x28, 0x25, 0xe0,
+ 0x2a, 0x26, 0x6c, 0x2f, 0x27, 0x1f, 0xc1, 0x00, 0x00, 0x27, 0x25, 0xaf, 0x2a, 0x12, 0x39, 0x4a,
+ 0x50, 0x02, 0xe1, 0x40, 0x30, 0x13, 0x05, 0x20, 0x11, 0x02, 0xe1, 0x40, 0xd2, 0x14, 0x80, 0x13,
+ 0xaf, 0x2a, 0x12, 0x39, 0x4a, 0x50, 0x02, 0xe1, 0x40, 0x30, 0x13, 0x05, 0x30, 0x11, 0x02, 0xe1,
+ 0x40, 0xc2, 0x14, 0x75, 0x2f, 0x01, 0x75, 0x30, 0x00, 0x75, 0x31, 0x8b, 0xaf, 0x29, 0x12, 0x28,
+ 0x97, 0x8f, 0x28, 0x22, 0x20, 0x13, 0x02, 0xe1, 0x40, 0x12, 0x43, 0x88, 0x12, 0x30, 0xca, 0x8f,
+ 0x28, 0x7f, 0x00, 0x22, 0xe5, 0x27, 0x7f, 0x08, 0xb4, 0x23, 0x02, 0x7f, 0x0c, 0x8f, 0x2c, 0x20,
+ 0x13, 0x02, 0xe1, 0x40, 0xad, 0x27, 0xaf, 0x29, 0x12, 0x36, 0xb4, 0x8f, 0x28, 0xe5, 0x28, 0x60,
+ 0x0a, 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0x74, 0x03, 0xe1, 0x0a, 0xaf, 0x2c, 0x80, 0x7c, 0x30,
+ 0x13, 0x02, 0xe1, 0x40, 0xaf, 0x29, 0x12, 0x37, 0xe9, 0x8f, 0x28, 0xe5, 0x2b, 0xb4, 0x0a, 0x0c,
+ 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0xe5, 0x2b, 0xf0, 0x7f, 0x84, 0x22, 0xe5, 0x28, 0x60, 0x09,
+ 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xe5,
+ 0x2b, 0x75, 0xf0, 0x03, 0xa4, 0x24, 0x81, 0xf5, 0x82, 0xe4, 0x34, 0x0e, 0xaf, 0x82, 0xf5, 0x2c,
+ 0x8f, 0x2d, 0x20, 0x13, 0x02, 0xe1, 0x40, 0x12, 0x36, 0x36, 0x7b, 0x12, 0x12, 0x37, 0x73, 0x12,
+ 0x36, 0x60, 0xf1, 0xfb, 0x78, 0x7c, 0x74, 0x70, 0xf2, 0xe4, 0xf2, 0x12, 0x43, 0x44, 0x70, 0x02,
+ 0x05, 0x2c, 0x75, 0x9e, 0x07, 0x74, 0x0a, 0xf2, 0x75, 0x9e, 0x0c, 0x12, 0x43, 0x44, 0x70, 0x02,
+ 0x05, 0x2c, 0xf5, 0x82, 0x85, 0x2c, 0x83, 0xe0, 0xf2, 0x7f, 0x12, 0x7e, 0x00, 0x80, 0x5a, 0x12,
+ 0x43, 0x99, 0x12, 0x32, 0x8a, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x0a, 0x74, 0x93, 0x25, 0x26, 0xb1,
+ 0x20, 0x74, 0x03, 0xf0, 0x22, 0x7f, 0x00, 0x22, 0x12, 0x43, 0x99, 0x12, 0x42, 0x62, 0x8f, 0x28,
+ 0xe5, 0x28, 0x60, 0x09, 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22,
+ 0x12, 0x43, 0x88, 0x12, 0x35, 0xd4, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x19, 0x7f, 0x02, 0xb4, 0x8f,
+ 0x02, 0x7f, 0x0e, 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0xef, 0xf0, 0xa2, 0x12, 0x92, 0x16, 0x12,
+ 0x2a, 0x42, 0xaf, 0x28, 0x22, 0xaf, 0x9e, 0x7e, 0x00, 0x12, 0x38, 0xa8, 0x7f, 0x00, 0x22, 0x12,
+ 0x3a, 0x1b, 0x7f, 0x00, 0x22, 0x74, 0x93, 0x25, 0x26, 0xb1, 0x20, 0x74, 0x07, 0xf0, 0x30, 0x11,
+ 0x09, 0xa2, 0x12, 0x92, 0x16, 0x12, 0x2a, 0x42, 0x80, 0x03, 0x12, 0x39, 0xac, 0x7f, 0x86, 0x22,
+ 0x30, 0x11, 0x09, 0xa2, 0x12, 0x92, 0x16, 0x12, 0x2a, 0x42, 0x80, 0x03, 0x12, 0x39, 0xac, 0x74,
+ 0x93, 0x25, 0x26, 0xb1, 0x20, 0x74, 0x09, 0xf0, 0x7f, 0x98, 0x22, 0x12, 0x33, 0xe1, 0xc2, 0x2a,
+ 0x12, 0x15, 0xed, 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0, 0x12, 0x2c, 0xaf, 0xf1, 0xed, 0xf1, 0x96,
+ 0xef, 0x60, 0x03, 0xaf, 0x54, 0x22, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x34, 0xf1, 0xe8, 0xef, 0x60,
+ 0x02, 0xaf, 0x54, 0x22, 0xab, 0x35, 0xaa, 0x36, 0xa9, 0x37, 0x22, 0xe4, 0xf5, 0x58, 0xfb, 0x7f,
+ 0x18, 0x7d, 0x26, 0x12, 0x15, 0x89, 0x74, 0xff, 0xf5, 0x3a, 0xf5, 0x3b, 0x90, 0xe2, 0x22, 0xe0,
+ 0x54, 0x66, 0x70, 0x11, 0x12, 0x11, 0x75, 0xe5, 0x3b, 0x15, 0x3b, 0x70, 0x02, 0x15, 0x3a, 0xe5,
+ 0x3b, 0x45, 0x3a, 0x70, 0xe7, 0xe5, 0x54, 0x70, 0x26, 0x90, 0xe2, 0x22, 0xe0, 0x20, 0xe1, 0x0c,
+ 0x75, 0x54, 0x89, 0xb1, 0x1a, 0x74, 0x03, 0xf0, 0xd2, 0x07, 0x80, 0x13, 0x90, 0x04, 0x37, 0xe0,
+ 0x60, 0x0d, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60, 0x60, 0x05, 0xb1, 0x17, 0x74, 0x01, 0xf0, 0xaf,
+ 0x54, 0x22, 0xe4, 0x7f, 0xdc, 0xfb, 0x7d, 0x26, 0x12, 0x15, 0x89, 0x80, 0xa9, 0x90, 0x04, 0x33,
+ 0xe0, 0xf5, 0x55, 0xa3, 0xe0, 0xf5, 0x56, 0x22, 0x11, 0x45, 0x32, 0x7a, 0xf8, 0x79, 0x00, 0x74,
+ 0xf8, 0xf5, 0x9d, 0x74, 0x00, 0xf5, 0x9e, 0x22, 0x12, 0x43, 0x76, 0x11, 0x01, 0xe4, 0xf5, 0x38,
+ 0x7f, 0x08, 0x11, 0x3f, 0xef, 0x60, 0x03, 0x7f, 0x99, 0x22, 0x74, 0xf8, 0x12, 0x43, 0x91, 0xff,
+ 0x12, 0x43, 0x6d, 0x0f, 0xbf, 0x40, 0xf9, 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0xa3, 0x74, 0x40, 0xf0,
+ 0x05, 0x38, 0xe5, 0x38, 0xc3, 0x94, 0x08, 0x40, 0xd7, 0x12, 0x10, 0xf8, 0x7f, 0x00, 0x22, 0x8f,
+ 0x39, 0x74, 0xff, 0xf5, 0x3a, 0xf5, 0x3b, 0xe4, 0xf5, 0x3c, 0xe5, 0x3b, 0x15, 0x3b, 0xae, 0x3a,
+ 0x70, 0x02, 0x15, 0x3a, 0x4e, 0x60, 0x0d, 0x90, 0xe6, 0xa5, 0xe0, 0x55, 0x39, 0x60, 0x05, 0x12,
+ 0x11, 0x75, 0x80, 0xe6, 0x90, 0xe6, 0xa5, 0xe0, 0x55, 0x39, 0x60, 0x21, 0x75, 0x3c, 0x99, 0xe4,
+ 0x90, 0xe6, 0x1a, 0xf0, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
+ 0xf0, 0x11, 0x90, 0xe5, 0x4f, 0xd3, 0x94, 0x04, 0x40, 0x03, 0x12, 0x30, 0x3c, 0xaf, 0x3c, 0x22,
+ 0x90, 0xe6, 0x1a, 0x74, 0x40, 0xf0, 0x22, 0x12, 0x36, 0x44, 0x8f, 0x33, 0xe5, 0x33, 0xb4, 0x02,
+ 0x0c, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x03, 0x51, 0x26, 0x7f, 0x84, 0x22, 0x20, 0x14, 0x0f,
+ 0x30, 0x1b, 0x0c, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x0d, 0x51, 0x26, 0x7f, 0x38, 0x22, 0xe5,
+ 0x33, 0x64, 0x01, 0x70, 0x25, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x33, 0xcb, 0x12,
+ 0x33, 0xe1, 0x30, 0x14, 0x0e, 0x7f, 0x01, 0x12, 0x17, 0x56, 0x31, 0xf3, 0x12, 0x16, 0x10, 0x8f,
+ 0x32, 0x80, 0x07, 0x31, 0xf3, 0x12, 0x23, 0x30, 0x8f, 0x32, 0x11, 0x90, 0x20, 0x2a, 0x02, 0xf1,
+ 0x80, 0x30, 0x14, 0x23, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02,
+ 0xc0, 0x03, 0x51, 0x0f, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0x12,
+ 0x0b, 0xc6, 0x90, 0x00, 0xef, 0x80, 0x21, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0,
+ 0x01, 0xc0, 0x02, 0xc0, 0x03, 0x51, 0x0f, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01,
+ 0xd0, 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xd9, 0x30, 0x1e, 0x1e, 0x90, 0x00,
+ 0xf3, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xeb, 0x31, 0xe4, 0x50, 0x0d, 0x90, 0x00, 0xf7, 0x12, 0x0c,
+ 0xa1, 0x90, 0x00, 0xef, 0x31, 0xe4, 0x40, 0x04, 0xd2, 0x15, 0x31, 0x7d, 0x30, 0x0a, 0x13, 0x90,
+ 0x04, 0x76, 0xe0, 0xb4, 0x12, 0x0c, 0xe4, 0x90, 0x04, 0x80, 0xf0, 0x53, 0x21, 0xfb, 0xc2, 0x15,
+ 0x31, 0x7d, 0x30, 0x20, 0x03, 0x12, 0x17, 0xa5, 0xc2, 0x1f, 0xaf, 0x32, 0x22, 0x90, 0x00, 0xfe,
+ 0x30, 0x15, 0x09, 0x74, 0x43, 0xf0, 0xa3, 0x74, 0x16, 0xf0, 0x80, 0x07, 0x74, 0x02, 0xf0, 0xa3,
+ 0x74, 0x18, 0xf0, 0x90, 0x00, 0xfe, 0xe0, 0xf5, 0x18, 0xa3, 0xe0, 0xf5, 0x19, 0xe4, 0xf5, 0x1a,
+ 0x75, 0x1b, 0x04, 0x90, 0x00, 0xeb, 0x31, 0xeb, 0xa3, 0xe0, 0xf5, 0x1e, 0xa3, 0xe0, 0xf5, 0x1f,
+ 0x31, 0xfc, 0x12, 0x1e, 0xff, 0x90, 0x00, 0xfe, 0xe0, 0x44, 0x80, 0xf5, 0x18, 0x90, 0x00, 0xef,
+ 0xe0, 0xf5, 0x1a, 0xa3, 0xe0, 0xf5, 0x1b, 0xa3, 0x31, 0xeb, 0x31, 0xfc, 0x12, 0x1e, 0xff, 0x90,
+ 0x00, 0xeb, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00,
+ 0x00, 0x00, 0x00, 0x22, 0x12, 0x0c, 0xad, 0xc3, 0x02, 0x0c, 0x30, 0xe0, 0xf5, 0x1c, 0xa3, 0xe0,
+ 0xf5, 0x1d, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31, 0x7f, 0x01, 0x22, 0x78, 0x34, 0x7c, 0x00,
+ 0x7d, 0x00, 0x7b, 0x00, 0x7a, 0x00, 0x79, 0x18, 0x7e, 0x00, 0x7f, 0x08, 0x02, 0x0b, 0x10, 0xab,
+ 0x2f, 0xaa, 0x30, 0xa9, 0x31, 0x90, 0x00, 0x05, 0x12, 0x0b, 0x4f, 0xfe, 0x90, 0x00, 0x06, 0x12,
+ 0x0b, 0x4f, 0xfd, 0xed, 0xff, 0x22, 0x30, 0x15, 0x06, 0xc2, 0x16, 0x51, 0x42, 0x80, 0x03, 0x12,
+ 0x39, 0xac, 0x12, 0x25, 0x1a, 0xe5, 0x34, 0xf0, 0x75, 0x5f, 0x22, 0xc2, 0x00, 0x51, 0x6e, 0xd2,
+ 0x27, 0x22, 0x90, 0x00, 0xad, 0xe0, 0x60, 0x18, 0x12, 0x39, 0x44, 0xec, 0x4d, 0x4e, 0x4f, 0x60,
+ 0x0f, 0x20, 0x16, 0x0a, 0x51, 0x61, 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0x00, 0xa3, 0xf0, 0x51, 0xdf,
+ 0x22, 0xe5, 0x4f, 0xb4, 0x05, 0x07, 0x90, 0xe6, 0xa5, 0xe0, 0x30, 0xe2, 0xf9, 0x22, 0x90, 0x00,
+ 0xad, 0xe0, 0x60, 0x6a, 0x12, 0x36, 0x36, 0x7f, 0x02, 0x12, 0x21, 0xb6, 0x12, 0x11, 0xa0, 0x7a,
+ 0xf8, 0x79, 0x00, 0x7e, 0xf8, 0x12, 0x27, 0xff, 0x78, 0x7c, 0x74, 0x55, 0xf2, 0x74, 0x53, 0xf2,
+ 0x74, 0x42, 0xf2, 0x74, 0x53, 0xf2, 0x90, 0x04, 0x9a, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0,
+ 0xf2, 0xa3, 0xe0, 0xf2, 0x90, 0x04, 0x99, 0xe0, 0xf2, 0x90, 0x04, 0x98, 0xe0, 0xf2, 0x90, 0x04,
+ 0x97, 0xe0, 0xf2, 0x90, 0x04, 0x96, 0xe0, 0xf2, 0xe5, 0x5f, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01,
+ 0x78, 0x7c, 0xef, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x99,
+ 0x74, 0x0d, 0xf2, 0x12, 0x11, 0xce, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x02, 0x51, 0xdf, 0x22, 0x51,
+ 0x61, 0x78, 0xa5, 0x74, 0x01, 0xf2, 0x22, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x10, 0x75, 0x5f, 0x02,
+ 0x51, 0x6e, 0x90, 0xe6, 0xa3, 0x74, 0x01, 0xf0, 0x90, 0xe6, 0xa5, 0xf0, 0x22, 0x74, 0x00, 0xf5,
+ 0x9a, 0x74, 0x7e, 0xf5, 0x9b, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9a, 0xf0, 0x90, 0xe6, 0x7b,
+ 0xe0, 0x90, 0x04, 0x9b, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9c, 0xf0, 0x90, 0xe6, 0x7b,
+ 0xe0, 0x90, 0x04, 0x9d, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x99, 0xf0, 0x90, 0xe6, 0x7b,
+ 0xe0, 0x90, 0x04, 0x98, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x97, 0xf0, 0x90, 0xe6, 0x7b,
+ 0xe0, 0x90, 0x04, 0x96, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x12, 0x32, 0x6e, 0x24, 0xff, 0x92, 0x10,
+ 0xe0, 0x54, 0x0f, 0xff, 0xc2, 0x27, 0xa2, 0x10, 0x92, 0x11, 0x12, 0x25, 0x28, 0x8f, 0x5f, 0x90,
+ 0x04, 0xa5, 0xe0, 0x20, 0xe2, 0x05, 0x20, 0x27, 0x02, 0x51, 0x3b, 0x22, 0x8f, 0x2b, 0x90, 0x00,
+ 0xc8, 0xe0, 0xff, 0x54, 0x1e, 0x60, 0x01, 0x22, 0x12, 0x3d, 0x43, 0xe5, 0x2b, 0x54, 0x1e, 0x70,
+ 0x02, 0x81, 0x40, 0x12, 0x40, 0x0d, 0x12, 0x40, 0x4c, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00,
+ 0xdc, 0xf0, 0x12, 0x42, 0xe2, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xf5, 0x54, 0x91,
+ 0xaf, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x15, 0x89, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0xf1,
+ 0x32, 0x75, 0x57, 0x01, 0x75, 0x58, 0xaa, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x20, 0x12, 0x27, 0xe8,
+ 0xe5, 0x54, 0x70, 0x18, 0x90, 0xe2, 0x0b, 0xe0, 0xb4, 0x06, 0x0c, 0xa3, 0xe0, 0x54, 0xfc, 0xff,
+ 0xbf, 0xa8, 0x04, 0xd2, 0x2b, 0x80, 0x05, 0x75, 0x54, 0x9a, 0x80, 0x64, 0xe4, 0xf5, 0x54, 0x91,
+ 0xaf, 0x12, 0x27, 0xe2, 0xe5, 0x54, 0x70, 0x2c, 0x90, 0xe2, 0x08, 0xe0, 0x64, 0xdc, 0x70, 0x24,
+ 0xe5, 0x2b, 0x30, 0xe1, 0x1f, 0x12, 0x3d, 0x97, 0x91, 0xb9, 0xe5, 0x54, 0x70, 0x16, 0x90, 0x00,
+ 0xc8, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0x00, 0xc6, 0x74,
+ 0x02, 0xf0, 0x80, 0x2c, 0xe5, 0x54, 0x64, 0x89, 0x70, 0x23, 0xe5, 0x2b, 0x30, 0xe2, 0x1e, 0x91,
+ 0xcf, 0x91, 0xb9, 0xe5, 0x54, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x00,
+ 0xc7, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x04, 0xf0, 0x80, 0x03, 0xe4, 0xf5, 0x54,
+ 0x12, 0x33, 0xc4, 0x70, 0x13, 0x90, 0xe6, 0x0d, 0x04, 0xf0, 0x12, 0x11, 0x64, 0x90, 0xe6, 0x0e,
+ 0x74, 0x0a, 0xf0, 0x12, 0x11, 0x64, 0x80, 0x36, 0xe4, 0xfd, 0x7f, 0x02, 0xf1, 0xf5, 0xf1, 0x0d,
+ 0x7f, 0x44, 0x12, 0x27, 0xe8, 0xd1, 0xf2, 0x70, 0x24, 0x7f, 0x42, 0x7e, 0x57, 0x7d, 0x59, 0x7c,
+ 0x43, 0x90, 0xfc, 0x00, 0x31, 0xe4, 0x70, 0x15, 0x7e, 0x00, 0x7f, 0xcb, 0x7c, 0xfc, 0x7d, 0x04,
+ 0x7b, 0x10, 0x7a, 0x00, 0x12, 0x14, 0x6f, 0x90, 0x00, 0xdc, 0x74, 0x01, 0xf0, 0x00, 0x90, 0x04,
+ 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x3f, 0xff, 0xff, 0x12, 0x10, 0xf8, 0x12, 0x42, 0xfe, 0xc2, 0x07,
+ 0x12, 0x43, 0x51, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0xe4,
+ 0xf5, 0x55, 0xf5, 0x56, 0xf5, 0x57, 0xf5, 0x58, 0x22, 0xe5, 0x54, 0x70, 0x11, 0x91, 0xaf, 0x75,
+ 0x57, 0x02, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x40, 0x12, 0x27, 0xe8, 0x12, 0x3f, 0xbc, 0x22, 0x74,
+ 0x01, 0x12, 0x40, 0x7e, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x15, 0x89, 0x90, 0xe2, 0x22, 0xe0, 0x30,
+ 0xe0, 0xf9, 0xf1, 0x32, 0x7f, 0x04, 0x12, 0x14, 0xad, 0xe5, 0x54, 0x60, 0x02, 0xa1, 0xa3, 0xe4,
+ 0x90, 0x04, 0x33, 0xf0, 0xa3, 0x74, 0x03, 0xf0, 0xe4, 0xf5, 0x55, 0x75, 0x56, 0x03, 0xfb, 0x7d,
+ 0x26, 0x7f, 0x0c, 0x12, 0x27, 0xe8, 0xef, 0x60, 0x02, 0xa1, 0xa3, 0x7f, 0x04, 0xb1, 0xdd, 0xef,
+ 0x60, 0x02, 0xa1, 0xa3, 0x12, 0x3d, 0x6b, 0xf1, 0xe5, 0x60, 0x02, 0xa1, 0xa3, 0x90, 0x04, 0x35,
+ 0xe0, 0xd3, 0x94, 0x03, 0x40, 0x77, 0x12, 0x41, 0x2d, 0x12, 0x10, 0xf8, 0x12, 0x3f, 0xbc, 0xf1,
+ 0x0d, 0x7f, 0x20, 0x12, 0x27, 0xe8, 0xef, 0x70, 0x6a, 0xd1, 0xf2, 0x70, 0x66, 0x75, 0x55, 0x03,
+ 0x75, 0x56, 0xb9, 0x75, 0x57, 0x01, 0x12, 0x27, 0x8b, 0x90, 0xfc, 0xc4, 0xe0, 0xb4, 0x03, 0x05,
+ 0x12, 0x3f, 0xf5, 0x80, 0x03, 0x12, 0x3d, 0x86, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x39, 0x90, 0xfc,
+ 0xd7, 0xe0, 0xff, 0x90, 0x00, 0xdb, 0xe0, 0xfe, 0xb1, 0xcf, 0xef, 0xf0, 0x90, 0xfc, 0xd6, 0xe0,
+ 0xff, 0xee, 0x12, 0x43, 0x36, 0xef, 0xf0, 0x90, 0xfc, 0xd5, 0xe0, 0xff, 0xee, 0x12, 0x43, 0x28,
+ 0xef, 0xf0, 0x90, 0xfc, 0xd4, 0xe0, 0xff, 0xee, 0x12, 0x43, 0x1a, 0xef, 0xf0, 0xee, 0xb1, 0xcf,
+ 0xd1, 0xf9, 0xb1, 0xcb, 0x12, 0x0c, 0xd9, 0x12, 0x0e, 0xf9, 0x12, 0x11, 0x64, 0x90, 0x04, 0x37,
+ 0x74, 0x04, 0xf0, 0x22, 0x12, 0x0b, 0xe1, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed,
+ 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0xe5, 0x0f, 0x2f, 0xf5, 0x0f, 0xe5, 0x0e, 0x3e, 0xf5,
+ 0x0e, 0xe5, 0x0d, 0x3d, 0xf5, 0x0d, 0xe5, 0x0c, 0x3c, 0xf5, 0x0c, 0x90, 0x00, 0xdb, 0xe0, 0x25,
+ 0xe0, 0x25, 0xe0, 0x24, 0xcb, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x8f, 0x2d, 0x12,
+ 0x27, 0xed, 0x12, 0x37, 0x52, 0x7d, 0x7e, 0x7f, 0x24, 0x12, 0x27, 0xe8, 0xef, 0x60, 0x03, 0x7f,
+ 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x5b, 0x12, 0x14, 0x67, 0xe5, 0x2d, 0x64, 0x04, 0x60, 0x05, 0xe5,
+ 0x2d, 0xb4, 0x08, 0x0a, 0x90, 0xe2, 0x09, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0x80, 0x03, 0x12, 0x43,
+ 0x66, 0x90, 0x04, 0x35, 0xf0, 0xe5, 0x2d, 0xb4, 0x02, 0x21, 0x90, 0x04, 0x35, 0xe0, 0x60, 0x1b,
+ 0x90, 0xe2, 0x10, 0x12, 0x0c, 0xa1, 0xee, 0x54, 0xfc, 0xfe, 0xe4, 0x24, 0x00, 0xff, 0xee, 0x34,
+ 0x04, 0x12, 0x3a, 0x14, 0xfc, 0x90, 0x00, 0xdb, 0xe0, 0x80, 0x70, 0x90, 0xe2, 0x0e, 0xe0, 0x54,
+ 0x3c, 0x13, 0x13, 0x54, 0x3f, 0xfb, 0xa3, 0xe0, 0x54, 0x0f, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xff,
+ 0xe4, 0x8f, 0x31, 0x8e, 0x30, 0xf5, 0x2f, 0xf5, 0x2e, 0x90, 0xe2, 0x12, 0xe0, 0x54, 0x0e, 0xc3,
+ 0x13, 0xfa, 0xe5, 0x31, 0x24, 0x01, 0xf5, 0x31, 0xe4, 0x3e, 0xf5, 0x30, 0xe4, 0x35, 0x2f, 0xf5,
+ 0x2f, 0xe4, 0x35, 0x2e, 0xf5, 0x2e, 0x0a, 0x0a, 0xeb, 0x64, 0x09, 0x60, 0x05, 0xeb, 0x24, 0xf7,
+ 0x2a, 0xfa, 0xaf, 0x31, 0xae, 0x30, 0xad, 0x2f, 0xac, 0x2e, 0xab, 0x02, 0xa8, 0x03, 0x12, 0x0c,
+ 0x54, 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xb1, 0xcf, 0x12, 0x0c, 0xd9, 0x90, 0xe2, 0x1f, 0xe0, 0x54,
+ 0x03, 0xff, 0xbf, 0x01, 0x0b, 0xeb, 0xb1, 0xcf, 0xd1, 0xf9, 0xeb, 0xb1, 0xcf, 0x12, 0x0c, 0xd9,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xb1, 0xcf, 0xd1, 0xf9, 0xeb, 0xb1, 0xcf, 0x12, 0x0c, 0xd9, 0x90,
+ 0xe2, 0x17, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0xff, 0x90, 0x04, 0x32, 0xe0, 0x54, 0xfc, 0x4f,
+ 0xf0, 0x90, 0xe2, 0x0f, 0xe0, 0x30, 0xe6, 0x17, 0x91, 0xaf, 0x75, 0x55, 0x04, 0x75, 0x56, 0x04,
+ 0xe4, 0xfb, 0xfd, 0x7f, 0x10, 0x12, 0x15, 0x89, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0x7f,
+ 0x00, 0x22, 0x7f, 0x10, 0x12, 0x3e, 0xfe, 0xef, 0x22, 0x12, 0x0c, 0xa1, 0xef, 0x24, 0xff, 0xff,
+ 0xee, 0x34, 0xff, 0xfe, 0xed, 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0x22, 0x91, 0xaf, 0x7b,
+ 0x04, 0x7d, 0x26, 0x22, 0xe4, 0xfc, 0x91, 0xaf, 0x30, 0x14, 0x05, 0x12, 0x27, 0xed, 0x7c, 0x26,
+ 0xad, 0x04, 0xe4, 0xfb, 0x7f, 0x1c, 0x12, 0x15, 0x89, 0xec, 0x60, 0x03, 0x12, 0x27, 0x96, 0xaf,
+ 0x54, 0x22, 0x7f, 0x05, 0x7e, 0x00, 0x8e, 0x30, 0x8f, 0x31, 0xe5, 0x31, 0x25, 0xe0, 0xf5, 0x31,
+ 0xe5, 0x30, 0x33, 0xf5, 0x30, 0xe5, 0x31, 0x15, 0x31, 0xae, 0x30, 0x70, 0x02, 0x15, 0x30, 0x4e,
+ 0x60, 0x05, 0x12, 0x11, 0x64, 0x80, 0xee, 0x22, 0xc2, 0x1f, 0xf1, 0x80, 0xf1, 0xb0, 0xe4, 0x90,
+ 0xe2, 0x24, 0xf0, 0x00, 0x12, 0x33, 0xac, 0x12, 0x33, 0x77, 0xf1, 0xeb, 0x90, 0xe2, 0x42, 0x74,
+ 0x25, 0xf0, 0x12, 0x33, 0xcb, 0x7f, 0x1e, 0x71, 0x6c, 0xc2, 0x07, 0xc2, 0x05, 0x12, 0x33, 0x08,
+ 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x20, 0xf0, 0x22, 0x8f, 0x2a, 0x7f, 0x03, 0x7e, 0x01, 0x90, 0xe2,
+ 0xa4, 0xe0, 0x5f, 0x6f, 0x60, 0x19, 0x90, 0xe2, 0xa6, 0xef, 0xf0, 0xee, 0x12, 0x10, 0xeb, 0xf1,
+ 0x80, 0xf1, 0xb0, 0x12, 0x33, 0xcb, 0x12, 0x37, 0x59, 0xaf, 0x2a, 0x71, 0x6c, 0xf1, 0x80, 0x22,
+ 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0x90, 0x04, 0xa4, 0xe0, 0x60, 0x29, 0x43, 0xb4, 0x40, 0x90, 0x00,
+ 0xe6, 0xe0, 0x60, 0x0e, 0x43, 0xa0, 0x40, 0x7f, 0x96, 0x7e, 0x00, 0xf1, 0x36, 0x53, 0xa0, 0xbf,
+ 0x80, 0x0c, 0x53, 0xa0, 0xbf, 0x7f, 0x96, 0x7e, 0x00, 0xf1, 0x36, 0x43, 0xa0, 0x40, 0x7f, 0x96,
+ 0x7e, 0x00, 0xf1, 0x36, 0x22, 0xd2, 0x14, 0xf1, 0x14, 0xef, 0x22, 0x51, 0x61, 0x90, 0x00, 0xdd,
+ 0xe0, 0x54, 0xfd, 0xf0, 0x22, 0x12, 0x3f, 0xd0, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x15, 0x74,
+ 0x62, 0xf2, 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0,
+ 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xe5, 0x4f, 0xd3, 0x94, 0x04,
+ 0x40, 0x06, 0x11, 0x3c, 0xc2, 0x28, 0xd2, 0x0d, 0x12, 0x20, 0x45, 0xd0, 0x07, 0xd0, 0x06, 0xd0,
+ 0x05, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe4, 0xfd, 0x7f, 0x02,
+ 0x12, 0x1d, 0x0b, 0x75, 0x4f, 0x04, 0x22, 0x12, 0x20, 0x45, 0xd2, 0x25, 0x32, 0x12, 0x20, 0x45,
+ 0x32, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00,
+ 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x78, 0x8b,
+ 0xe2, 0xff, 0xc3, 0x90, 0x00, 0xb2, 0xe0, 0x9f, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x94, 0x00, 0xf0,
+ 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x05, 0x12, 0x1f, 0xbd, 0xd2, 0x23, 0x11, 0xc0, 0x74, 0x0c,
+ 0xf0, 0x90, 0x04, 0x85, 0x74, 0x40, 0xf0, 0x78, 0x8b, 0xf1, 0x85, 0x7a, 0xe7, 0x79, 0x40, 0x12,
+ 0x1d, 0x2f, 0x12, 0x20, 0x45, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0,
+ 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32,
+ 0x74, 0x43, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x84, 0x22, 0x8f, 0x2e, 0x74, 0xc5, 0x2f, 0x31,
+ 0x51, 0x64, 0x01, 0x60, 0x0a, 0x90, 0x00, 0xb7, 0x74, 0x11, 0xf0, 0xa3, 0x74, 0x2a, 0xf0, 0x31,
+ 0x46, 0xe0, 0x24, 0x04, 0x30, 0x1b, 0x0b, 0xf5, 0x82, 0xe4, 0x3e, 0xf5, 0x83, 0x74, 0x05, 0xf0,
+ 0x80, 0x08, 0xf5, 0x82, 0xe4, 0x3e, 0xf5, 0x83, 0xe4, 0xf0, 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x41,
+ 0x12, 0x0b, 0x36, 0xff, 0x90, 0x00, 0xb7, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xf5, 0x82, 0x8c, 0x83,
+ 0xef, 0xf0, 0x31, 0xfe, 0x8d, 0x82, 0x8c, 0x83, 0x51, 0x75, 0x11, 0xc0, 0x74, 0x10, 0xf0, 0xe5,
+ 0x2e, 0xc4, 0x54, 0xf0, 0x90, 0x04, 0x85, 0xf0, 0x74, 0xc5, 0x25, 0x2e, 0x31, 0x51, 0x90, 0x04,
+ 0x86, 0xf0, 0x31, 0x46, 0xe0, 0xaa, 0x06, 0xf9, 0x7b, 0x01, 0x7f, 0x2a, 0x12, 0x1d, 0x2f, 0x80,
+ 0x02, 0x31, 0xbe, 0x7f, 0x00, 0x22, 0x90, 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0x22, 0x74, 0xc5, 0x25,
+ 0x27, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0, 0x22, 0x8f, 0x26, 0x75, 0x27, 0x01, 0x31,
+ 0x4d, 0xf5, 0x28, 0xe4, 0xf5, 0x29, 0x71, 0x7a, 0x74, 0xc5, 0x25, 0x27, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0xe4, 0xf0, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x71, 0xac, 0x12, 0x11, 0x64, 0x7f,
+ 0x01, 0x51, 0xe9, 0x7f, 0x1e, 0x12, 0x2f, 0x88, 0x71, 0x08, 0x31, 0x4d, 0x65, 0x28, 0x60, 0x2d,
+ 0xe5, 0x26, 0x60, 0x13, 0x31, 0x4d, 0xfe, 0x45, 0x28, 0xff, 0xe5, 0x28, 0xd3, 0x9e, 0x7d, 0x00,
+ 0x40, 0x02, 0x7d, 0x01, 0x12, 0x1f, 0x2d, 0xe5, 0x27, 0x60, 0x07, 0x90, 0x00, 0xb9, 0xe0, 0x20,
+ 0xe0, 0x05, 0x90, 0x04, 0x93, 0x80, 0x03, 0x90, 0x04, 0x94, 0x74, 0x0a, 0xf0, 0x22, 0x31, 0x46,
+ 0xe0, 0x4e, 0x60, 0x39, 0xd1, 0x36, 0xe4, 0xff, 0xef, 0x24, 0x04, 0xfd, 0xe4, 0x33, 0xfc, 0x90,
+ 0x00, 0xb7, 0xe0, 0xfa, 0xa3, 0xe0, 0x2d, 0xf5, 0x82, 0xea, 0x3c, 0xf5, 0x83, 0xe0, 0xfe, 0x74,
+ 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf8, 0xf5, 0x83, 0xee, 0xf0, 0x0f, 0xbf, 0x24, 0xd9, 0x7f,
+ 0x24, 0x7e, 0x00, 0x12, 0x38, 0xa8, 0xe4, 0x90, 0x00, 0xb7, 0xf0, 0xa3, 0xf0, 0x22, 0x90, 0x00,
+ 0x01, 0x02, 0x0b, 0x4f, 0x8b, 0x3a, 0x8a, 0x3b, 0x89, 0x3c, 0xc0, 0x03, 0xc0, 0x02, 0xc0, 0x01,
+ 0x12, 0x0c, 0x67, 0x12, 0x42, 0xe2, 0x12, 0x0c, 0xad, 0x12, 0x0b, 0xc6, 0xd0, 0x01, 0xd0, 0x02,
+ 0xd0, 0x03, 0x12, 0x0c, 0x87, 0x90, 0x04, 0x39, 0xe0, 0xab, 0x3a, 0xaa, 0x3b, 0xa9, 0x3c, 0x70,
+ 0x1c, 0x31, 0xfe, 0x90, 0x00, 0x02, 0x51, 0x67, 0x4f, 0xf5, 0x55, 0xee, 0x90, 0x00, 0x03, 0x51,
+ 0x67, 0x4f, 0xf5, 0x56, 0xee, 0x25, 0xe0, 0xf5, 0x57, 0xe4, 0xf5, 0x58, 0x22, 0x12, 0x0b, 0x36,
+ 0xf5, 0x55, 0x31, 0xfe, 0xf5, 0x56, 0x90, 0x00, 0x02, 0x12, 0x0b, 0x4f, 0xf5, 0x57, 0x90, 0x00,
+ 0x03, 0x12, 0x0b, 0x4f, 0xf5, 0x58, 0x22, 0x25, 0xe0, 0xff, 0x12, 0x0b, 0x4f, 0xfe, 0xc4, 0x13,
+ 0x13, 0x13, 0x54, 0x01, 0x22, 0xa3, 0xf0, 0x90, 0x04, 0xa5, 0xe0, 0x44, 0x0c, 0xf0, 0x30, 0x22,
+ 0x08, 0x30, 0x0b, 0xfa, 0x12, 0x0f, 0xff, 0x80, 0xf5, 0x22, 0x8f, 0x2e, 0x8d, 0x2f, 0x90, 0x00,
+ 0xc7, 0xe0, 0xfd, 0xa3, 0xe0, 0x90, 0x00, 0xc7, 0xf0, 0xd1, 0x44, 0x90, 0x00, 0xc7, 0xed, 0xf0,
+ 0xef, 0x14, 0x70, 0x11, 0x71, 0xe1, 0xaf, 0x2f, 0x71, 0x3f, 0x12, 0x2f, 0x80, 0x90, 0x04, 0x37,
+ 0xe0, 0xf5, 0x1a, 0x80, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x28, 0x75, 0x19,
+ 0x11, 0x75, 0x18, 0xc3, 0x74, 0xc5, 0x25, 0x2e, 0x31, 0x51, 0xf5, 0x1b, 0xe5, 0x2e, 0xc4, 0x54,
+ 0xf0, 0xf5, 0x1a, 0xe5, 0x2f, 0x54, 0x03, 0xf5, 0x1d, 0xe4, 0x90, 0x00, 0xb7, 0xf0, 0x51, 0x75,
+ 0x12, 0x29, 0xfc, 0x12, 0x1e, 0xff, 0x7f, 0x00, 0x22, 0xad, 0x07, 0x71, 0x29, 0x74, 0x38, 0xf0,
+ 0x12, 0x2f, 0xeb, 0xed, 0x60, 0x09, 0xd2, 0x1c, 0x90, 0xe2, 0x42, 0x74, 0x29, 0xf0, 0x22, 0xc2,
+ 0x1c, 0x90, 0xe2, 0x42, 0x74, 0x11, 0xf0, 0x22, 0x90, 0x00, 0xe1, 0x74, 0x02, 0xf0, 0x7a, 0xf8,
+ 0x71, 0x31, 0x74, 0x26, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe2, 0x42, 0xe0,
+ 0x54, 0xfe, 0xf0, 0xe4, 0x90, 0xe2, 0x41, 0xf0, 0x22, 0x90, 0x00, 0xe1, 0x74, 0x14, 0xf0, 0x7a,
+ 0xfc, 0x7b, 0x01, 0x79, 0x00, 0x90, 0x00, 0xde, 0x12, 0x0d, 0x22, 0x90, 0x00, 0xe2, 0x22, 0xe4,
+ 0xf5, 0x54, 0xef, 0x30, 0xe0, 0x1d, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x70, 0x26, 0x12, 0x2f,
+ 0xe5, 0x70, 0x21, 0x90, 0x00, 0xc7, 0xe0, 0xff, 0x71, 0xc4, 0xfe, 0xef, 0x4e, 0x90, 0x00, 0xc7,
+ 0xf0, 0x80, 0x11, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x60, 0x05, 0xc2, 0x14, 0x12, 0x2f, 0x14,
+ 0x71, 0x81, 0xf1, 0x7c, 0xaf, 0x54, 0x22, 0x12, 0x11, 0x64, 0x90, 0x00, 0xc8, 0xe0, 0x54, 0xe1,
+ 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0xe1, 0xf0, 0x22, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x71,
+ 0xac, 0x00, 0x12, 0x11, 0x75, 0x90, 0x04, 0x38, 0xe0, 0x90, 0xe2, 0x1f, 0xf0, 0x00, 0x90, 0xe2,
+ 0x2e, 0x74, 0x03, 0xf0, 0x00, 0x12, 0x11, 0x75, 0x7f, 0x01, 0x80, 0x93, 0x90, 0xe2, 0x21, 0x74,
+ 0x20, 0xf0, 0x22, 0xe4, 0x90, 0x00, 0xe5, 0xf0, 0x71, 0xc4, 0x60, 0x06, 0x71, 0xcb, 0xf1, 0x59,
+ 0x71, 0x89, 0x61, 0x08, 0x90, 0x00, 0xc8, 0xe0, 0x54, 0x1e, 0x22, 0x90, 0xe6, 0x01, 0x74, 0xa3,
+ 0xf0, 0x90, 0xe6, 0x09, 0x74, 0xff, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x01, 0xf0, 0x12, 0x3d,
+ 0x4e, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0xdf, 0xf0, 0x22, 0x71, 0xc4, 0x60, 0x0f, 0x90, 0x00, 0xdd,
+ 0xe0, 0x20, 0xe0, 0x02, 0x71, 0xcb, 0x71, 0xe1, 0xe4, 0xff, 0x71, 0x3f, 0x12, 0x2f, 0x80, 0x90,
+ 0x00, 0xe5, 0x74, 0x5a, 0xf0, 0x22, 0x74, 0xc5, 0x2f, 0x31, 0x51, 0x60, 0x03, 0xed, 0x60, 0x03,
+ 0x7f, 0x0a, 0x22, 0x12, 0x0c, 0x67, 0x8f, 0x0b, 0x8e, 0x0a, 0x8d, 0x09, 0x8c, 0x08, 0x12, 0x2a,
+ 0x15, 0xf1, 0x61, 0x71, 0xe1, 0x90, 0x04, 0x39, 0xe0, 0x70, 0x58, 0xaf, 0x0b, 0xae, 0x0a, 0xad,
+ 0x09, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xad, 0xb1, 0x45, 0xb1, 0x2e, 0xfd, 0x90, 0x04, 0x3b, 0x12,
+ 0x0c, 0xad, 0x12, 0x2d, 0xa4, 0x12, 0x3a, 0x0b, 0xfc, 0x78, 0x09, 0x12, 0x0c, 0x54, 0xef, 0x24,
+ 0xff, 0xf5, 0x13, 0xee, 0x34, 0xff, 0xf5, 0x12, 0xed, 0x34, 0xff, 0xf5, 0x11, 0xec, 0x34, 0xff,
+ 0xf5, 0x10, 0xaf, 0x13, 0xae, 0x12, 0xad, 0x11, 0xfc, 0xb1, 0x1c, 0xd3, 0x12, 0x0c, 0x30, 0x40,
+ 0x03, 0x7f, 0x0c, 0x22, 0xaf, 0x13, 0xae, 0x12, 0xad, 0x11, 0xac, 0x10, 0xb1, 0x39, 0x40, 0x3e,
+ 0x7f, 0x0c, 0x22, 0xb1, 0x1c, 0xc0, 0x00, 0xb1, 0x25, 0x12, 0x0c, 0x41, 0xd0, 0x00, 0xb1, 0x45,
+ 0xb1, 0x25, 0x12, 0x0c, 0x41, 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xb1, 0x2e, 0xfd,
+ 0x12, 0x2d, 0xa4, 0x12, 0x0c, 0xa1, 0xb1, 0x1c, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03, 0x7f, 0x0c,
+ 0x22, 0x12, 0x2d, 0xcb, 0x12, 0x0c, 0xa1, 0xb1, 0x39, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x85, 0x0b,
+ 0x58, 0x85, 0x0a, 0x57, 0x85, 0x09, 0x56, 0x85, 0x08, 0x55, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x80,
+ 0x12, 0x27, 0xe8, 0xef, 0x60, 0x03, 0xaf, 0x54, 0x22, 0x85, 0x0f, 0x58, 0x85, 0x0e, 0x57, 0x85,
+ 0x0d, 0x56, 0x85, 0x0c, 0x55, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x84, 0x12, 0x27, 0xe8, 0xef, 0x60,
+ 0x03, 0xaf, 0x54, 0x22, 0x12, 0x2c, 0xaf, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x98, 0x12, 0x27, 0xe8,
+ 0xef, 0x60, 0x03, 0xaf, 0x54, 0x22, 0x12, 0x27, 0xed, 0xf1, 0x52, 0x7d, 0x26, 0x7f, 0x34, 0x12,
+ 0x27, 0xe8, 0xe5, 0x54, 0x70, 0xf0, 0x12, 0x2f, 0x80, 0x7f, 0x00, 0x22, 0xab, 0x0b, 0xaa, 0x0a,
+ 0xa9, 0x09, 0xa8, 0x08, 0x22, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xa1, 0x78, 0x09, 0x22, 0x90, 0x04,
+ 0x2a, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xe4, 0xfc, 0x22, 0xab, 0x0f, 0xaa, 0x0e, 0xa9, 0x0d, 0xa8,
+ 0x0c, 0xd3, 0x02, 0x0c, 0x30, 0x12, 0x0b, 0xe1, 0x8f, 0x0b, 0x8e, 0x0a, 0x8d, 0x09, 0x8c, 0x08,
+ 0x8f, 0x0f, 0x8e, 0x0e, 0x8d, 0x0d, 0x8c, 0x0c, 0x22, 0x71, 0xc4, 0xfe, 0x5f, 0xfd, 0x60, 0x0f,
+ 0xff, 0xc2, 0x14, 0x12, 0x2f, 0x14, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x15, 0x89, 0x71, 0x77, 0x43,
+ 0xb4, 0x41, 0xe4, 0x90, 0x00, 0xc6, 0xf0, 0x43, 0xa0, 0x40, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22,
+ 0x74, 0xc5, 0x2f, 0x31, 0x51, 0x60, 0x03, 0xed, 0x60, 0x07, 0x7d, 0x0a, 0x7f, 0x02, 0x02, 0x1e,
+ 0xbf, 0xeb, 0x14, 0x60, 0x12, 0x14, 0x60, 0x17, 0x24, 0x02, 0x70, 0x1c, 0x75, 0x59, 0x04, 0x75,
+ 0x5a, 0x45, 0x75, 0x5b, 0x05, 0x80, 0x11, 0x75, 0x59, 0x04, 0x75, 0x5a, 0x4a, 0x80, 0x06, 0x75,
+ 0x59, 0x04, 0x75, 0x5a, 0x5b, 0x75, 0x5b, 0x11, 0x74, 0x02, 0x11, 0xc2, 0x74, 0x15, 0xf0, 0xe4,
+ 0x90, 0x04, 0x85, 0xf0, 0x90, 0x04, 0x86, 0xe5, 0x5b, 0xf0, 0xaa, 0x59, 0xa9, 0x5a, 0x7b, 0x01,
+ 0xff, 0x02, 0x1d, 0x2f, 0xd1, 0x44, 0x90, 0x00, 0xfe, 0xef, 0xf0, 0xbf, 0x02, 0x03, 0x7f, 0x84,
+ 0x22, 0x31, 0xfe, 0xfe, 0x54, 0xc0, 0xff, 0xbf, 0xc0, 0x03, 0x7f, 0x8f, 0x22, 0xee, 0x54, 0x3f,
+ 0xff, 0x64, 0x3f, 0x60, 0x05, 0xef, 0x64, 0x1c, 0x70, 0x36, 0xd1, 0x36, 0x7b, 0x40, 0xf1, 0x73,
+ 0xd1, 0x60, 0x12, 0x27, 0xff, 0x90, 0xe6, 0x7c, 0x74, 0x03, 0xf0, 0xe4, 0xf0, 0x90, 0x00, 0xfe,
+ 0xe0, 0xb4, 0x01, 0x10, 0x90, 0x04, 0x32, 0xe0, 0x54, 0x03, 0x60, 0x08, 0x90, 0xe6, 0x7c, 0x74,
+ 0x80, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0x80, 0x03,
+ 0x7f, 0x85, 0x22, 0x7f, 0x00, 0x22, 0xe5, 0x4f, 0xb4, 0x05, 0x08, 0x90, 0xe6, 0xa5, 0xe0, 0x54,
+ 0x09, 0x70, 0xf8, 0x22, 0x90, 0x00, 0xc7, 0xe0, 0xfe, 0xa3, 0xe0, 0x5e, 0xbf, 0x01, 0x0e, 0x54,
+ 0x1e, 0x60, 0x0a, 0x90, 0x00, 0xba, 0xe0, 0x30, 0xe1, 0x03, 0x7f, 0x01, 0x22, 0x7f, 0x02, 0x22,
+ 0x8e, 0x4a, 0x8f, 0x4b, 0x8d, 0x4c, 0x8a, 0x4d, 0x8b, 0x4e, 0xf1, 0x6a, 0xe5, 0x4a, 0xf5, 0x9a,
+ 0xe5, 0x4b, 0xf5, 0x9b, 0xe5, 0x4e, 0xae, 0x4d, 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8,
+ 0xf9, 0xff, 0xe5, 0x4e, 0x54, 0x07, 0xfd, 0xef, 0x1f, 0xaa, 0x06, 0x70, 0x01, 0x1e, 0x4a, 0x60,
+ 0x0f, 0xac, 0x4c, 0x78, 0x7b, 0xec, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0x80, 0xe7,
+ 0xaf, 0x05, 0x1d, 0xef, 0x60, 0x07, 0x78, 0x7b, 0xe5, 0x4c, 0xf2, 0x80, 0xf3, 0x12, 0x11, 0xb7,
+ 0x85, 0x5e, 0xe8, 0x22, 0x8d, 0x2e, 0xe4, 0xfd, 0xd1, 0x44, 0xac, 0x07, 0xbc, 0x02, 0x03, 0x7f,
+ 0x84, 0x22, 0xd1, 0x36, 0x12, 0x27, 0xff, 0xe5, 0x2e, 0xb4, 0x23, 0x0c, 0xe4, 0x90, 0xe6, 0x7c,
+ 0xf0, 0xf0, 0xf0, 0x74, 0x08, 0xf0, 0x7d, 0x02, 0xec, 0x70, 0x2a, 0x90, 0x00, 0xbd, 0xe0, 0x90,
+ 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbe, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0x90,
+ 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xc0, 0xf1, 0x41, 0x90, 0x00, 0xbb, 0xe0, 0x90, 0xe6, 0x7c, 0xf0,
+ 0x90, 0x00, 0xbc, 0x80, 0x34, 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x12, 0x2d, 0xcf, 0xe0, 0x90, 0xe6,
+ 0x7c, 0xf0, 0xef, 0x12, 0x43, 0x36, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xdb, 0xe0, 0xff,
+ 0x12, 0x43, 0x28, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0x12, 0x43, 0x1a, 0xf1, 0x41, 0x90, 0x00,
+ 0xc9, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xca, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x7f, 0x00,
+ 0x22, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xed, 0xf0, 0xe4, 0xf0, 0x22, 0x90, 0xe6, 0x14, 0xf0, 0x02,
+ 0x16, 0x03, 0xe4, 0xf5, 0x57, 0xf5, 0x58, 0xfb, 0x22, 0xe4, 0x90, 0xe6, 0x02, 0xf0, 0xa3, 0xf0,
+ 0x22, 0x90, 0x04, 0x2a, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x85, 0xe8, 0x5e, 0xe4, 0xf5, 0xe8,
+ 0x02, 0x11, 0x89, 0x7e, 0xf8, 0x7f, 0x00, 0x7a, 0x00, 0xe4, 0xfd, 0x22, 0x90, 0xe2, 0x1f, 0xe0,
+ 0x90, 0x04, 0x38, 0xf0, 0x22, 0xe2, 0x90, 0x04, 0x86, 0xf0, 0xe2, 0xff, 0x7b, 0x01, 0x22, 0xc0,
+ 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01,
+ 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x11, 0xc0, 0x74, 0x0c,
+ 0xf0, 0x90, 0x04, 0x85, 0x74, 0x60, 0xf0, 0x78, 0x8d, 0xf1, 0x85, 0x7a, 0xe7, 0x79, 0x80, 0x12,
+ 0x1d, 0x2f, 0x12, 0x1f, 0xbd, 0x78, 0x8d, 0xe4, 0xf2, 0x53, 0x91, 0xef, 0xf5, 0xa1, 0xd0, 0x07,
+ 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0,
+ 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xd1, 0x44, 0xbf, 0x02, 0x03, 0x7f, 0x84,
+ 0x22, 0x7f, 0x00, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0,
+ 0x00, 0xc0, 0x06, 0xc0, 0x07, 0xe4, 0x53, 0x91, 0xef, 0xf5, 0xa1, 0x20, 0x00, 0x65, 0x90, 0xe6,
+ 0xa3, 0xe0, 0x20, 0xe2, 0x5e, 0x90, 0xf0, 0x00, 0xe0, 0xb4, 0x55, 0x17, 0xa3, 0xe0, 0xb4, 0x53,
+ 0x12, 0xa3, 0xe0, 0xb4, 0x42, 0x0d, 0xa3, 0xe0, 0xb4, 0x43, 0x08, 0x90, 0xe6, 0x91, 0xe0, 0x64,
+ 0x1f, 0x60, 0x15, 0x90, 0x00, 0xab, 0x74, 0x01, 0xf0, 0x78, 0x49, 0x74, 0x82, 0xf2, 0x78, 0xa3,
+ 0x74, 0x01, 0xf2, 0x78, 0xa5, 0xf2, 0x80, 0x2b, 0x7f, 0x00, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4,
+ 0x34, 0xf0, 0xf5, 0x83, 0xe0, 0xfe, 0x74, 0x7a, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83,
+ 0xee, 0xf0, 0x0f, 0xbf, 0x1f, 0xe4, 0x90, 0xf0, 0x00, 0xe4, 0xf0, 0x90, 0xe6, 0x49, 0x74, 0x82,
+ 0xf0, 0xd2, 0x00, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0,
+ 0xe0, 0x32, 0x12, 0x16, 0x03, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0x78, 0x80, 0xe2, 0x44, 0x0a,
+ 0xf2, 0x7f, 0x64, 0x7e, 0x00, 0x12, 0x2f, 0x36, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x90, 0xe3, 0x5f,
+ 0xf0, 0x78, 0x5f, 0xf2, 0x53, 0x91, 0xef, 0x22, 0xc2, 0x14, 0xc2, 0x15, 0x90, 0x00, 0xad, 0xe0,
+ 0x70, 0x02, 0x21, 0x3b, 0x90, 0x04, 0x98, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0x9f, 0xec, 0x9e,
+ 0x50, 0x06, 0xae, 0x04, 0xaf, 0x05, 0x80, 0x00, 0xee, 0x31, 0x3c, 0x4e, 0x60, 0x6d, 0x90, 0x00,
+ 0xa9, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x31, 0x74, 0x50, 0x0c, 0xd2, 0x14, 0x90, 0x04, 0x98, 0xe0,
+ 0xff, 0xa3, 0xe0, 0xcf, 0x31, 0x3c, 0x90, 0x00, 0xfe, 0xe0, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00,
+ 0xa3, 0xe0, 0x78, 0x99, 0xf2, 0x31, 0x44, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x00, 0xfe, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0xfb, 0xaa, 0x06, 0xe4, 0xf9, 0xf8, 0xd0, 0x07, 0xd0, 0x06, 0x12, 0x0b, 0xd3, 0x90,
+ 0x04, 0x96, 0x12, 0x0c, 0xd9, 0x90, 0x00, 0xaa, 0xe0, 0x24, 0xff, 0xff, 0x90, 0x00, 0xa9, 0xe0,
+ 0x34, 0xff, 0xfe, 0x90, 0x00, 0xfe, 0xe0, 0x5e, 0xfe, 0xa3, 0xe0, 0x5f, 0x4e, 0x60, 0x02, 0xd2,
+ 0x15, 0x20, 0x14, 0x07, 0xa2, 0x15, 0x92, 0x16, 0x12, 0x2a, 0x42, 0x22, 0x90, 0x00, 0xfe, 0xf0,
+ 0xa3, 0xef, 0xf0, 0x22, 0x90, 0x04, 0x96, 0x02, 0x0c, 0xa1, 0xab, 0x07, 0xeb, 0x70, 0x02, 0xc3,
+ 0x22, 0x31, 0x44, 0xbb, 0x01, 0x06, 0x7b, 0x0b, 0x79, 0x0b, 0x80, 0x04, 0x7b, 0x09, 0x79, 0x09,
+ 0xa8, 0x01, 0x12, 0x0c, 0x41, 0x90, 0x00, 0x90, 0xe0, 0x6e, 0x70, 0x03, 0xa3, 0xe0, 0x6f, 0xc3,
+ 0x60, 0x01, 0xd3, 0x22, 0xe4, 0xfc, 0xfd, 0x90, 0x04, 0x96, 0x12, 0x0c, 0xad, 0xd3, 0x02, 0x0c,
+ 0x30, 0x12, 0x2a, 0x15, 0xe4, 0xfc, 0xfd, 0x12, 0x0c, 0xb9, 0x12, 0x0b, 0xc6, 0x90, 0x04, 0x2c,
+ 0x12, 0x0c, 0xd9, 0x12, 0x2d, 0xcb, 0x51, 0x0b, 0xfc, 0x90, 0x04, 0x2c, 0x31, 0x7a, 0x40, 0x09,
+ 0x12, 0x25, 0x1a, 0x74, 0x08, 0xf0, 0x7f, 0x0c, 0x22, 0x7f, 0x00, 0x22, 0xe4, 0xf5, 0x3a, 0xf5,
+ 0x3b, 0x78, 0x04, 0x74, 0x80, 0xf2, 0x12, 0x11, 0x7f, 0xe5, 0xaa, 0x20, 0xe0, 0x2e, 0x90, 0xe6,
+ 0xa3, 0xe0, 0xc4, 0x54, 0x07, 0xff, 0x60, 0x13, 0x7e, 0x00, 0x90, 0x00, 0xa9, 0xe0, 0xfc, 0xa3,
+ 0xe0, 0xfd, 0x12, 0x0b, 0x9e, 0x8e, 0x3a, 0x8f, 0x3b, 0x80, 0x11, 0x90, 0xe6, 0x90, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0x7c, 0x00, 0x24, 0x00, 0xf5, 0x3b, 0xec, 0x3e, 0xf5, 0x3a, 0xae, 0x3a, 0xaf, 0x3b,
+ 0x31, 0x74, 0x40, 0x0d, 0x90, 0xe6, 0xa3, 0xe0, 0x44, 0x01, 0xf0, 0xe4, 0x90, 0xe6, 0x04, 0xf0,
+ 0x22, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x7f, 0x02, 0x02, 0x21, 0xb6, 0x12, 0x0c, 0xa1, 0xef, 0x24,
+ 0x01, 0xff, 0xe4, 0x3e, 0xfe, 0xe4, 0x3d, 0xfd, 0xe4, 0x3c, 0x22, 0x12, 0x27, 0xfb, 0xe4, 0x90,
+ 0xe6, 0x7c, 0xf0, 0xe5, 0x14, 0xf0, 0xe4, 0xf0, 0xe5, 0x15, 0xf0, 0xe5, 0x16, 0xf0, 0xe5, 0x17,
+ 0xf0, 0x90, 0x04, 0x9f, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x04, 0xa0, 0xe0, 0x90, 0xe6, 0x7c,
+ 0xf0, 0xaf, 0x9e, 0x7e, 0x00, 0x01, 0xa8, 0x7e, 0x01, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1b,
+ 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x3c, 0xef, 0xd3, 0x94, 0x01, 0x40, 0x08, 0x90, 0x00, 0xdb, 0x74,
+ 0x01, 0xf0, 0xff, 0x22, 0xef, 0x60, 0x10, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x17, 0x20, 0x19,
+ 0x02, 0x80, 0x12, 0xd2, 0x1b, 0x80, 0x18, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x04, 0xe4, 0xfe,
+ 0x80, 0x0d, 0x20, 0x19, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x1b, 0xaf,
+ 0x06, 0x22, 0xef, 0x60, 0x03, 0x7f, 0x01, 0x22, 0x90, 0x00, 0xb9, 0xe0, 0x7f, 0x01, 0x30, 0xe0,
+ 0x02, 0x7f, 0x00, 0x22, 0x53, 0x91, 0xdf, 0x32, 0x75, 0x92, 0xe6, 0x90, 0xe6, 0x0d, 0x74, 0x01,
+ 0xf0, 0xa3, 0x74, 0x0a, 0xf0, 0x90, 0xe6, 0x00, 0x74, 0x14, 0xf0, 0xc2, 0x88, 0x43, 0xb8, 0x04,
+ 0xe4, 0xf5, 0x8e, 0x78, 0x82, 0x74, 0x05, 0xf2, 0x75, 0xaf, 0x07, 0x78, 0x04, 0x74, 0x02, 0xf2,
+ 0x00, 0x00, 0x00, 0x78, 0x12, 0x74, 0xa2, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x18, 0xf2, 0x00,
+ 0x00, 0x00, 0x78, 0x04, 0x74, 0x04, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x13, 0x74, 0x22, 0xf2, 0x00,
+ 0x00, 0x00, 0x78, 0x19, 0x74, 0x20, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x00,
+ 0x00, 0x00, 0x78, 0x14, 0x74, 0xe2, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1a, 0x74, 0x40, 0xf2, 0x00,
+ 0x00, 0x00, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x15, 0x74, 0x62, 0xf2, 0x00,
+ 0x00, 0x00, 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x04, 0xf2, 0x00, 0x00,
+ 0x00, 0x90, 0xe3, 0x04, 0xf0, 0x90, 0xe2, 0xa6, 0xf0, 0xa3, 0xf0, 0x00, 0x00, 0x00, 0x78, 0x0b,
+ 0x74, 0x03, 0xf2, 0x00, 0x00, 0x00, 0x90, 0xe2, 0x1f, 0x74, 0x20, 0xf0, 0x90, 0xe4, 0xdf, 0xf0,
+ 0x75, 0xe8, 0x03, 0xd2, 0xdd, 0xc2, 0x19, 0xd2, 0x1a, 0x22, 0xe4, 0x90, 0x00, 0xfc, 0xf0, 0xa3,
+ 0xf0, 0x90, 0x04, 0x87, 0xa3, 0xe0, 0x30, 0xe0, 0x14, 0x90, 0x04, 0x87, 0xe4, 0x75, 0xf0, 0x01,
+ 0x12, 0x0b, 0xb0, 0x90, 0x04, 0x8f, 0xe4, 0x75, 0xf0, 0x01, 0x12, 0x0b, 0xb0, 0x51, 0xa8, 0x12,
+ 0x1f, 0xf8, 0x91, 0x28, 0xd2, 0xaf, 0xc2, 0xac, 0xd2, 0xa8, 0xd2, 0xaa, 0x90, 0xe2, 0x7a, 0xe0,
+ 0x54, 0xbf, 0xf0, 0x90, 0xe2, 0x7e, 0xe0, 0x44, 0x04, 0xf0, 0x91, 0x67, 0x12, 0x14, 0x14, 0x30,
+ 0x26, 0x20, 0x90, 0x00, 0xfc, 0xe4, 0x75, 0xf0, 0x01, 0x12, 0x0b, 0xb0, 0x90, 0x00, 0xfc, 0xe0,
+ 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x0c, 0xf5, 0x29, 0xf5, 0x2a, 0xf5, 0x2b, 0xfb, 0xfd, 0xff, 0x12,
+ 0x1e, 0xde, 0xc2, 0xaf, 0x30, 0x00, 0x0c, 0x90, 0x04, 0xa5, 0xe0, 0x20, 0xe2, 0x05, 0xd2, 0xaf,
+ 0x12, 0x2a, 0xe7, 0xd2, 0xaf, 0x30, 0x08, 0x02, 0x91, 0x25, 0x30, 0x09, 0x08, 0x30, 0x2a, 0x03,
+ 0x12, 0x27, 0x5b, 0x91, 0x26, 0x30, 0x0a, 0x08, 0x30, 0x2a, 0x03, 0x12, 0x27, 0x5b, 0x91, 0x27,
+ 0x30, 0x0b, 0x09, 0x30, 0x2a, 0x03, 0x12, 0x27, 0x5b, 0x12, 0x0f, 0xff, 0x30, 0x05, 0x0d, 0x90,
+ 0x00, 0xe8, 0xe0, 0x60, 0x05, 0x7f, 0x01, 0x12, 0x31, 0x5a, 0xc2, 0x05, 0x30, 0x07, 0x03, 0x12,
+ 0x2f, 0x58, 0x30, 0x0d, 0x8a, 0x7f, 0xff, 0x30, 0x28, 0x05, 0x12, 0x21, 0xd2, 0x80, 0x02, 0x91,
+ 0x44, 0xc2, 0x0d, 0x61, 0x9f, 0x22, 0x22, 0x22, 0x90, 0x04, 0xa0, 0x74, 0x06, 0xf0, 0x90, 0x04,
+ 0x9f, 0xe0, 0x70, 0x0f, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0xf0, 0xe4, 0x90, 0xe2, 0xa4, 0xf0, 0x90,
+ 0xe2, 0xa6, 0xf0, 0x22, 0x90, 0x00, 0xc8, 0xe0, 0x5f, 0xff, 0x90, 0x00, 0xe3, 0xe0, 0x70, 0x03,
+ 0x7f, 0x11, 0x22, 0xef, 0x54, 0x1e, 0x60, 0x08, 0x12, 0x35, 0x59, 0x90, 0x00, 0xc8, 0xef, 0xf0,
+ 0xe4, 0x90, 0x00, 0xe3, 0xf0, 0xff, 0x22, 0xe4, 0x90, 0x00, 0xb6, 0xf0, 0x90, 0x00, 0xc7, 0xf0,
+ 0x90, 0x00, 0xb9, 0xf0, 0xa3, 0xf0, 0xf5, 0x60, 0x90, 0x00, 0xdd, 0xf0, 0x90, 0x00, 0xdc, 0xf0,
+ 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xbb, 0x74, 0x08, 0xf0, 0xa3, 0xe4, 0xf0, 0xa3, 0x12, 0x0c,
+ 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xc9, 0x74, 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x12, 0x2d,
+ 0xcb, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x00, 0xc8, 0xf0, 0x12, 0x33, 0x29,
+ 0x74, 0x38, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x02, 0xf0, 0xc2, 0x20, 0xc2, 0x1d, 0x90, 0x00,
+ 0xe6, 0x14, 0xf0, 0xe4, 0x90, 0x00, 0xc5, 0xf0, 0xa3, 0xf0, 0xc2, 0x1e, 0x90, 0x00, 0xeb, 0x12,
+ 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00,
+ 0x90, 0x00, 0xe7, 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0xa3, 0x74, 0x01, 0xf0, 0xa3, 0xf0, 0xe4, 0xf5,
+ 0xb2, 0x75, 0xb4, 0x40, 0x75, 0xa0, 0x40, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x90, 0xe2,
+ 0x43, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x06, 0x90, 0xe2, 0x41, 0x74, 0x01,
+ 0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0,
+ 0x75, 0xd0, 0x00, 0xc0, 0x07, 0xc2, 0x8b, 0x90, 0x00, 0xe8, 0xe0, 0xff, 0x90, 0xe2, 0x31, 0xe0,
+ 0x5f, 0x60, 0x05, 0x74, 0xff, 0xf0, 0xd2, 0x05, 0xd0, 0x07, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83,
+ 0xd0, 0xe0, 0x32, 0x74, 0x30, 0xb1, 0x7e, 0x74, 0x03, 0xb1, 0x74, 0x74, 0x78, 0xf0, 0x90, 0x04,
+ 0x3f, 0xe0, 0x90, 0xe6, 0x0d, 0xf0, 0x12, 0x11, 0x7f, 0x90, 0x04, 0x36, 0xe0, 0x90, 0xe6, 0x0e,
+ 0xf0, 0x12, 0x11, 0x7f, 0x90, 0x04, 0x40, 0xe0, 0xf5, 0x8e, 0x22, 0xb1, 0x7c, 0x04, 0xb1, 0x74,
+ 0x04, 0xf0, 0x80, 0xda, 0xf0, 0xa3, 0x14, 0xf0, 0x90, 0x04, 0x36, 0x22, 0x74, 0x02, 0x90, 0x00,
+ 0xe4, 0xf0, 0x90, 0x04, 0x3f, 0x22, 0xb1, 0x7c, 0x14, 0xf0, 0xa3, 0x04, 0xf0, 0x90, 0x04, 0x30,
+ 0xe0, 0x90, 0x04, 0x36, 0xf0, 0x80, 0xb7, 0x75, 0x2c, 0x02, 0x7f, 0x02, 0x12, 0x14, 0xad, 0xe5,
+ 0x54, 0x60, 0x02, 0xc1, 0xe0, 0xe4, 0x7f, 0x0c, 0x12, 0x27, 0xe5, 0xef, 0x60, 0x02, 0xc1, 0xe0,
+ 0x90, 0xe2, 0x08, 0xe0, 0x54, 0xfc, 0x64, 0x0c, 0x70, 0x30, 0xd1, 0xe1, 0x54, 0x1f, 0x64, 0x02,
+ 0x70, 0x28, 0x90, 0xe2, 0x08, 0xd1, 0xeb, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x33, 0xf0,
+ 0x90, 0xe2, 0x09, 0xd1, 0xeb, 0xfe, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x34, 0xf0, 0xe0,
+ 0x70, 0x0c, 0x90, 0x04, 0x33, 0xe0, 0x70, 0x06, 0x80, 0xbb, 0x75, 0x54, 0x8b, 0x22, 0x7f, 0x02,
+ 0x12, 0x2d, 0xdd, 0xef, 0x60, 0x02, 0xc1, 0xe0, 0xb1, 0x86, 0x12, 0x2f, 0xe5, 0x60, 0x02, 0xc1,
+ 0xe0, 0x90, 0xe2, 0x09, 0xe0, 0x30, 0xe3, 0x08, 0x90, 0x04, 0x3a, 0x74, 0x01, 0xf0, 0xc1, 0xc7,
+ 0x12, 0x40, 0x9d, 0x12, 0x27, 0xe2, 0xef, 0x60, 0x02, 0xc1, 0xe0, 0xd1, 0xe1, 0x54, 0x1f, 0x64,
+ 0x04, 0x60, 0x04, 0x75, 0x54, 0x8a, 0x22, 0x7d, 0x08, 0x12, 0x41, 0x21, 0x7b, 0x04, 0x7d, 0x26,
+ 0x7f, 0xcc, 0x12, 0x27, 0xe8, 0xef, 0x60, 0x02, 0xc1, 0xe0, 0x12, 0x2e, 0xf2, 0x60, 0x02, 0xc1,
+ 0xe0, 0x90, 0xfc, 0x00, 0xe0, 0x54, 0x0f, 0x90, 0x04, 0x35, 0xf0, 0x90, 0xfc, 0x01, 0xe0, 0x30,
+ 0xe2, 0x1b, 0x12, 0x27, 0xe2, 0xef, 0x60, 0x02, 0xc1, 0xe0, 0x12, 0x2c, 0xaf, 0x75, 0x58, 0x02,
+ 0xe4, 0x12, 0x27, 0x8e, 0xef, 0x70, 0x79, 0x90, 0xe2, 0x1f, 0x74, 0x06, 0xf0, 0xf1, 0xe4, 0x90,
+ 0x04, 0x35, 0xe0, 0xd3, 0x94, 0x00, 0x40, 0x4f, 0xe4, 0xf5, 0x55, 0x75, 0x56, 0xff, 0x75, 0x57,
+ 0xff, 0x75, 0x58, 0xf1, 0x7d, 0x40, 0xff, 0xf1, 0xc0, 0x12, 0x10, 0xf8, 0xe4, 0x90, 0xfc, 0x0d,
+ 0xf0, 0x7b, 0x04, 0x12, 0x27, 0x8f, 0x12, 0x2e, 0xf2, 0x70, 0x45, 0x90, 0xfc, 0x0d, 0xe0, 0x30,
+ 0xe1, 0x25, 0x12, 0x10, 0xf8, 0xe4, 0x90, 0xfc, 0x10, 0xf0, 0x75, 0x55, 0x80, 0x7b, 0x04, 0x12,
+ 0x27, 0x8f, 0x12, 0x2e, 0xf2, 0x70, 0x29, 0x90, 0xfc, 0x10, 0xe0, 0x54, 0x0f, 0x64, 0x01, 0x60,
+ 0x04, 0x75, 0x54, 0x83, 0x22, 0xf1, 0xf5, 0x90, 0x04, 0x37, 0x74, 0x02, 0xf0, 0x90, 0x00, 0xea,
+ 0xe0, 0x60, 0x0d, 0xe5, 0xa0, 0x55, 0x2c, 0x60, 0x07, 0x90, 0x04, 0x32, 0xe0, 0x44, 0x01, 0xf0,
+ 0x22, 0x90, 0xe2, 0x0b, 0xe0, 0x54, 0x78, 0x13, 0x13, 0x13, 0x22, 0xe0, 0xc4, 0x33, 0x33, 0x54,
+ 0xc0, 0xff, 0xa3, 0xe0, 0x22, 0x90, 0xe2, 0x21, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x80, 0x8f, 0x3a,
+ 0x90, 0x04, 0x41, 0x12, 0x0c, 0xa1, 0x8f, 0x3e, 0x8e, 0x3d, 0x8d, 0x3c, 0x8c, 0x3b, 0xaf, 0x3e,
+ 0xae, 0x3d, 0xad, 0x3c, 0xac, 0x3b, 0xec, 0x4d, 0x4e, 0x4f, 0x60, 0x33, 0x20, 0x29, 0x30, 0x90,
+ 0xe2, 0x31, 0xe0, 0x55, 0x3a, 0x70, 0x28, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x64, 0x70, 0x20, 0x20,
+ 0x1f, 0x1d, 0x12, 0x11, 0x75, 0xe5, 0x3e, 0x24, 0xff, 0xf5, 0x3e, 0xe5, 0x3d, 0x34, 0xff, 0xf5,
+ 0x3d, 0xe5, 0x3c, 0x34, 0xff, 0xf5, 0x3c, 0xe5, 0x3b, 0x34, 0xff, 0xf5, 0x3b, 0x80, 0xbf, 0xe5,
+ 0x54, 0x70, 0x2c, 0x90, 0xe2, 0x31, 0xe0, 0x55, 0x3a, 0x70, 0x10, 0x20, 0x29, 0x0d, 0x75, 0x54,
+ 0x89, 0x12, 0x25, 0x1a, 0x74, 0x03, 0xf0, 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04, 0x37, 0xe0, 0x60,
+ 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60, 0x60, 0x06, 0x12, 0x25, 0x17, 0x74, 0x01, 0xf0, 0xaf,
+ 0x54, 0x22, 0x8f, 0x2d, 0xad, 0x2d, 0xe4, 0xff, 0xf1, 0xd0, 0x12, 0x2c, 0xaf, 0xe4, 0xfb, 0x7f,
+ 0x4c, 0x12, 0x27, 0x91, 0xef, 0x70, 0x24, 0x90, 0xe2, 0x21, 0x74, 0x02, 0xf0, 0x7f, 0x80, 0xd1,
+ 0xfe, 0xef, 0x70, 0x17, 0xad, 0x2d, 0xe4, 0xff, 0x12, 0x2f, 0xf5, 0x7b, 0x04, 0x7d, 0x26, 0x7f,
+ 0x38, 0x12, 0x27, 0xe8, 0xef, 0x70, 0x04, 0x7f, 0x10, 0xd1, 0xfe, 0x22, 0xe4, 0xfd, 0x7f, 0x02,
+ 0xae, 0x07, 0x90, 0xe2, 0x2c, 0xed, 0xf0, 0x12, 0x16, 0x03, 0x90, 0xe2, 0x2d, 0xee, 0xf0, 0x22,
+ 0xf1, 0xc0, 0x7d, 0x01, 0x7c, 0x00, 0x7f, 0x30, 0xab, 0x07, 0xed, 0x90, 0xe2, 0x1c, 0xf0, 0xeb,
+ 0x4c, 0xa3, 0xf0, 0x22, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0, 0x22, 0xa3, 0xf0, 0xff, 0xf1, 0x82,
+ 0x90, 0xfc, 0x00, 0xe0, 0x22, 0x90, 0x00, 0xe4, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x3f, 0xf0, 0xe4,
+ 0xa3, 0xf0, 0x90, 0x04, 0x31, 0xe0, 0x90, 0x04, 0x36, 0xf0, 0x02, 0x3d, 0x4e, 0xe4, 0x90, 0x04,
+ 0x2a, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x33, 0xf0, 0xa3, 0xf0, 0x12, 0x2d, 0xcb, 0x12, 0x0c, 0xe5,
+ 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x04, 0x32, 0xf0, 0x90, 0x04, 0x39, 0xf0, 0xc2, 0x2b, 0x90,
+ 0x04, 0x37, 0xf0, 0xc2, 0x2a, 0xa3, 0xf0, 0xc2, 0x29, 0xc2, 0x2a, 0x90, 0x04, 0x3a, 0xf0, 0x90,
+ 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0xff, 0xff, 0x02, 0x3d, 0x43, 0x74, 0x02, 0x11, 0x7e,
+ 0x90, 0xe2, 0x19, 0x74, 0xa5, 0xf0, 0x12, 0x16, 0x03, 0x11, 0x8c, 0x12, 0x3f, 0xe4, 0x12, 0x16,
+ 0x03, 0xe4, 0x90, 0xe2, 0x32, 0xf0, 0x12, 0x16, 0x03, 0xe4, 0x11, 0x94, 0x11, 0x85, 0x90, 0xe2,
+ 0x2e, 0x74, 0x03, 0xf0, 0x12, 0x16, 0x03, 0x90, 0xe2, 0x29, 0x74, 0xff, 0xf0, 0x22, 0x90, 0xe2,
+ 0x1f, 0xf0, 0x02, 0x16, 0x03, 0x90, 0xe2, 0x34, 0xf0, 0x02, 0x16, 0x03, 0xe4, 0x90, 0xe2, 0x1b,
+ 0xf0, 0x02, 0x16, 0x03, 0x90, 0xe2, 0x33, 0xf0, 0x12, 0x16, 0x03, 0xe4, 0x22, 0x90, 0x04, 0x65,
+ 0xe0, 0x54, 0x01, 0xff, 0x7e, 0x01, 0x90, 0x04, 0x35, 0xe0, 0xfb, 0x70, 0x17, 0xef, 0x70, 0x0a,
+ 0x90, 0x04, 0x66, 0xe0, 0x54, 0xfe, 0xc3, 0x13, 0x04, 0xfe, 0xaf, 0x06, 0xe4, 0xfc, 0xfd, 0xfe,
+ 0x78, 0x09, 0x80, 0x49, 0xeb, 0x64, 0x01, 0x70, 0x57, 0xf5, 0x2d, 0x12, 0x27, 0xe3, 0xef, 0x70,
+ 0x4f, 0x7d, 0x40, 0x31, 0x21, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x34, 0x12, 0x27, 0xe8, 0xef, 0x70,
+ 0x3f, 0x12, 0x2e, 0xf2, 0x70, 0x3a, 0x90, 0xfc, 0x0a, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0xf5, 0x2d,
+ 0x12, 0x0e, 0xf9, 0x12, 0x10, 0xf8, 0xe5, 0x2d, 0xd3, 0x94, 0x00, 0x40, 0x19, 0xe5, 0x2d, 0x94,
+ 0x0a, 0x50, 0x13, 0xe4, 0xff, 0x7e, 0x20, 0xfd, 0xfc, 0xa9, 0x2d, 0xa8, 0x01, 0x12, 0x0c, 0x54,
+ 0x90, 0x04, 0x3b, 0x02, 0x0c, 0xd9, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00,
+ 0x22, 0xe4, 0xff, 0x12, 0x2f, 0xf5, 0x90, 0xe2, 0x1e, 0x74, 0x40, 0xf0, 0x22, 0x75, 0x2c, 0x01,
+ 0x12, 0x10, 0xf8, 0x31, 0x9a, 0xf0, 0x31, 0x26, 0xa3, 0x74, 0x09, 0xf0, 0x90, 0xfc, 0x00, 0x74,
+ 0x55, 0xf0, 0xa3, 0x74, 0xaa, 0x12, 0x10, 0xd6, 0xa3, 0xf0, 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x08,
+ 0x12, 0x3f, 0xeb, 0xb4, 0xaa, 0x0a, 0xa3, 0xe0, 0xb4, 0x55, 0x05, 0x75, 0x2c, 0x02, 0x80, 0x2b,
+ 0x90, 0xe2, 0x1f, 0x74, 0x05, 0xf0, 0x12, 0x10, 0xf8, 0x31, 0x9a, 0xf0, 0x90, 0xfc, 0x00, 0x74,
+ 0x5a, 0xf0, 0xe4, 0x12, 0x10, 0xdc, 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x04, 0x12, 0x3f, 0xeb, 0x64,
+ 0xa5, 0x60, 0x08, 0x90, 0xe2, 0x1f, 0x74, 0x01, 0xf0, 0x80, 0x0c, 0x75, 0x55, 0x03, 0x75, 0x56,
+ 0xb7, 0x85, 0x2c, 0x57, 0x12, 0x27, 0x8b, 0x02, 0x3f, 0xe4, 0x90, 0xe6, 0x15, 0x74, 0x22, 0xf0,
+ 0xe4, 0x90, 0xe6, 0x1b, 0x22, 0x7f, 0x02, 0xe4, 0xfe, 0xee, 0x51, 0x11, 0x8c, 0x83, 0xe0, 0xfd,
+ 0x20, 0xe6, 0x4a, 0x51, 0x06, 0xf5, 0x83, 0xe4, 0x93, 0xfa, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8a,
+ 0x83, 0xe4, 0xf0, 0x90, 0xe3, 0x04, 0xef, 0xf0, 0x00, 0x00, 0x00, 0x44, 0x80, 0xfc, 0x90, 0xe3,
+ 0x49, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x53, 0x05, 0x03, 0xee, 0x60, 0x03, 0xbe, 0x02, 0x15, 0xed,
+ 0x70, 0x07, 0x90, 0xe3, 0x49, 0xec, 0xf0, 0x7d, 0x03, 0xbd, 0x03, 0x08, 0x90, 0xe3, 0x49, 0xec,
+ 0xf0, 0x00, 0x00, 0x00, 0x51, 0x06, 0x51, 0x1a, 0x8c, 0x83, 0x74, 0x11, 0xf0, 0x0f, 0x0f, 0x0e,
+ 0xee, 0x64, 0x04, 0x70, 0xa4, 0x22, 0xee, 0x25, 0xe0, 0x24, 0xd1, 0xf5, 0x82, 0xe4, 0x34, 0x0e,
+ 0x22, 0x25, 0xe0, 0x24, 0xd9, 0xf5, 0x82, 0xe4, 0x34, 0x0e, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74,
+ 0x01, 0x93, 0xf5, 0x82, 0x22, 0xe4, 0xff, 0x7e, 0x02, 0xef, 0xc3, 0x94, 0x04, 0x50, 0x32, 0xef,
+ 0x51, 0x11, 0x8c, 0x83, 0xe0, 0x30, 0xe6, 0x24, 0xef, 0x51, 0x07, 0xf5, 0x83, 0xe4, 0x93, 0xfc,
+ 0x74, 0x01, 0x93, 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04,
+ 0xee, 0xf0, 0x00, 0x00, 0x00, 0x8d, 0x82, 0x8c, 0x83, 0x74, 0x05, 0xf0, 0x0f, 0x0e, 0x0e, 0x80,
+ 0xc8, 0x22, 0xac, 0x07, 0x12, 0x36, 0x44, 0xbf, 0x02, 0x03, 0x7f, 0x84, 0x22, 0xec, 0x04, 0xff,
+ 0xed, 0x60, 0x05, 0xef, 0x42, 0x60, 0x80, 0x04, 0xef, 0xf4, 0x52, 0x60, 0x7f, 0x00, 0x22, 0x90,
+ 0x00, 0xfb, 0x74, 0x04, 0xf0, 0xe4, 0xf5, 0x8d, 0xf5, 0x8b, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x10,
+ 0xf5, 0x89, 0xd2, 0x8e, 0xd2, 0xab, 0x22, 0xe4, 0x90, 0x00, 0xfb, 0xf0, 0xc2, 0xab, 0xc2, 0x8e,
+ 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x30, 0xf5, 0x89, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x30,
+ 0x25, 0x0a, 0xc2, 0x25, 0x90, 0x00, 0xfb, 0x74, 0x04, 0xf0, 0x80, 0x0d, 0x90, 0x00, 0xfb, 0xe0,
+ 0x60, 0x07, 0x14, 0xf0, 0xe0, 0x70, 0x02, 0xd2, 0x1f, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32,
+ 0x12, 0x16, 0x03, 0xe4, 0x90, 0xe6, 0x1a, 0xf0, 0x12, 0x16, 0x03, 0x90, 0xe6, 0x04, 0x74, 0x06,
+ 0xf0, 0x22, 0x90, 0x00, 0xdb, 0xe0, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xd3, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0x22, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4f, 0xf0, 0x02, 0x16, 0x03, 0x90, 0xe6,
+ 0x15, 0x74, 0x62, 0xf0, 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xf0, 0x22, 0xe0, 0x54, 0x30, 0xff, 0x90,
+ 0x04, 0x2a, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x02, 0x3f, 0xd8, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xce,
+ 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcd, 0xf5, 0x82,
+ 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcc, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0x22, 0x85, 0x2d, 0x82, 0x85, 0x2c, 0x83, 0xe0, 0xf2, 0x05, 0x2d, 0xe5, 0x2d,
+ 0x22, 0x90, 0xe2, 0x31, 0x74, 0x08, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x22, 0x90, 0x04, 0x2a, 0x74,
+ 0xff, 0xf5, 0xf0, 0x02, 0x0b, 0xb0, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0x03, 0x22, 0x90, 0xe6, 0x7c,
+ 0xe0, 0x90, 0xe6, 0x7b, 0xf0, 0x22, 0x7a, 0xfc, 0x79, 0x00, 0x7e, 0xfc, 0x74, 0xfc, 0x22, 0x8f,
+ 0x34, 0x8b, 0x35, 0x8a, 0x36, 0x89, 0x37, 0x22, 0x7b, 0x01, 0x7a, 0x00, 0x79, 0x8a, 0xaf, 0x29,
+ 0x22, 0xf5, 0x9a, 0x74, 0x00, 0xf5, 0x9b, 0xe4, 0x22, 0x90, 0x00, 0x8d, 0xe0, 0xfd, 0xaf, 0x29,
+ 0x22, 0x00
+ }
+} ;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastfw_sd_mmc_rel_nopport_Ast121_68.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1101 @@
+#define CYANFW_SIZE 17488
+union {
+ uint8_t fw_image[CYANFW_SIZE] ;
+ uint16_t dummy_for_word_alignment ;
+} CyAnFirmware = {
+ {
+ 0x02, 0x11, 0x54, 0x02, 0x3e, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x3e, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x43, 0x30, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x37, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3d, 0x81, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xe7, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x46, 0xe7, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x3e,
+ 0x88, 0x82, 0x8c, 0x83, 0xe7, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x32, 0xe3, 0x09, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x78, 0xe3, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x70, 0x88, 0x82, 0x8c, 0x83,
+ 0xe3, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x64, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x58, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x4c,
+ 0x80, 0xd2, 0x80, 0xfa, 0x80, 0xc6, 0x80, 0xd4, 0x80, 0x69, 0x80, 0xf2, 0x80, 0x33, 0x80, 0x10,
+ 0x80, 0xa6, 0x80, 0xea, 0x80, 0x9a, 0x80, 0xa8, 0x80, 0xda, 0x80, 0xe2, 0x80, 0xca, 0x80, 0x33,
+ 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83,
+ 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xe9, 0xde, 0xe7, 0x80,
+ 0x0d, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf6, 0x08, 0xdf, 0xf9, 0xec, 0xfa, 0xa9, 0xf0,
+ 0xed, 0xfb, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc,
+ 0xc5, 0x83, 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xea, 0xde,
+ 0xe8, 0x80, 0xdb, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf2, 0x08, 0xdf, 0xf9, 0x80, 0xcc,
+ 0x88, 0xf0, 0xef, 0x60, 0x01, 0x0e, 0x4e, 0x60, 0xc3, 0x88, 0xf0, 0xed, 0x24, 0x02, 0xb4, 0x04,
+ 0x00, 0x50, 0xb9, 0xf5, 0x82, 0xeb, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xaf, 0x23, 0x23, 0x45,
+ 0x82, 0x23, 0x90, 0x0a, 0x90, 0x73, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0x22, 0x50,
+ 0x02, 0xe7, 0x22, 0xbb, 0xfe, 0x02, 0xe3, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0x22, 0xbb,
+ 0x01, 0x0c, 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe0, 0x22, 0x50, 0x06,
+ 0xe9, 0x25, 0x82, 0xf8, 0xe6, 0x22, 0xbb, 0xfe, 0x06, 0xe9, 0x25, 0x82, 0xf8, 0xe2, 0x22, 0xe5,
+ 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe4, 0x93, 0x22, 0xf8, 0xbb, 0x01, 0x0d,
+ 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe8, 0xf0, 0x22, 0x50, 0x06, 0xe9,
+ 0x25, 0x82, 0xc8, 0xf6, 0x22, 0xbb, 0xfe, 0x05, 0xe9, 0x25, 0x82, 0xc8, 0xf2, 0x22, 0xef, 0x8d,
+ 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, 0x2e, 0xfe, 0x22,
+ 0xc5, 0xf0, 0xf8, 0xa3, 0xe0, 0x28, 0xf0, 0xc5, 0xf0, 0xf8, 0xe5, 0x82, 0x15, 0x82, 0x70, 0x02,
+ 0x15, 0x83, 0xe0, 0x38, 0xf0, 0x22, 0xef, 0x2b, 0xff, 0xee, 0x3a, 0xfe, 0xed, 0x39, 0xfd, 0xec,
+ 0x38, 0xfc, 0x22, 0xc3, 0xef, 0x9b, 0xff, 0xee, 0x9a, 0xfe, 0xed, 0x99, 0xfd, 0xec, 0x98, 0xfc,
+ 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, 0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c,
+ 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, 0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0,
+ 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, 0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc,
+ 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, 0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd,
+ 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, 0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22,
+ 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, 0xf0, 0xe8, 0x9c, 0x45, 0xf0,
+ 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, 0xee, 0x13, 0xfe, 0xef, 0x13,
+ 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33,
+ 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xa1, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x51, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x5d,
+ 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x69, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xd9, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xa3, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xaf,
+ 0x22, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x22, 0xe0, 0xf8, 0xa3,
+ 0xe0, 0xf9, 0xa3, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83,
+ 0x02, 0x0c, 0xad, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x79, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02,
+ 0x0d, 0x86, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x93, 0xec, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xa8, 0x82, 0x85, 0x83, 0xf0, 0xd0, 0x83, 0xd0, 0x82, 0x12, 0x0c,
+ 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0xe4, 0x73, 0xe4, 0x93, 0xa3, 0xc5,
+ 0x83, 0xc5, 0xf0, 0xc5, 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0xf0, 0xa3, 0xc5, 0x83, 0xc5, 0xf0, 0xc5,
+ 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5,
+ 0x83, 0x22, 0xeb, 0xf0, 0xa3, 0xea, 0xf0, 0xa3, 0xe9, 0xf0, 0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8,
+ 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, 0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93,
+ 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, 0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80,
+ 0xdf, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x08, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe2, 0xfc, 0x08,
+ 0xe2, 0xfd, 0x08, 0xe2, 0xfe, 0x08, 0xe2, 0xff, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd,
+ 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, 0xf9, 0x08, 0xe6,
+ 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xe2, 0xfb, 0x08, 0xe2, 0xf9, 0x08, 0xe2, 0xfa, 0x08, 0xe2,
+ 0xcb, 0xf8, 0x22, 0xe4, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf9, 0x74, 0x02, 0x93, 0xfa, 0x74, 0x03,
+ 0x93, 0xfb, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, 0xf6, 0x08, 0xef, 0xf6, 0x22, 0xec,
+ 0xf2, 0x08, 0xed, 0xf2, 0x08, 0xee, 0xf2, 0x08, 0xef, 0xf2, 0x22, 0xc1, 0x23, 0x41, 0x00, 0x60,
+ 0x00, 0x41, 0x00, 0x61, 0x00, 0x42, 0x00, 0xa9, 0x00, 0x40, 0x41, 0x00, 0xab, 0x00, 0x41, 0x00,
+ 0xac, 0x7c, 0x01, 0x4f, 0x00, 0x41, 0x00, 0xae, 0x00, 0xc1, 0x21, 0x02, 0x50, 0x00, 0x00, 0x41,
+ 0x00, 0xaf, 0x00, 0x42, 0x00, 0xb1, 0x00, 0x00, 0xc1, 0x22, 0x02, 0x52, 0x00, 0xb3, 0x41, 0x00,
+ 0xb0, 0x00, 0xc1, 0x24, 0x41, 0x00, 0xad, 0x00, 0x44, 0x04, 0x96, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x04, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x04, 0x87, 0x03, 0x90, 0x4a, 0x04, 0x89, 0x03,
+ 0x40, 0x03, 0x48, 0x03, 0x50, 0x03, 0x90, 0x00, 0x00, 0x48, 0x04, 0x6c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x83, 0x00, 0x41, 0x04, 0x84, 0x00, 0x41, 0x04, 0x85, 0x00,
+ 0x41, 0x04, 0x86, 0x00, 0x02, 0x20, 0x00, 0x00, 0x41, 0x00, 0xff, 0x00, 0xc1, 0x26, 0xc1, 0x28,
+ 0x41, 0x04, 0x30, 0x16, 0x41, 0x04, 0x31, 0x07, 0x01, 0x14, 0x01, 0x01, 0x15, 0x02, 0x02, 0x16,
+ 0x00, 0xc5, 0x41, 0x04, 0x9f, 0x00, 0x41, 0x04, 0xa0, 0x00, 0x41, 0x04, 0xa1, 0x00, 0x41, 0x04,
+ 0xa4, 0x01, 0x42, 0x00, 0xb7, 0x00, 0x00, 0x41, 0x00, 0xfb, 0x00, 0xc1, 0x1e, 0x00, 0x74, 0x00,
+ 0xf5, 0x86, 0x90, 0xfd, 0xa5, 0x7c, 0x05, 0xa3, 0xe5, 0x82, 0x45, 0x83, 0x70, 0xf9, 0x22, 0x74,
+ 0x00, 0xf5, 0x86, 0x90, 0xff, 0xe1, 0x02, 0x0e, 0x87, 0x74, 0x00, 0xf5, 0x86, 0x90, 0xff, 0x41,
+ 0x02, 0x0e, 0x87, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x61, 0xa8, 0x61, 0xe5, 0x9a, 0xf6, 0x15, 0x61,
+ 0xa8, 0x61, 0xe5, 0x9b, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x61,
+ 0xa8, 0x61, 0xe5, 0x9d, 0xf6, 0x15, 0x61, 0xa8, 0x61, 0xe5, 0x9e, 0xf6, 0xd0, 0xe0, 0xd0, 0x00,
+ 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0xa8, 0x61, 0xe6, 0xf5, 0x9b, 0x05, 0x61, 0xa8, 0x61, 0xe6, 0xf5,
+ 0x9a, 0x05, 0x61, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0xa8, 0x61, 0xe6, 0xf5,
+ 0x9e, 0x05, 0x61, 0xa8, 0x61, 0xe6, 0xf5, 0x9d, 0x05, 0x61, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0x22,
+ 0x02, 0x37, 0xff, 0x00, 0x02, 0x38, 0xd1, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xfe, 0x00,
+ 0x02, 0x21, 0x2a, 0x00, 0x02, 0x38, 0x43, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x38, 0xce, 0x00, 0x02, 0x39, 0x3c, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x39, 0xbe, 0x00,
+ 0x02, 0x3a, 0x8d, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00, 0x02, 0x38, 0xcb, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00,
+ 0x02, 0x10, 0xff, 0x00, 0x02, 0x10, 0xff, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x08, 0x03, 0x05, 0x24,
+ 0x00, 0x02, 0x3a, 0x00, 0x03, 0x03, 0x00, 0x03, 0x11, 0x0c, 0x03, 0x12, 0x00, 0x05, 0x20, 0x00,
+ 0x05, 0x21, 0x00, 0x05, 0x26, 0x00, 0x06, 0x28, 0x00, 0x05, 0x04, 0x02, 0x02, 0x53, 0x02, 0x07,
+ 0x27, 0x00, 0x05, 0x39, 0x00, 0xff, 0xff, 0xff, 0xe3, 0x18, 0xe3, 0x19, 0xe3, 0x1a, 0xe3, 0x1b,
+ 0xe3, 0x12, 0xe3, 0x13, 0xe3, 0x14, 0xe3, 0x15, 0x90, 0xe6, 0x04, 0x74, 0x80, 0xf0, 0x22, 0x22,
+ 0x00, 0x00, 0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0xb4, 0x04, 0x17, 0x47, 0x02, 0x00,
+ 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00,
+ 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00, 0x00, 0x02,
+ 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x00, 0x02, 0x00, 0x07, 0x05, 0x86, 0x02, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00,
+ 0x00, 0x02, 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x07, 0x05, 0x86,
+ 0x02, 0x40, 0x00, 0x00, 0x04, 0x03, 0x09, 0x04, 0x1a, 0x03, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00,
+ 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x30, 0x00,
+ 0x31, 0x00, 0x10, 0x03, 0x43, 0x00, 0x79, 0x00, 0x70, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00,
+ 0x73, 0x00, 0x18, 0x03, 0x57, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x42, 0x00,
+ 0x72, 0x00, 0x69, 0x00, 0x64, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xe3, 0x4a, 0x00, 0x00, 0xe3, 0x4b, 0x00, 0x00, 0xe3, 0x4c, 0x00, 0x00,
+ 0xe3, 0x4d, 0xe3, 0x4e, 0xe3, 0x4f, 0xe3, 0x38, 0xe3, 0x39, 0xe3, 0x3a, 0xe3, 0x3b, 0x11, 0xdb,
+ 0x78, 0x80, 0xe2, 0x44, 0x04, 0xf2, 0xe2, 0x54, 0xf7, 0xf2, 0x22, 0x78, 0x80, 0xe2, 0x44, 0x0a,
+ 0xf2, 0x7f, 0x64, 0x7e, 0x00, 0x12, 0x1e, 0xe4, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x90, 0xe3, 0x5f,
+ 0xf0, 0x78, 0x5f, 0xf2, 0x53, 0x91, 0xef, 0x22, 0x7f, 0x10, 0x12, 0x1e, 0x3d, 0xef, 0x22, 0x32,
+ 0x01, 0x00, 0x00, 0x24, 0x00, 0x80, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72,
+ 0x65, 0x73, 0x73, 0x00, 0x41, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x4e, 0x41, 0x4e, 0x44,
+ 0x20, 0x20, 0x20, 0x00, 0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x80,
+ 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x41, 0x73,
+ 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x53, 0x44, 0x20, 0x43, 0x61, 0x72, 0x64, 0x00, 0x30, 0x30,
+ 0x30, 0x31, 0x00, 0x00, 0x78, 0x7f, 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x92, 0xe6, 0x75, 0x81, 0x61,
+ 0x02, 0x11, 0x9e, 0x02, 0x28, 0x0d, 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0x40, 0x03, 0xf6,
+ 0x80, 0x01, 0xf2, 0x08, 0xdf, 0xf4, 0x80, 0x29, 0xe4, 0x93, 0xa3, 0xf8, 0x54, 0x07, 0x24, 0x0c,
+ 0xc8, 0xc3, 0x33, 0xc4, 0x54, 0x0f, 0x44, 0x20, 0xc8, 0x83, 0x40, 0x04, 0xf4, 0x56, 0x80, 0x01,
+ 0x46, 0xf6, 0xdf, 0xe4, 0x80, 0x0b, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x90, 0x0d,
+ 0xbb, 0xe4, 0x7e, 0x01, 0x93, 0x60, 0xbc, 0xa3, 0xff, 0x54, 0x3f, 0x30, 0xe5, 0x09, 0x54, 0x1f,
+ 0xfe, 0xe4, 0x93, 0xa3, 0x60, 0x01, 0x0e, 0xcf, 0x54, 0xc0, 0x25, 0xe0, 0x60, 0xa8, 0x40, 0xb8,
+ 0xe4, 0x93, 0xa3, 0xfa, 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xca,
+ 0xc5, 0x83, 0xca, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xdf, 0xe9, 0xde,
+ 0xe7, 0x80, 0xbe, 0xe4, 0xf5, 0x27, 0xef, 0x70, 0x11, 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40, 0x4f,
+ 0x11, 0xdb, 0x75, 0x4f, 0x03, 0x12, 0x44, 0x47, 0x80, 0x45, 0xe5, 0x4f, 0x24, 0xfd, 0x60, 0x0c,
+ 0x24, 0xfe, 0x60, 0x03, 0x04, 0x70, 0x35, 0x75, 0x27, 0x10, 0x80, 0x33, 0x90, 0xe2, 0xa6, 0x74,
+ 0x30, 0xf0, 0x74, 0x10, 0x12, 0x37, 0xf2, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x53, 0x91, 0xef, 0x78,
+ 0x5c, 0x74, 0x3b, 0xf2, 0x11, 0xce, 0x75, 0x4f, 0x04, 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x02, 0x71,
+ 0xa0, 0x7f, 0x02, 0x51, 0x78, 0x78, 0x5e, 0x74, 0x1b, 0xf2, 0x80, 0x03, 0x75, 0x27, 0x1b, 0xaf,
+ 0x27, 0x22, 0xe4, 0xfe, 0x7d, 0x02, 0xef, 0x5d, 0x90, 0x00, 0xb9, 0xf0, 0x90, 0xe6, 0x12, 0x70,
+ 0x0b, 0x74, 0x22, 0xf0, 0x90, 0xe6, 0x14, 0x74, 0x62, 0xf0, 0x80, 0x09, 0x74, 0xa2, 0xf0, 0x90,
+ 0xe6, 0x14, 0x74, 0xe2, 0xf0, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe1, 0x01, 0x0e, 0x30, 0x19, 0x04,
+ 0x30, 0x1a, 0x01, 0x0e, 0xee, 0x14, 0xff, 0x22, 0xef, 0x44, 0x80, 0xfe, 0x12, 0x0f, 0xf8, 0x00,
+ 0xef, 0xf0, 0x00, 0xe4, 0xf0, 0x00, 0x90, 0xe6, 0x49, 0xee, 0xf0, 0x00, 0xf0, 0x30, 0x1d, 0x04,
+ 0x00, 0xf0, 0x00, 0xf0, 0x22, 0x8f, 0x27, 0x90, 0x00, 0xe3, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xc8,
+ 0xe0, 0xf4, 0x55, 0x27, 0x70, 0x03, 0x7f, 0x10, 0x22, 0x7f, 0x01, 0x12, 0x41, 0x44, 0xe5, 0x27,
+ 0x54, 0x1e, 0x60, 0x0e, 0x12, 0x0f, 0xf8, 0x12, 0x0e, 0x99, 0xaf, 0x27, 0x12, 0x1f, 0x7f, 0x12,
+ 0x44, 0x02, 0x20, 0x1d, 0x04, 0x7f, 0x04, 0x51, 0x78, 0x12, 0x0f, 0xf8, 0x00, 0x74, 0x06, 0xf0,
+ 0x00, 0x74, 0x08, 0xf0, 0x00, 0xe4, 0xf0, 0x71, 0xa0, 0x7f, 0x00, 0x22, 0x8d, 0x27, 0xac, 0x03,
+ 0xe4, 0xfe, 0x51, 0x42, 0xae, 0x07, 0x90, 0x00, 0xb9, 0xe0, 0x90, 0x00, 0xac, 0x60, 0x1e, 0xe0,
+ 0x44, 0x80, 0xff, 0xf0, 0xec, 0x54, 0x1f, 0x25, 0xe0, 0x25, 0xe0, 0xfd, 0xef, 0x54, 0x83, 0x4d,
+ 0xff, 0xf0, 0xee, 0x54, 0x03, 0xfe, 0xef, 0x54, 0xfc, 0x4e, 0xf0, 0x80, 0x03, 0x74, 0x7c, 0xf0,
+ 0x90, 0x00, 0x74, 0x71, 0x96, 0x89, 0x82, 0xf5, 0x83, 0xec, 0xf0, 0x90, 0x00, 0x76, 0x71, 0x96,
+ 0xf5, 0x83, 0x89, 0x82, 0xec, 0xf0, 0xe5, 0x27, 0x70, 0x0b, 0x75, 0x4f, 0x03, 0x90, 0x00, 0xae,
+ 0x74, 0x02, 0xf0, 0x80, 0x0b, 0x75, 0x4f, 0x03, 0x90, 0x00, 0xae, 0x74, 0x01, 0x12, 0x38, 0xde,
+ 0x7f, 0x00, 0x22, 0xe4, 0xf5, 0x26, 0x90, 0xe2, 0x77, 0xf0, 0x90, 0xe2, 0x76, 0xf0, 0x7f, 0xff,
+ 0x51, 0x95, 0x43, 0x26, 0x02, 0x7d, 0x01, 0x7f, 0x02, 0x12, 0x35, 0x41, 0x12, 0x1f, 0xff, 0xe4,
+ 0xfb, 0x7d, 0x01, 0xaf, 0x26, 0x51, 0xdc, 0xe4, 0x90, 0xe6, 0x10, 0xf0, 0x00, 0xa3, 0xf0, 0x00,
+ 0x90, 0xe3, 0x4a, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0,
+ 0x00, 0xa3, 0xf0, 0x00, 0x90, 0xe3, 0x38, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3,
+ 0xf0, 0x00, 0x7f, 0x01, 0x21, 0xe3, 0xe0, 0xfe, 0xa3, 0xe0, 0x24, 0x02, 0xf9, 0xe4, 0x3e, 0x22,
+ 0x90, 0x00, 0xe1, 0x74, 0x02, 0xf0, 0x7a, 0xf8, 0x12, 0x41, 0x36, 0x74, 0x26, 0xf0, 0x90, 0x00,
+ 0xdd, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe2, 0x42, 0xe0, 0x54, 0xfe, 0xf0, 0xe4, 0x90, 0xe2, 0x41,
+ 0xf0, 0x22, 0x12, 0x44, 0x2c, 0xe4, 0xf5, 0x54, 0x12, 0x35, 0x06, 0xef, 0x60, 0x05, 0x75, 0x54,
+ 0x0c, 0x81, 0xdb, 0x12, 0x2d, 0xa3, 0x12, 0x32, 0x80, 0x12, 0x37, 0xc5, 0x4e, 0x70, 0x02, 0x81,
+ 0xdb, 0x12, 0x42, 0x14, 0xe5, 0x34, 0x60, 0x06, 0x20, 0x24, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92,
+ 0x15, 0xe4, 0x30, 0x15, 0x0d, 0x12, 0x3f, 0x8f, 0x90, 0xe2, 0x34, 0xf1, 0x06, 0x12, 0x3b, 0x1b,
+ 0x80, 0x0a, 0x12, 0x3f, 0x80, 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x80, 0xf0, 0xb1, 0x05, 0x12, 0x2d,
+ 0xa3, 0x12, 0x2e, 0x25, 0x30, 0x15, 0x74, 0xf1, 0x09, 0x12, 0x3f, 0x9b, 0x90, 0x04, 0x2a, 0xe0,
+ 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x02, 0x81, 0xac, 0xe5, 0x54, 0x60, 0x02, 0x81, 0xac, 0x12, 0x43,
+ 0xd9, 0x90, 0xe2, 0x41, 0xe0, 0x70, 0x03, 0x00, 0x80, 0xf7, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x44,
+ 0xb1, 0x20, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x0b, 0xe5, 0x58, 0x24, 0x01, 0xf5, 0x58, 0xe4, 0x35,
+ 0x57, 0x80, 0x09, 0xe4, 0x25, 0x58, 0xf5, 0x58, 0xe5, 0x57, 0x34, 0x02, 0xf5, 0x57, 0xe4, 0x35,
+ 0x56, 0xf5, 0x56, 0xe4, 0x35, 0x55, 0xf5, 0x55, 0x12, 0x43, 0xc0, 0xf1, 0x4d, 0x7f, 0x10, 0x12,
+ 0x1e, 0x3d, 0x71, 0xa0, 0x12, 0x36, 0xf6, 0xef, 0x60, 0x07, 0xe5, 0x54, 0x70, 0x03, 0x75, 0x54,
+ 0x99, 0xf1, 0xec, 0x00, 0xf0, 0x00, 0xf1, 0x09, 0x00, 0x80, 0x91, 0xc2, 0x29, 0x90, 0x00, 0xe2,
+ 0x12, 0x3f, 0xad, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x48, 0xf1, 0x16, 0x7f, 0x10, 0x12, 0x1e, 0x3d,
+ 0x91, 0xfd, 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0, 0xb1, 0x13, 0xf1, 0x4d, 0xc2, 0x29, 0x90, 0xe2,
+ 0x1f, 0xe0, 0x54, 0x7f, 0xf0, 0x00, 0xe4, 0x90, 0xe2, 0x33, 0xf0, 0x00, 0x90, 0xe2, 0x31, 0x74,
+ 0xff, 0xf0, 0x00, 0x90, 0x00, 0xe8, 0xe0, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0x00, 0xe5,
+ 0x54, 0x60, 0x08, 0xb4, 0x99, 0x02, 0xff, 0x22, 0x75, 0x54, 0x37, 0xe5, 0x34, 0x60, 0x1b, 0x85,
+ 0x54, 0x5f, 0xe5, 0x54, 0x60, 0x07, 0xc2, 0x16, 0x12, 0x2b, 0x9d, 0x80, 0x0a, 0x90, 0x04, 0x96,
+ 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x12, 0x2e, 0x1d, 0xaf, 0x54, 0x22, 0x90, 0xe2, 0x00,
+ 0x74, 0x30, 0xf0, 0xb1, 0x13, 0x90, 0xe2, 0x22, 0x74, 0xff, 0xf0, 0xb1, 0x13, 0x90, 0xe2, 0x31,
+ 0x74, 0xff, 0xf0, 0x90, 0x00, 0xe4, 0xe0, 0xff, 0xef, 0x60, 0x04, 0x00, 0x1f, 0x80, 0xf9, 0x22,
+ 0xae, 0x07, 0x12, 0x3f, 0x87, 0x90, 0xe2, 0x1a, 0xed, 0xf0, 0xb1, 0x13, 0xe5, 0x55, 0x54, 0xc0,
+ 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4e, 0x90, 0xe2, 0x00, 0xf0, 0xb1, 0x13, 0xe5, 0x55, 0x25,
+ 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x56, 0x90, 0xe2, 0x01, 0x12, 0x43, 0xb6, 0xe5, 0x56, 0x25, 0xe0,
+ 0x25, 0xe0, 0xff, 0xe5, 0x57, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4f, 0x90, 0xe2, 0x02, 0xf0, 0xb1,
+ 0x13, 0xe5, 0x57, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x58, 0x90, 0xe2, 0x03, 0x12, 0x43, 0xb6,
+ 0xe5, 0x58, 0x25, 0xe0, 0x25, 0xe0, 0x90, 0xe2, 0x04, 0xb1, 0x02, 0xeb, 0x44, 0x01, 0x90, 0xe2,
+ 0x21, 0xf0, 0x80, 0x8f, 0xc2, 0x20, 0xef, 0x60, 0x20, 0x12, 0x0f, 0xf8, 0xf1, 0xdc, 0x30, 0x24,
+ 0x0d, 0xe4, 0x90, 0xe6, 0x1b, 0xf0, 0xd2, 0x20, 0x74, 0xe0, 0xf1, 0xf3, 0xf1, 0x9b, 0xf1, 0x9b,
+ 0x90, 0xe6, 0x1a, 0x74, 0x48, 0xf0, 0x02, 0x36, 0x8e, 0xe4, 0x90, 0xe6, 0x1b, 0xf1, 0x06, 0xb1,
+ 0x13, 0x74, 0x88, 0xf1, 0xa5, 0xf1, 0xec, 0xb1, 0x13, 0x90, 0xe6, 0x1b, 0x74, 0x48, 0xf0, 0x22,
+ 0x75, 0x2c, 0x02, 0x7f, 0x02, 0x12, 0x1b, 0xd1, 0xe5, 0x54, 0x60, 0x02, 0xe1, 0x05, 0xe4, 0x7f,
+ 0x0c, 0xf1, 0x13, 0xef, 0x60, 0x02, 0xe1, 0x05, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0xfc, 0x64, 0x0c,
+ 0x70, 0x33, 0x12, 0x44, 0x18, 0x54, 0x1f, 0x64, 0x02, 0x70, 0x2a, 0x90, 0xe2, 0x08, 0x12, 0x44,
+ 0x22, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x33, 0xf0, 0x90, 0xe2, 0x09, 0x12, 0x44, 0x22,
+ 0xfe, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x34, 0xf0, 0xe0, 0x70, 0x0c, 0x90, 0x04, 0x33,
+ 0xe0, 0x70, 0x06, 0x80, 0xb9, 0x75, 0x54, 0x8b, 0x22, 0x7f, 0x02, 0x12, 0x19, 0x2f, 0xef, 0x60,
+ 0x02, 0xe1, 0x05, 0x12, 0x3e, 0xe1, 0x12, 0x1f, 0xba, 0x60, 0x02, 0xe1, 0x05, 0x90, 0xe2, 0x09,
+ 0xe0, 0x30, 0xe3, 0x08, 0x90, 0x04, 0x3a, 0x74, 0x01, 0xf0, 0xc1, 0xec, 0x12, 0x3f, 0xbb, 0xf1,
+ 0x10, 0xef, 0x60, 0x02, 0xe1, 0x05, 0x12, 0x44, 0x18, 0x54, 0x1f, 0x64, 0x04, 0x60, 0x04, 0x75,
+ 0x54, 0x8a, 0x22, 0x7d, 0x08, 0x12, 0x43, 0xaa, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0xcc, 0xf1, 0x16,
+ 0xef, 0x60, 0x02, 0xe1, 0x05, 0x11, 0xf8, 0x60, 0x02, 0xe1, 0x05, 0x90, 0xfc, 0x00, 0xe0, 0x54,
+ 0x0f, 0x90, 0x04, 0x35, 0xf0, 0x90, 0xfc, 0x01, 0xe0, 0x30, 0xe2, 0x19, 0xf1, 0x10, 0xef, 0x60,
+ 0x02, 0xe1, 0x05, 0x12, 0x1c, 0xac, 0x75, 0x58, 0x02, 0xe4, 0xf1, 0x46, 0xef, 0x70, 0x76, 0x90,
+ 0xe2, 0x1f, 0x74, 0x06, 0xf0, 0x12, 0x1b, 0xca, 0x90, 0x04, 0x35, 0xe0, 0xd3, 0x94, 0x00, 0x40,
+ 0x4b, 0xe4, 0xf5, 0x55, 0x75, 0x56, 0xff, 0x75, 0x57, 0xff, 0x75, 0x58, 0xf1, 0x7d, 0x40, 0xff,
+ 0x12, 0x1f, 0x1c, 0xf1, 0x09, 0xe4, 0x90, 0xfc, 0x0d, 0xf0, 0x7b, 0x04, 0xf1, 0x47, 0x11, 0xf8,
+ 0x70, 0x43, 0x90, 0xfc, 0x0d, 0xe0, 0x30, 0xe1, 0x23, 0xf1, 0x09, 0xe4, 0x90, 0xfc, 0x10, 0xf0,
+ 0x75, 0x55, 0x80, 0x7b, 0x04, 0xf1, 0x47, 0x11, 0xf8, 0x70, 0x2a, 0x90, 0xfc, 0x10, 0xe0, 0x54,
+ 0x0f, 0x64, 0x01, 0x60, 0x04, 0x75, 0x54, 0x83, 0x22, 0x12, 0x3e, 0xf2, 0x90, 0x04, 0x37, 0x74,
+ 0x02, 0xf0, 0x90, 0x00, 0xea, 0xe0, 0x60, 0x0d, 0xe5, 0xa0, 0x55, 0x2c, 0x60, 0x07, 0x90, 0x04,
+ 0x32, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0xf0, 0xb1, 0x13, 0x90, 0xe6, 0x04, 0x74, 0x08, 0xf0, 0x22,
+ 0xe4, 0x7f, 0xdc, 0xfb, 0x7d, 0x26, 0xb1, 0x20, 0x80, 0x33, 0x12, 0x32, 0x91, 0xc2, 0x2a, 0x91,
+ 0xfd, 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0, 0x12, 0x1c, 0xac, 0x12, 0x34, 0x25, 0xf1, 0x4d, 0xef,
+ 0x60, 0x03, 0xaf, 0x54, 0x22, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x34, 0xf1, 0x16, 0xef, 0x60, 0x02,
+ 0xaf, 0x54, 0x22, 0xe4, 0xf5, 0x58, 0xfb, 0x7f, 0x18, 0x7d, 0x26, 0xb1, 0x20, 0x74, 0xff, 0xf5,
+ 0x3a, 0xf5, 0x3b, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x66, 0x70, 0x11, 0x12, 0x0e, 0x8f, 0xe5, 0x3b,
+ 0x15, 0x3b, 0x70, 0x02, 0x15, 0x3a, 0xe5, 0x3b, 0x45, 0x3a, 0x70, 0xe7, 0xe5, 0x54, 0x70, 0x28,
+ 0x90, 0xe2, 0x22, 0xe0, 0x20, 0xe1, 0x0d, 0x75, 0x54, 0x89, 0x12, 0x2b, 0x8f, 0x74, 0x03, 0xf0,
+ 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04, 0x37, 0xe0, 0x60, 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60,
+ 0x60, 0x06, 0x12, 0x2b, 0x8c, 0x74, 0x01, 0xf0, 0xaf, 0x54, 0x22, 0x90, 0xe6, 0x48, 0x74, 0x86,
+ 0xf0, 0xb1, 0x13, 0x74, 0x86, 0x90, 0xe6, 0x48, 0xf0, 0xa1, 0x13, 0x12, 0x2f, 0xa6, 0x12, 0x0f,
+ 0xf8, 0xf1, 0xdc, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0,
+ 0xb1, 0x13, 0x74, 0xe2, 0xf1, 0xf3, 0x12, 0x36, 0x9e, 0xb1, 0x13, 0x90, 0xe6, 0x15, 0x74, 0x62,
+ 0xf0, 0xb1, 0x13, 0x12, 0x3b, 0x21, 0x12, 0x36, 0x8e, 0xc2, 0x20, 0x22, 0xb1, 0x13, 0xe4, 0x90,
+ 0xe6, 0x1a, 0xf0, 0xb1, 0x13, 0x90, 0xe6, 0x04, 0x74, 0x06, 0xf0, 0x22, 0x90, 0xe6, 0x48, 0x74,
+ 0x88, 0xf0, 0x22, 0x90, 0xe6, 0x14, 0xf0, 0xa1, 0x13, 0x12, 0x3f, 0x98, 0x78, 0x04, 0x74, 0x08,
+ 0xf2, 0x78, 0x15, 0x74, 0x62, 0xf2, 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x22, 0x90, 0x00, 0x66, 0x74,
+ 0x10, 0xf0, 0xa3, 0x74, 0x22, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x44, 0xf0, 0xa3, 0x74,
+ 0x10, 0xf0, 0xa3, 0x74, 0x64, 0xf0, 0x90, 0x00, 0x74, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x2b, 0xf0,
+ 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x4d, 0x12, 0x38, 0xde, 0x74, 0x00, 0x24, 0x02, 0xff, 0xe4,
+ 0x90, 0x00, 0x62, 0x11, 0xd1, 0x7c, 0x10, 0x7d, 0x02, 0x7b, 0x12, 0x7a, 0x00, 0x11, 0xee, 0x74,
+ 0x00, 0x24, 0x22, 0xff, 0xe4, 0x90, 0x00, 0x64, 0x11, 0xd1, 0x7c, 0x10, 0x7d, 0x16, 0x7b, 0x0a,
+ 0x7a, 0x00, 0x11, 0xee, 0x7c, 0x01, 0x7d, 0x00, 0xed, 0x24, 0x42, 0xfe, 0xe4, 0x3c, 0x90, 0x00,
+ 0x72, 0xf0, 0xa3, 0xce, 0xf0, 0xed, 0x24, 0xc2, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x70, 0xf0, 0xa3,
+ 0xce, 0xf0, 0x74, 0x00, 0x24, 0x42, 0xfe, 0x74, 0x01, 0x34, 0x01, 0x90, 0x00, 0x78, 0xf0, 0xa3,
+ 0xce, 0xf0, 0x90, 0x00, 0x6a, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xac, 0x06, 0x90, 0x00, 0x99, 0xec,
+ 0x11, 0xc7, 0xfb, 0x7a, 0x00, 0xed, 0x2b, 0x90, 0x00, 0x9b, 0x11, 0xc0, 0x2d, 0x90, 0x00, 0x9d,
+ 0x11, 0xc0, 0x2d, 0xfe, 0xea, 0x3c, 0x90, 0x00, 0x9f, 0xf0, 0xa3, 0xce, 0x11, 0xd9, 0x80, 0x1f,
+ 0xff, 0xea, 0x3c, 0xfe, 0xad, 0x07, 0xfc, 0xf0, 0xa3, 0xed, 0xf0, 0xf5, 0x82, 0x8e, 0x83, 0xe0,
+ 0x22, 0x34, 0x01, 0xfe, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3,
+ 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x22, 0x7b, 0x11, 0x7c, 0xe2, 0x7d, 0x08, 0x7a, 0x00, 0x8e, 0x32,
+ 0x8f, 0x33, 0x8c, 0x34, 0x8d, 0x35, 0x8a, 0x36, 0x8b, 0x37, 0x12, 0x37, 0xce, 0x12, 0x0e, 0xba,
+ 0xe5, 0x32, 0xf5, 0x9a, 0xe5, 0x33, 0xf5, 0x9b, 0xe5, 0x34, 0xf5, 0x9d, 0xe5, 0x35, 0xf5, 0x9e,
+ 0xe5, 0x37, 0x15, 0x37, 0xae, 0x36, 0x70, 0x02, 0x15, 0x36, 0x4e, 0x60, 0x08, 0x78, 0x7c, 0xe2,
+ 0x78, 0x7b, 0xf2, 0x80, 0xeb, 0x12, 0x0e, 0xe8, 0x12, 0x0e, 0xd1, 0x85, 0x5e, 0xe8, 0x22, 0x8f,
+ 0x2d, 0x12, 0x34, 0x25, 0x12, 0x36, 0x97, 0x7d, 0x7e, 0x7f, 0x24, 0x12, 0x17, 0x16, 0xef, 0x60,
+ 0x03, 0x7f, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x5b, 0x11, 0xe6, 0xe5, 0x2d, 0x64, 0x04, 0x60, 0x05,
+ 0xe5, 0x2d, 0xb4, 0x08, 0x0a, 0x90, 0xe2, 0x09, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0x80, 0x03, 0x12,
+ 0x2f, 0xe2, 0x90, 0x04, 0x35, 0xf0, 0xe5, 0x2d, 0xb4, 0x02, 0x21, 0x90, 0x04, 0x35, 0xe0, 0x60,
+ 0x1b, 0x90, 0xe2, 0x10, 0x12, 0x0c, 0xa1, 0xee, 0x54, 0xfc, 0xfe, 0xe4, 0x24, 0x00, 0xff, 0xee,
+ 0x34, 0x04, 0x12, 0x35, 0x3a, 0xfc, 0x90, 0x00, 0xdb, 0xe0, 0x80, 0x70, 0x90, 0xe2, 0x0e, 0xe0,
+ 0x54, 0x3c, 0x13, 0x13, 0x54, 0x3f, 0xfb, 0xa3, 0xe0, 0x54, 0x0f, 0xfe, 0xa3, 0xe0, 0xfd, 0xed,
+ 0xff, 0xe4, 0x8f, 0x31, 0x8e, 0x30, 0xf5, 0x2f, 0xf5, 0x2e, 0x90, 0xe2, 0x12, 0xe0, 0x54, 0x0e,
+ 0xc3, 0x13, 0xfa, 0xe5, 0x31, 0x24, 0x01, 0xf5, 0x31, 0xe4, 0x3e, 0xf5, 0x30, 0xe4, 0x35, 0x2f,
+ 0xf5, 0x2f, 0xe4, 0x35, 0x2e, 0xf5, 0x2e, 0x0a, 0x0a, 0xeb, 0x64, 0x09, 0x60, 0x05, 0xeb, 0x24,
+ 0xf7, 0x2a, 0xfa, 0xaf, 0x31, 0xae, 0x30, 0xad, 0x2f, 0xac, 0x2e, 0xab, 0x02, 0xa8, 0x03, 0x12,
+ 0x0c, 0x54, 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0x51, 0x6e, 0x12, 0x0c, 0xd9, 0x90, 0xe2, 0x1f, 0xe0,
+ 0x54, 0x03, 0xff, 0xbf, 0x01, 0x0b, 0xeb, 0x51, 0x6e, 0x71, 0x4f, 0xeb, 0x51, 0x6e, 0x12, 0x0c,
+ 0xd9, 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0x51, 0x6e, 0x71, 0x4f, 0xeb, 0x51, 0x6e, 0x12, 0x0c, 0xd9,
+ 0x90, 0xe2, 0x17, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0xff, 0x90, 0x04, 0x32, 0xe0, 0x54, 0xfc,
+ 0x4f, 0xf0, 0x90, 0xe2, 0x0f, 0xe0, 0x30, 0xe6, 0x17, 0x91, 0xac, 0x75, 0x55, 0x04, 0x75, 0x56,
+ 0x04, 0xe4, 0xfb, 0xfd, 0x7f, 0x10, 0x12, 0x15, 0x20, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9,
+ 0x7f, 0x00, 0x22, 0x12, 0x0b, 0xe1, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed, 0x34,
+ 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0xe5, 0x0f, 0x2f, 0xf5, 0x0f, 0xe5, 0x0e, 0x3e, 0xf5, 0x0e,
+ 0xe5, 0x0d, 0x3d, 0xf5, 0x0d, 0xe5, 0x0c, 0x3c, 0xf5, 0x0c, 0x90, 0x00, 0xdb, 0xe0, 0x25, 0xe0,
+ 0x25, 0xe0, 0x24, 0xcb, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x74, 0x01, 0x12, 0x3f,
+ 0x79, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x15, 0x20, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0xd1,
+ 0xe0, 0x7f, 0x04, 0x71, 0xd1, 0xe5, 0x54, 0x60, 0x02, 0x61, 0x4e, 0xe4, 0x90, 0x04, 0x33, 0xf0,
+ 0xa3, 0x74, 0x03, 0xf0, 0xe4, 0xf5, 0x55, 0x75, 0x56, 0x03, 0xfb, 0x7d, 0x26, 0x7f, 0x0c, 0x12,
+ 0x17, 0x16, 0xef, 0x60, 0x02, 0x61, 0x4e, 0x7f, 0x04, 0x31, 0x2f, 0xef, 0x60, 0x02, 0x61, 0x4e,
+ 0x12, 0x3e, 0xc6, 0xf1, 0xba, 0x60, 0x02, 0x61, 0x4e, 0x90, 0x04, 0x35, 0xe0, 0xd3, 0x94, 0x03,
+ 0x40, 0x76, 0x71, 0x63, 0x12, 0x17, 0x09, 0xf1, 0x18, 0xf1, 0x06, 0x7f, 0x20, 0x12, 0x17, 0x16,
+ 0xef, 0x70, 0x6b, 0x12, 0x10, 0xf8, 0x70, 0x66, 0x75, 0x55, 0x03, 0x75, 0x56, 0xb9, 0x75, 0x57,
+ 0x01, 0x12, 0x17, 0x43, 0x90, 0xfc, 0xc4, 0xe0, 0xb4, 0x03, 0x05, 0x12, 0x3e, 0xf2, 0x80, 0x03,
+ 0x12, 0x3e, 0xe1, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x39, 0x90, 0xfc, 0xd7, 0xe0, 0xff, 0x90, 0x00,
+ 0xdb, 0xe0, 0xfe, 0x51, 0x6e, 0xef, 0xf0, 0x90, 0xfc, 0xd6, 0xe0, 0xff, 0xee, 0x12, 0x42, 0xcf,
+ 0xef, 0xf0, 0x90, 0xfc, 0xd5, 0xe0, 0xff, 0xee, 0x12, 0x42, 0xc1, 0xef, 0xf0, 0x90, 0xfc, 0xd4,
+ 0xe0, 0xff, 0xee, 0x12, 0x42, 0xb3, 0xef, 0xf0, 0xee, 0x51, 0x6e, 0x71, 0x4f, 0x51, 0x6a, 0x12,
+ 0x0c, 0xd9, 0x12, 0x17, 0xec, 0x12, 0x0e, 0x7e, 0x90, 0x04, 0x37, 0x74, 0x04, 0xf0, 0x22, 0x12,
+ 0x0c, 0xa1, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed, 0x34, 0xff, 0xfd, 0xec, 0x34,
+ 0xff, 0xfc, 0x22, 0x75, 0x2c, 0x01, 0x12, 0x17, 0x09, 0xf1, 0x0d, 0xf0, 0x12, 0x43, 0xaf, 0xa3,
+ 0x74, 0x09, 0xf0, 0x90, 0xfc, 0x00, 0x74, 0x55, 0xf0, 0xa3, 0x74, 0xaa, 0x11, 0xd9, 0xa3, 0xf0,
+ 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x08, 0xd1, 0xc1, 0xb4, 0xaa, 0x0a, 0xa3, 0xe0, 0xb4, 0x55, 0x05,
+ 0x75, 0x2c, 0x02, 0x80, 0x29, 0x90, 0xe2, 0x1f, 0x74, 0x05, 0xf0, 0x12, 0x17, 0x09, 0xf1, 0x0d,
+ 0xf0, 0x90, 0xfc, 0x00, 0x74, 0x5a, 0xf0, 0xe4, 0x11, 0xdf, 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x04,
+ 0xd1, 0xc1, 0x64, 0xa5, 0x60, 0x08, 0x90, 0xe2, 0x1f, 0x74, 0x01, 0xf0, 0x80, 0x0c, 0x75, 0x55,
+ 0x03, 0x75, 0x56, 0xb7, 0x85, 0x2c, 0x57, 0x12, 0x17, 0x43, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0,
+ 0x22, 0x8f, 0x2d, 0xe4, 0xf5, 0x2e, 0x75, 0x2f, 0x3f, 0xf5, 0x54, 0x12, 0x43, 0xaf, 0x91, 0xac,
+ 0xe5, 0x2d, 0xb4, 0x02, 0x0e, 0x30, 0x2b, 0x03, 0x75, 0x55, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f,
+ 0xa4, 0x80, 0x09, 0x75, 0x55, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x04, 0x12, 0x15, 0x20, 0x12,
+ 0x17, 0x4d, 0xef, 0x60, 0x02, 0x81, 0xab, 0xe5, 0x2d, 0xb4, 0x02, 0x09, 0x90, 0xe2, 0x0a, 0xe0,
+ 0x20, 0xe5, 0x0e, 0x80, 0x08, 0x90, 0xe2, 0x0a, 0xe0, 0x64, 0xfe, 0x60, 0x04, 0x75, 0x54, 0x88,
+ 0x22, 0xe5, 0x2e, 0x70, 0x50, 0xe5, 0x2f, 0x60, 0x4c, 0xe5, 0x2d, 0x64, 0x02, 0x70, 0x1b, 0xf5,
+ 0x55, 0xf5, 0x56, 0x12, 0x17, 0x11, 0xef, 0x70, 0x72, 0x30, 0x2b, 0x03, 0x75, 0x55, 0x40, 0x75,
+ 0x56, 0x3c, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xa4, 0x80, 0x0f, 0x75, 0x55, 0x40, 0x75, 0x56, 0xff,
+ 0x75, 0x57, 0x80, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x04, 0x12, 0x15, 0x20, 0x12, 0x17, 0x4d, 0xef,
+ 0x70, 0x49, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0x02, 0xf5, 0x2e, 0x70, 0xb5, 0x7f, 0x64, 0xfe, 0xd1,
+ 0xe4, 0x15, 0x2f, 0x80, 0xac, 0xe5, 0x2e, 0x70, 0x04, 0x75, 0x54, 0x89, 0x22, 0x7e, 0x04, 0x7f,
+ 0x45, 0x7b, 0x05, 0x11, 0xe8, 0x90, 0xe2, 0x08, 0xe0, 0x30, 0xe0, 0x06, 0x90, 0x04, 0x39, 0x74,
+ 0x01, 0xf0, 0x71, 0xca, 0x12, 0x0e, 0x99, 0x91, 0xac, 0xe4, 0xfb, 0x7d, 0x7e, 0x7f, 0x08, 0x12,
+ 0x17, 0x16, 0xef, 0x70, 0x06, 0x7e, 0x04, 0x7f, 0x4a, 0x11, 0xe6, 0x22, 0xe4, 0xf5, 0x55, 0xf5,
+ 0x56, 0xf5, 0x57, 0xf5, 0x58, 0x22, 0x8f, 0x2b, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x54, 0x1e, 0x60,
+ 0x01, 0x22, 0x12, 0x3e, 0x9e, 0xe5, 0x2b, 0x54, 0x1e, 0x70, 0x02, 0xa1, 0x8a, 0x12, 0x3f, 0x09,
+ 0x12, 0x3f, 0x47, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xdc, 0xf0, 0x12, 0x43, 0x98, 0x12,
+ 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0xf5, 0x54, 0x91, 0xac, 0xe4, 0xfb, 0xfd, 0xff, 0x12,
+ 0x15, 0x20, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0xd1, 0xe0, 0x75, 0x57, 0x01, 0x75, 0x58,
+ 0xaa, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x20, 0x12, 0x17, 0x16, 0xe5, 0x54, 0x70, 0x18, 0x90, 0xe2,
+ 0x0b, 0xe0, 0xb4, 0x06, 0x0c, 0xa3, 0xe0, 0x54, 0xfc, 0xff, 0xbf, 0xa8, 0x04, 0xd2, 0x2b, 0x80,
+ 0x05, 0x75, 0x54, 0x9a, 0x80, 0x64, 0xe4, 0xf5, 0x54, 0x91, 0xac, 0x12, 0x17, 0x10, 0xe5, 0x54,
+ 0x70, 0x2c, 0x90, 0xe2, 0x08, 0xe0, 0x64, 0xdc, 0x70, 0x24, 0xe5, 0x2b, 0x30, 0xe1, 0x1f, 0x12,
+ 0x15, 0xc0, 0xd1, 0xcb, 0xe5, 0x54, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44, 0x02, 0xf0, 0x90,
+ 0x00, 0xc7, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x02, 0xf0, 0x80, 0x2c, 0xe5, 0x54,
+ 0x64, 0x89, 0x70, 0x23, 0xe5, 0x2b, 0x30, 0xe2, 0x1e, 0x51, 0x7c, 0xd1, 0xcb, 0xe5, 0x54, 0x70,
+ 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x44, 0x04, 0xf0, 0x90,
+ 0x00, 0xc6, 0x74, 0x04, 0xf0, 0x80, 0x03, 0xe4, 0xf5, 0x54, 0xf1, 0xf8, 0x70, 0x13, 0x90, 0xe6,
+ 0x0d, 0x04, 0xf0, 0x12, 0x0e, 0x7e, 0x90, 0xe6, 0x0e, 0x74, 0x0a, 0xf0, 0x12, 0x0e, 0x7e, 0x80,
+ 0x38, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x17, 0xf9, 0xf1, 0x06, 0x7f, 0x44, 0x12, 0x17, 0x16, 0x12,
+ 0x10, 0xf8, 0x70, 0x24, 0x7f, 0x42, 0x7e, 0x57, 0x7d, 0x59, 0x7c, 0x43, 0x90, 0xfc, 0x00, 0x12,
+ 0x2f, 0xdb, 0x70, 0x14, 0x7e, 0x00, 0x7f, 0xcb, 0x7c, 0xfc, 0x7d, 0x04, 0x7b, 0x10, 0x7a, 0x00,
+ 0x11, 0xee, 0x90, 0x00, 0xdc, 0x74, 0x01, 0xf0, 0x00, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00,
+ 0x3f, 0xff, 0xff, 0x12, 0x17, 0x09, 0x12, 0x3b, 0x1b, 0xc2, 0x07, 0x12, 0x44, 0x0d, 0x60, 0x04,
+ 0x90, 0xe2, 0x34, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x8f, 0x2d, 0xad, 0x2d, 0xe4, 0xff,
+ 0x12, 0x3f, 0x98, 0x91, 0xac, 0xe4, 0xfb, 0x7f, 0x4c, 0x12, 0x17, 0x49, 0xef, 0x70, 0x24, 0x90,
+ 0xe2, 0x21, 0x74, 0x02, 0xf0, 0x7f, 0x80, 0xd1, 0x3d, 0xef, 0x70, 0x17, 0xad, 0x2d, 0xe4, 0xff,
+ 0x12, 0x17, 0xf9, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x38, 0x12, 0x17, 0x16, 0xef, 0x70, 0x04, 0x7f,
+ 0x10, 0xd1, 0x3d, 0x22, 0x90, 0xe2, 0x21, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x80, 0x8f, 0x3a, 0x90,
+ 0x04, 0x41, 0x12, 0x0c, 0xa1, 0x8f, 0x3e, 0x8e, 0x3d, 0x8d, 0x3c, 0x8c, 0x3b, 0xaf, 0x3e, 0xae,
+ 0x3d, 0xad, 0x3c, 0xac, 0x3b, 0xec, 0x4d, 0x4e, 0x4f, 0x60, 0x33, 0x20, 0x29, 0x30, 0x90, 0xe2,
+ 0x31, 0xe0, 0x55, 0x3a, 0x70, 0x28, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x64, 0x70, 0x20, 0x20, 0x1f,
+ 0x1d, 0x12, 0x0e, 0x8f, 0xe5, 0x3e, 0x24, 0xff, 0xf5, 0x3e, 0xe5, 0x3d, 0x34, 0xff, 0xf5, 0x3d,
+ 0xe5, 0x3c, 0x34, 0xff, 0xf5, 0x3c, 0xe5, 0x3b, 0x34, 0xff, 0xf5, 0x3b, 0x80, 0xbf, 0xe5, 0x54,
+ 0x70, 0x2c, 0x90, 0xe2, 0x31, 0xe0, 0x55, 0x3a, 0x70, 0x10, 0x20, 0x29, 0x0d, 0x75, 0x54, 0x89,
+ 0x12, 0x2b, 0x8f, 0x74, 0x03, 0xf0, 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04, 0x37, 0xe0, 0x60, 0x0e,
+ 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60, 0x60, 0x06, 0x12, 0x2b, 0x8c, 0x74, 0x01, 0xf0, 0xaf, 0x54,
+ 0x22, 0xa3, 0xf0, 0xff, 0xb1, 0xfa, 0x90, 0xfc, 0x00, 0xe0, 0x22, 0xe5, 0x54, 0x70, 0x10, 0x91,
+ 0xac, 0x75, 0x57, 0x02, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x40, 0x12, 0x17, 0x16, 0xf1, 0x18, 0x22,
+ 0x7f, 0x05, 0x7e, 0x00, 0x8e, 0x30, 0x8f, 0x31, 0xe5, 0x31, 0x25, 0xe0, 0xf5, 0x31, 0xe5, 0x30,
+ 0x33, 0xf5, 0x30, 0xe5, 0x31, 0x15, 0x31, 0xae, 0x30, 0x70, 0x02, 0x15, 0x30, 0x4e, 0x60, 0x05,
+ 0x12, 0x0e, 0x7e, 0x80, 0xee, 0x22, 0x91, 0xac, 0x7b, 0x04, 0x7d, 0x26, 0x22, 0x90, 0xe6, 0x15,
+ 0x74, 0x22, 0xf0, 0xe4, 0x90, 0xe6, 0x1b, 0x22, 0xe4, 0xfd, 0x7f, 0x02, 0xae, 0x07, 0x90, 0xe2,
+ 0x2c, 0xed, 0xf0, 0x12, 0x15, 0x13, 0x90, 0xe2, 0x2d, 0xee, 0xf0, 0x22, 0xe4, 0xfc, 0x91, 0xac,
+ 0x30, 0x14, 0x05, 0x12, 0x34, 0x25, 0x7c, 0x26, 0xad, 0x04, 0xe4, 0xfb, 0x7f, 0x1c, 0x12, 0x15,
+ 0x20, 0xec, 0x60, 0x03, 0x12, 0x17, 0x4d, 0xaf, 0x54, 0x22, 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0x90,
+ 0x04, 0xa4, 0xe0, 0x60, 0x29, 0x43, 0xb4, 0x40, 0x90, 0x00, 0xe6, 0xe0, 0x60, 0x0e, 0x43, 0xa0,
+ 0x40, 0x7f, 0x96, 0x7e, 0x00, 0xd1, 0xe4, 0x53, 0xa0, 0xbf, 0x80, 0x0c, 0x53, 0xa0, 0xbf, 0x7f,
+ 0x96, 0x7e, 0x00, 0xd1, 0xe4, 0x43, 0xa0, 0x40, 0x7f, 0x96, 0x7e, 0x00, 0xd1, 0xe4, 0x22, 0x8f,
+ 0x2a, 0x7f, 0x03, 0x7e, 0x01, 0xc2, 0xe9, 0x90, 0xe2, 0x75, 0xe0, 0x20, 0xe4, 0xf9, 0x90, 0xe2,
+ 0xa4, 0xe0, 0x5f, 0x6f, 0x60, 0x19, 0x90, 0xe2, 0xa6, 0xef, 0xf0, 0xee, 0x12, 0x37, 0xf2, 0xf1,
+ 0xb2, 0xf1, 0x4a, 0x12, 0x32, 0x99, 0x12, 0x37, 0xb5, 0xaf, 0x2a, 0x91, 0xb6, 0xf1, 0xb2, 0xd2,
+ 0xe9, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x20, 0xf0, 0x22, 0xd2, 0x14, 0xf1, 0x2c, 0xef, 0x22,
+ 0xe4, 0xf5, 0x54, 0xef, 0x30, 0xe0, 0x1c, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x70, 0x26, 0xf1,
+ 0xba, 0x70, 0x22, 0x90, 0x00, 0xc7, 0xe0, 0xff, 0xf1, 0xf8, 0xfe, 0xef, 0x4e, 0x90, 0x00, 0xc7,
+ 0xf0, 0x80, 0x12, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x60, 0x04, 0xc2, 0x14, 0xf1, 0x2c, 0x12,
+ 0x40, 0x72, 0x12, 0x42, 0x14, 0xaf, 0x54, 0x22, 0x90, 0x00, 0xc8, 0xe0, 0x54, 0x1e, 0x22, 0xe4,
+ 0x78, 0x8a, 0xf2, 0x78, 0xb5, 0xf2, 0x12, 0x18, 0x0c, 0x75, 0x4f, 0x01, 0x75, 0x52, 0x00, 0x75,
+ 0x53, 0xb3, 0xe5, 0x53, 0x30, 0xe0, 0x08, 0x05, 0x53, 0xe5, 0x53, 0x70, 0x02, 0x05, 0x52, 0x22,
+ 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40, 0x03, 0x12, 0x10, 0xdb, 0x11, 0x6b, 0x90, 0xe3, 0x12, 0xf0,
+ 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x7f, 0x03, 0x12, 0x43, 0xe7, 0x70, 0x02,
+ 0xe4, 0x93, 0x60, 0x07, 0x51, 0x1c, 0x11, 0xb9, 0xe4, 0xf0, 0x00, 0x0f, 0xbf, 0x10, 0xec, 0x90,
+ 0xe2, 0xeb, 0x74, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xe4, 0xf0, 0x7e, 0xe2, 0x7f, 0x86, 0x7b, 0x1c,
+ 0xfa, 0xfd, 0x12, 0x36, 0x3a, 0x12, 0x44, 0x47, 0xf5, 0x4f, 0x22, 0x11, 0xc2, 0x11, 0x71, 0xe4,
+ 0x22, 0xe4, 0xff, 0x7e, 0x02, 0xef, 0xc3, 0x94, 0x04, 0x50, 0x30, 0xef, 0x11, 0xac, 0xe0, 0x30,
+ 0xe6, 0x24, 0xef, 0x31, 0x20, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd, 0xf5, 0x82,
+ 0x8c, 0x83, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04, 0xee, 0xf0, 0x00, 0x00, 0x00, 0x8d,
+ 0x82, 0x8c, 0x83, 0x74, 0x05, 0xf0, 0x0f, 0x0e, 0x0e, 0x80, 0xca, 0x22, 0x25, 0xe0, 0x24, 0xf0,
+ 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8c,
+ 0x83, 0x22, 0x7f, 0x02, 0xe4, 0xfe, 0xee, 0x11, 0xac, 0xe0, 0xfd, 0x20, 0xe6, 0x48, 0x31, 0x1f,
+ 0xf5, 0x83, 0xe4, 0x93, 0xfa, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8a, 0x83, 0xe4, 0xf0, 0x90, 0xe3,
+ 0x04, 0xef, 0xf0, 0x00, 0x00, 0x00, 0x44, 0x80, 0xfc, 0x90, 0xe3, 0x49, 0xf0, 0x00, 0x00, 0x00,
+ 0xf0, 0x53, 0x05, 0x03, 0xee, 0x60, 0x03, 0xbe, 0x02, 0x15, 0xed, 0x70, 0x07, 0x90, 0xe3, 0x49,
+ 0xec, 0xf0, 0x7d, 0x03, 0xbd, 0x03, 0x08, 0x90, 0xe3, 0x49, 0xec, 0xf0, 0x00, 0x00, 0x00, 0x31,
+ 0x1f, 0x11, 0xb5, 0x74, 0x11, 0xf0, 0x0f, 0x0f, 0x0e, 0xee, 0x64, 0x04, 0x70, 0xa8, 0x22, 0xee,
+ 0x25, 0xe0, 0x24, 0xe8, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0x22, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x12, 0x38, 0x3c, 0x90, 0x00, 0xab, 0xe4, 0xf0, 0x78,
+ 0xa3, 0xf2, 0x78, 0xa5, 0xf2, 0x78, 0x1a, 0x74, 0x40, 0xf2, 0x78, 0x48, 0x74, 0x86, 0xf2, 0x00,
+ 0xf2, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x7f, 0x02, 0x12, 0x12, 0x78, 0x11, 0x6b, 0xff, 0x12,
+ 0x43, 0xe7, 0x70, 0x02, 0xe4, 0x93, 0x60, 0x08, 0x51, 0x1c, 0x11, 0xb9, 0xe0, 0x54, 0xfd, 0xf0,
+ 0x0f, 0xbf, 0x10, 0xeb, 0x90, 0x00, 0xa9, 0xe4, 0xf0, 0xa3, 0x74, 0x40, 0xf0, 0x78, 0x24, 0xe4,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x25, 0x74, 0x40, 0xf2, 0x90, 0x00, 0x60, 0xe4, 0xf0, 0xa3, 0xf0,
+ 0x90, 0x00, 0x68, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee, 0x12, 0x38, 0xd6, 0x90, 0x00, 0x66, 0xe0,
+ 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x00, 0x6e, 0xec, 0xf0, 0xa3, 0xed, 0xf0, 0xa9, 0x07, 0x12, 0x38,
+ 0xbf, 0xaa, 0x04, 0xa9, 0x05, 0x90, 0x00, 0x01, 0x74, 0x07, 0x12, 0x0b, 0x7c, 0x30, 0x22, 0x0b,
+ 0xc2, 0x23, 0x90, 0x04, 0x81, 0xe4, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90, 0x00, 0xad, 0xe4, 0xf0,
+ 0xc2, 0x24, 0xc2, 0x21, 0xc2, 0x22, 0xc2, 0x00, 0x90, 0x04, 0x94, 0xf0, 0x90, 0x04, 0x93, 0xf0,
+ 0xe5, 0x4f, 0xc3, 0x94, 0x04, 0x40, 0x0a, 0xe4, 0xfd, 0x7f, 0x04, 0xd1, 0xc6, 0xd2, 0x28, 0xd2,
+ 0x0d, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xef, 0x75, 0xf0, 0x02,
+ 0x90, 0x10, 0xae, 0x12, 0x0d, 0x16, 0xe4, 0x93, 0x22, 0xef, 0x14, 0x60, 0x15, 0x14, 0x60, 0x1a,
+ 0x24, 0x81, 0x60, 0x12, 0x24, 0xfb, 0x60, 0x16, 0x24, 0x86, 0x70, 0x1c, 0x51, 0x88, 0xe4, 0xf0,
+ 0x80, 0x35, 0x78, 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5,
+ 0xe2, 0x54, 0x01, 0x51, 0x88, 0xf0, 0x80, 0x1f, 0x53, 0x07, 0x0f, 0x51, 0x1c, 0xfc, 0x74, 0x01,
+ 0x93, 0x4c, 0x70, 0x03, 0x7f, 0x15, 0x22, 0x51, 0x1c, 0xd1, 0xb2, 0xe0, 0x7f, 0x00, 0x30, 0xe1,
+ 0x02, 0x7f, 0x01, 0x51, 0x88, 0xef, 0xf0, 0x51, 0x88, 0xa3, 0xe4, 0xf0, 0x74, 0x02, 0xb1, 0xdf,
+ 0xe5, 0x53, 0x78, 0xb4, 0xf2, 0x7f, 0x00, 0x22, 0x85, 0x53, 0x82, 0x85, 0x52, 0x83, 0x22, 0x78,
+ 0xb8, 0xe2, 0xf5, 0x3f, 0x78, 0xb9, 0xe2, 0xf5, 0x40, 0x78, 0xba, 0xe2, 0xf5, 0x41, 0x78, 0xbb,
+ 0xe2, 0xf5, 0x42, 0x78, 0xbc, 0xe2, 0xf5, 0x43, 0xe5, 0x3f, 0x54, 0x03, 0xff, 0xc2, 0x17, 0xc2,
+ 0x18, 0xe5, 0x3f, 0x54, 0x60, 0x90, 0x00, 0xaf, 0xf0, 0xc2, 0x21, 0x64, 0x20, 0x60, 0x05, 0xe0,
+ 0x64, 0x40, 0x70, 0x76, 0x90, 0x00, 0xac, 0xe0, 0x20, 0xe7, 0x02, 0xa1, 0xce, 0x54, 0x7c, 0x13,
+ 0x13, 0x54, 0x3f, 0x65, 0x43, 0x60, 0x02, 0xa1, 0xce, 0xef, 0x64, 0x01, 0x60, 0x02, 0xa1, 0xce,
+ 0xd2, 0x17, 0xe5, 0x40, 0x24, 0x02, 0x60, 0x33, 0x14, 0x60, 0x02, 0xa1, 0xce, 0xe5, 0x3f, 0x64,
+ 0x21, 0x60, 0x02, 0xa1, 0xce, 0xe5, 0x41, 0x60, 0x02, 0xa1, 0xce, 0x78, 0xbe, 0xe2, 0x60, 0x02,
+ 0xa1, 0xce, 0x53, 0x91, 0xef, 0x75, 0xa1, 0x01, 0x90, 0x00, 0xab, 0xf0, 0x7e, 0x00, 0x7f, 0x7a,
+ 0x7b, 0x1f, 0xfa, 0xfd, 0x12, 0x36, 0x3a, 0xc2, 0x00, 0xa1, 0x89, 0xe5, 0x3f, 0x64, 0xa1, 0x60,
+ 0x02, 0xa1, 0xce, 0xe5, 0x41, 0x60, 0x02, 0xa1, 0xce, 0x78, 0xbe, 0xe2, 0x64, 0x01, 0x60, 0x02,
+ 0xa1, 0xce, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0x81, 0xcd, 0x90, 0x00, 0xae, 0xe0, 0x64, 0x02,
+ 0x60, 0x02, 0x81, 0x1c, 0xe5, 0x40, 0xb4, 0x09, 0x05, 0x12, 0x2f, 0xf9, 0x80, 0x14, 0xe5, 0x40,
+ 0x70, 0x10, 0xe5, 0x3f, 0xb4, 0x82, 0x0b, 0xd2, 0x17, 0xaf, 0x43, 0x51, 0x29, 0xef, 0x60, 0x02,
+ 0xa1, 0xce, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02, 0x81, 0x13, 0x90, 0x00, 0xac, 0xe0, 0x30, 0xe7,
+ 0x3b, 0xe5, 0x40, 0x64, 0x06, 0x70, 0x2d, 0xe5, 0x42, 0x64, 0x02, 0x60, 0x06, 0xe5, 0x42, 0x64,
+ 0x07, 0x70, 0x21, 0xd2, 0x21, 0x90, 0x00, 0x76, 0x12, 0x44, 0x3e, 0x30, 0x24, 0x06, 0xe5, 0x42,
+ 0x64, 0x02, 0x60, 0x08, 0x20, 0x24, 0x15, 0xe5, 0x42, 0xb4, 0x07, 0x10, 0x90, 0x00, 0x74, 0x12,
+ 0x44, 0x3e, 0x80, 0x08, 0xe5, 0x40, 0xb4, 0x0b, 0x03, 0x12, 0x43, 0xca, 0xe5, 0x40, 0x64, 0x03,
+ 0x70, 0x32, 0xe5, 0x3f, 0xb4, 0x02, 0x15, 0xe5, 0x41, 0x70, 0x11, 0xe5, 0x43, 0x64, 0x02, 0x60,
+ 0x05, 0xe5, 0x43, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x43, 0xb1, 0xe8, 0xe5, 0x3f, 0x70, 0x14,
+ 0xe5, 0x41, 0xb4, 0x01, 0x08, 0x90, 0x00, 0xb0, 0x74, 0x03, 0xf0, 0x80, 0x07, 0xe5, 0x41, 0xb4,
+ 0x02, 0x02, 0xd2, 0x17, 0xe5, 0x40, 0x64, 0x01, 0x70, 0x29, 0xe5, 0x3f, 0xb4, 0x02, 0x15, 0xe5,
+ 0x41, 0x70, 0x11, 0xe5, 0x43, 0x64, 0x02, 0x60, 0x05, 0xe5, 0x43, 0xb4, 0x86, 0x06, 0xd2, 0x17,
+ 0xaf, 0x43, 0xd1, 0x3c, 0xe5, 0x3f, 0x70, 0x0b, 0xe5, 0x41, 0xb4, 0x01, 0x06, 0x90, 0x00, 0xb0,
+ 0x74, 0x01, 0xf0, 0x30, 0x17, 0x02, 0xa1, 0x89, 0xd2, 0x18, 0xa1, 0x89, 0x90, 0x00, 0xaf, 0xe0,
+ 0x60, 0x02, 0xa1, 0xce, 0xd2, 0x17, 0xe5, 0x40, 0x12, 0x0d, 0x2b, 0x24, 0xfb, 0x00, 0x25, 0x27,
+ 0x01, 0x25, 0x5e, 0x03, 0x24, 0x47, 0x06, 0x24, 0xf0, 0x08, 0x24, 0xdf, 0x09, 0x24, 0xc9, 0x0a,
+ 0x24, 0xd4, 0x0b, 0x00, 0x00, 0x25, 0xce, 0xe5, 0x42, 0x24, 0xfe, 0x60, 0x29, 0x14, 0x60, 0x3d,
+ 0x24, 0xfd, 0x60, 0x13, 0x14, 0x60, 0x2a, 0x24, 0x06, 0x60, 0x02, 0xa1, 0xce, 0x78, 0x8b, 0x74,
+ 0x12, 0xf2, 0x90, 0x00, 0x62, 0x80, 0x08, 0x78, 0x8b, 0x74, 0x0a, 0xf2, 0x90, 0x00, 0x64, 0xe0,
+ 0x78, 0xb3, 0xf2, 0xa3, 0x80, 0x14, 0x90, 0x00, 0x6c, 0x12, 0x43, 0x7d, 0x90, 0x00, 0x6d, 0x80,
+ 0x09, 0x90, 0x00, 0x6e, 0x12, 0x43, 0x7d, 0x90, 0x00, 0x6f, 0xe0, 0xa1, 0x19, 0xe5, 0x41, 0xc3,
+ 0x94, 0x08, 0x50, 0x15, 0xe5, 0x41, 0x25, 0xe0, 0x24, 0x99, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5,
+ 0x83, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x4e, 0x70, 0x06, 0xd2, 0x18, 0xc2, 0x17, 0xa1, 0x89, 0x8e,
+ 0x46, 0x8f, 0x47, 0x8e, 0x48, 0x8f, 0x49, 0x85, 0x49, 0x82, 0x85, 0x48, 0x83, 0xe0, 0x78, 0x8b,
+ 0xf2, 0xe5, 0x46, 0x78, 0xb3, 0xf2, 0xef, 0x80, 0x50, 0x90, 0x00, 0x60, 0xe0, 0xb1, 0xd6, 0xfe,
+ 0xe5, 0x53, 0x80, 0x45, 0x12, 0x43, 0xca, 0x90, 0x00, 0x60, 0xe5, 0x41, 0xf0, 0xa1, 0x89, 0xad,
+ 0x41, 0x7f, 0x05, 0xd1, 0xc6, 0x90, 0x00, 0x61, 0xe5, 0x41, 0xf0, 0x12, 0x2f, 0xf9, 0xa1, 0x89,
+ 0x90, 0x00, 0x61, 0xe0, 0xb1, 0xd6, 0xfe, 0xe5, 0x53, 0x80, 0x1e, 0xe5, 0x3f, 0x24, 0x7f, 0x60,
+ 0x09, 0x14, 0x60, 0x1a, 0x24, 0x02, 0x60, 0x02, 0xa1, 0xce, 0x51, 0x88, 0xe4, 0xf0, 0xa3, 0xf0,
+ 0x78, 0x8b, 0x74, 0x02, 0xb1, 0xe1, 0xfe, 0xe5, 0x53, 0x78, 0xb4, 0xf2, 0x80, 0x6b, 0xaf, 0x43,
+ 0x51, 0x29, 0xef, 0x60, 0x64, 0xa1, 0xce, 0xe5, 0x3f, 0xb4, 0x02, 0x1f, 0xe5, 0x41, 0x70, 0x1b,
+ 0xaf, 0x43, 0xd1, 0x3c, 0xef, 0x60, 0x02, 0xa1, 0xce, 0xe5, 0x43, 0x64, 0x02, 0x60, 0x0c, 0xe5,
+ 0x43, 0x64, 0x86, 0x60, 0x06, 0xad, 0x43, 0x7f, 0x07, 0xd1, 0xc6, 0xe5, 0x3f, 0x70, 0x3a, 0xe5,
+ 0x41, 0x64, 0x01, 0x70, 0x34, 0x90, 0x00, 0xb0, 0xe0, 0x54, 0xfd, 0xf0, 0x80, 0x2b, 0xe5, 0x3f,
+ 0x24, 0xfe, 0x60, 0x1a, 0x24, 0x02, 0x70, 0x66, 0xe5, 0x41, 0xb4, 0x01, 0x09, 0x90, 0x00, 0xb0,
+ 0xe0, 0x44, 0x02, 0xf0, 0x80, 0x13, 0xe5, 0x41, 0x64, 0x02, 0x60, 0x0d, 0x80, 0x50, 0xe5, 0x41,
+ 0x70, 0x4c, 0xaf, 0x43, 0xb1, 0xe8, 0xef, 0x70, 0x45, 0x30, 0x18, 0x38, 0x30, 0x22, 0x11, 0xe4,
+ 0x90, 0x04, 0x81, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90, 0x00, 0xb1, 0xf0, 0xa3, 0xf0, 0xc2, 0x23,
+ 0xf1, 0xf8, 0xe5, 0x3f, 0x20, 0xe7, 0x18, 0x78, 0xbf, 0xe2, 0x90, 0x00, 0xb1, 0xf0, 0x78, 0xbe,
+ 0xe2, 0xa3, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x02, 0xd2, 0x23, 0xd2,
+ 0x22, 0x12, 0x3d, 0x10, 0x30, 0x17, 0x0e, 0x78, 0xa0, 0xe2, 0x44, 0x80, 0xf2, 0x22, 0x90, 0xe6,
+ 0xa0, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0x85, 0x53, 0x82, 0x85, 0x52, 0x83, 0xf0, 0x74, 0x01, 0x78,
+ 0x8b, 0xf2, 0xe5, 0x52, 0x78, 0xb3, 0xf2, 0x22, 0xef, 0x54, 0x0f, 0xfe, 0xef, 0x14, 0x60, 0x1a,
+ 0x14, 0x60, 0x1f, 0x24, 0x82, 0x60, 0x0b, 0x14, 0x60, 0x14, 0x24, 0xfb, 0x60, 0x18, 0x24, 0x86,
+ 0x70, 0x1b, 0x78, 0xa0, 0xe2, 0x44, 0x01, 0xf2, 0x80, 0x2f, 0x78, 0xa1, 0x80, 0x0a, 0x78, 0xa2,
+ 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0x74, 0x01, 0xf2, 0x80, 0x1c, 0x75, 0xf0, 0x02,
+ 0xee, 0x51, 0x20, 0xfc, 0x74, 0x01, 0x93, 0x4c, 0x70, 0x03, 0x7f, 0x15, 0x22, 0x75, 0xf0, 0x02,
+ 0xee, 0x51, 0x20, 0xd1, 0xb2, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x00, 0x22, 0xad, 0x07, 0xed, 0x54,
+ 0x0f, 0xfc, 0xed, 0x60, 0x50, 0x24, 0xfe, 0x60, 0x18, 0x24, 0x81, 0x60, 0x0e, 0x24, 0xfb, 0x60,
+ 0x20, 0x24, 0x85, 0x70, 0x27, 0xe4, 0x78, 0xa1, 0xf2, 0x80, 0x3a, 0xe4, 0x78, 0xa2, 0xf2, 0x80,
+ 0x34, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x2e, 0x78, 0xa3, 0xf2, 0x7f, 0x02, 0x12, 0x12, 0x78, 0x80,
+ 0x24, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x1e, 0x78, 0xa5, 0xf2, 0x80, 0x19, 0xec, 0x51, 0x1d, 0xfe,
+ 0x74, 0x01, 0x93, 0x4e, 0x70, 0x03, 0x7f, 0x15, 0x22, 0x75, 0xf0, 0x02, 0xec, 0x51, 0x20, 0xd1,
+ 0xb2, 0xe0, 0x54, 0xfd, 0xf0, 0xed, 0x30, 0xe7, 0x03, 0x43, 0x04, 0x10, 0xd1, 0xbb, 0xe0, 0x30,
+ 0xe7, 0x0d, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x20, 0xe7, 0x03, 0x43, 0x04, 0x10, 0xd1, 0xbb, 0x7f,
+ 0x00, 0x22, 0xfe, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x90, 0xe6, 0x83, 0xec, 0xf0,
+ 0x44, 0x20, 0xf0, 0xec, 0xf0, 0x22, 0xae, 0x07, 0xd1, 0xea, 0xf1, 0xf8, 0x90, 0xe2, 0x66, 0xee,
+ 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xed, 0xf0, 0xe4, 0x12, 0x18, 0xdf, 0x12, 0x3d, 0x77, 0x74, 0x0b,
+ 0xf0, 0x7f, 0x01, 0xe1, 0x93, 0xf0, 0x7f, 0x00, 0xf1, 0x93, 0x22, 0x8f, 0x3f, 0x8b, 0x40, 0x8a,
+ 0x41, 0x89, 0x42, 0x12, 0x0e, 0xa3, 0xaa, 0x41, 0xa9, 0x42, 0xae, 0x02, 0xee, 0xf5, 0x9a, 0xaf,
+ 0x01, 0xef, 0xf5, 0x9b, 0xe5, 0x3f, 0xd3, 0x94, 0x04, 0x50, 0x22, 0xd1, 0xea, 0x90, 0x04, 0x85,
+ 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x43, 0x57, 0x12, 0x3a, 0x82, 0x90, 0x04,
+ 0x84, 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xf1, 0x93, 0x02, 0x0e, 0xd1, 0xd1, 0xea, 0xe4,
+ 0x90, 0xe2, 0x67, 0xf0, 0xe5, 0x3f, 0x04, 0xc3, 0x13, 0x04, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x04,
+ 0x85, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x43, 0x67, 0x90, 0x04, 0x83, 0xe0,
+ 0x90, 0xe2, 0x65, 0xf0, 0xf1, 0x89, 0x15, 0x3f, 0x15, 0x3f, 0xd1, 0xea, 0x90, 0xe6, 0x7b, 0xe0,
+ 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0x7b, 0x12, 0x43, 0x57, 0xe5, 0x3f, 0xd3, 0x94, 0x06, 0x50,
+ 0x06, 0x12, 0x3a, 0x82, 0x75, 0x3f, 0x06, 0xf1, 0x89, 0x74, 0xfa, 0x25, 0x3f, 0xf5, 0x3f, 0x70,
+ 0xd9, 0x12, 0x0e, 0xd1, 0xd2, 0xe8, 0xd2, 0xe9, 0x22, 0x90, 0x04, 0x84, 0xe0, 0x90, 0xe2, 0x64,
+ 0xf0, 0x7f, 0x00, 0x15, 0x61, 0xa8, 0x61, 0xa6, 0x07, 0xa8, 0x61, 0xe4, 0xf6, 0x05, 0x61, 0x22,
+ 0xae, 0x07, 0xf1, 0xf2, 0x74, 0x04, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2,
+ 0x68, 0xf0, 0x90, 0x03, 0x50, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x03, 0x53, 0xe0, 0x90, 0xe2,
+ 0x6a, 0xf0, 0x90, 0x03, 0x52, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x74, 0x02, 0x12, 0x3d, 0x79, 0x04,
+ 0xd1, 0xe5, 0x90, 0x03, 0x55, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x54, 0xe0, 0x90, 0xe2,
+ 0x67, 0xf0, 0xa3, 0xee, 0xf0, 0xe4, 0x12, 0x18, 0xdf, 0x12, 0x3c, 0xbf, 0x74, 0x03, 0xf0, 0x0f,
+ 0x80, 0xa1, 0xd1, 0xea, 0x90, 0xe2, 0x66, 0x22, 0x90, 0x00, 0xff, 0xe0, 0x44, 0x08, 0xf0, 0x22,
+ 0x90, 0xe6, 0x80, 0xe0, 0x44, 0x08, 0xf0, 0x78, 0x68, 0x74, 0x0b, 0xf2, 0x22, 0xe4, 0x90, 0x04,
+ 0xa5, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x87, 0xa3, 0xe0, 0x30, 0xe0, 0x14, 0x90, 0x04, 0x87, 0xe4,
+ 0x75, 0xf0, 0x01, 0x12, 0x0b, 0xb0, 0x90, 0x04, 0x8f, 0xe4, 0x75, 0xf0, 0x01, 0x12, 0x0b, 0xb0,
+ 0x12, 0x3d, 0x85, 0x11, 0x00, 0x12, 0x3e, 0x37, 0xd2, 0xaf, 0xc2, 0xac, 0xd2, 0xa8, 0xd2, 0xaa,
+ 0x90, 0xe2, 0x7a, 0xe0, 0x54, 0xbf, 0xf0, 0x90, 0xe2, 0x7e, 0xe0, 0x44, 0x04, 0xf0, 0x12, 0x40,
+ 0x9e, 0x12, 0x13, 0x43, 0x30, 0x26, 0x20, 0x90, 0x04, 0xa5, 0xe4, 0x75, 0xf0, 0x01, 0x12, 0x0b,
+ 0xb0, 0x90, 0x04, 0xa5, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x0c, 0xf5, 0x29, 0xf5, 0x2a, 0xf5,
+ 0x2b, 0xfb, 0xfd, 0xff, 0x12, 0x3c, 0x9c, 0xc2, 0xaf, 0x30, 0x00, 0x0b, 0x90, 0x00, 0xff, 0xe0,
+ 0x20, 0xe2, 0x04, 0xd2, 0xaf, 0xd1, 0x88, 0xd2, 0xaf, 0x30, 0x08, 0x03, 0x12, 0x0e, 0xff, 0x30,
+ 0x09, 0x09, 0x30, 0x2a, 0x03, 0x12, 0x17, 0x1a, 0x12, 0x40, 0x9c, 0x30, 0x0a, 0x09, 0x30, 0x2a,
+ 0x03, 0x12, 0x17, 0x1a, 0x12, 0x40, 0x9d, 0x30, 0x0b, 0x09, 0x30, 0x2a, 0x03, 0x12, 0x17, 0x1a,
+ 0x12, 0x0f, 0xff, 0x30, 0x05, 0x0c, 0x90, 0x00, 0xe8, 0xe0, 0x60, 0x04, 0x7f, 0x01, 0x11, 0xdc,
+ 0xc2, 0x05, 0x30, 0x07, 0x03, 0x12, 0x34, 0xb2, 0x30, 0x0d, 0x89, 0x7f, 0xff, 0x30, 0x28, 0x05,
+ 0x12, 0x12, 0x95, 0x80, 0x03, 0x12, 0x40, 0x7a, 0xc2, 0x0d, 0x01, 0x54, 0x8f, 0x26, 0x75, 0x27,
+ 0x01, 0x12, 0x41, 0xe6, 0x31, 0x47, 0xf5, 0x28, 0xe4, 0xf5, 0x29, 0x12, 0x40, 0x6b, 0x74, 0xc5,
+ 0x25, 0x27, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe4, 0xf0, 0x90, 0xe2, 0x24, 0xf0, 0x00,
+ 0x12, 0x34, 0xd8, 0x12, 0x0e, 0x7e, 0x7f, 0x01, 0x12, 0x41, 0x44, 0x7f, 0x1e, 0x12, 0x1f, 0x7f,
+ 0x12, 0x13, 0xa0, 0x31, 0x47, 0x65, 0x28, 0x60, 0x2d, 0xe5, 0x26, 0x60, 0x13, 0x31, 0x47, 0xfe,
+ 0x45, 0x28, 0xff, 0xe5, 0x28, 0xd3, 0x9e, 0x7d, 0x00, 0x40, 0x02, 0x7d, 0x01, 0x12, 0x30, 0x4c,
+ 0xe5, 0x27, 0x60, 0x07, 0x90, 0x00, 0xb9, 0xe0, 0x20, 0xe0, 0x05, 0x90, 0x04, 0x93, 0x80, 0x03,
+ 0x90, 0x04, 0x94, 0x74, 0x0a, 0xf0, 0x22, 0x74, 0xc5, 0x25, 0x27, 0xf5, 0x82, 0xe4, 0x34, 0x00,
+ 0xf5, 0x83, 0xe0, 0x22, 0x8f, 0x26, 0xa2, 0x11, 0xb3, 0x92, 0x12, 0x90, 0x00, 0x89, 0xe0, 0xf5,
+ 0x27, 0xe4, 0xff, 0xfe, 0xfd, 0xfc, 0x90, 0x04, 0x96, 0xf1, 0xdb, 0xc3, 0x60, 0x01, 0xd3, 0x92,
+ 0x13, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0xff, 0xe5, 0x26, 0xd3, 0x9f, 0x40, 0x02, 0x61, 0x73,
+ 0xaf, 0x26, 0x12, 0x3c, 0x3f, 0x8f, 0x29, 0x74, 0xc5, 0x2f, 0x31, 0x4b, 0xf5, 0x2a, 0x30, 0x2a,
+ 0x24, 0x90, 0x04, 0x9e, 0xe0, 0xb5, 0x26, 0x1a, 0xe5, 0x27, 0xb4, 0x2a, 0x15, 0x90, 0x00, 0x8b,
+ 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x2c, 0xf1, 0xdb, 0x70, 0x08, 0x90, 0x00, 0x91, 0xe0, 0x64, 0x80,
+ 0x60, 0x03, 0x12, 0x17, 0x1a, 0x90, 0x04, 0x9e, 0xe5, 0x26, 0xf0, 0x71, 0x93, 0xe0, 0xf5, 0x2b,
+ 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0xe4, 0xf0, 0xe5, 0x27, 0x12, 0x0d, 0x2b, 0x2a, 0x66, 0x00,
+ 0x2a, 0x96, 0x03, 0x2a, 0x2c, 0x12, 0x2b, 0x26, 0x1a, 0x2a, 0xe7, 0x1b, 0x2b, 0x0f, 0x1e, 0x2a,
+ 0x3b, 0x23, 0x2a, 0x3b, 0x25, 0x29, 0xf5, 0x28, 0x2a, 0x09, 0x2a, 0x2a, 0x93, 0x2f, 0x2b, 0x54,
+ 0xc1, 0x00, 0x00, 0x2b, 0x5a, 0xaf, 0x2a, 0xf1, 0xb9, 0x50, 0x02, 0x61, 0x73, 0x30, 0x13, 0x05,
+ 0x20, 0x11, 0x02, 0x61, 0x73, 0xd2, 0x14, 0x80, 0x12, 0xaf, 0x2a, 0xf1, 0xb9, 0x50, 0x02, 0x61,
+ 0x73, 0x30, 0x13, 0x05, 0x30, 0x11, 0x02, 0x61, 0x73, 0xc2, 0x14, 0x75, 0x2f, 0x01, 0x75, 0x30,
+ 0x00, 0x75, 0x31, 0x8b, 0xaf, 0x29, 0x12, 0x31, 0x89, 0x8f, 0x28, 0x22, 0x20, 0x13, 0x02, 0x61,
+ 0x73, 0x12, 0x44, 0x35, 0xf1, 0x20, 0x8f, 0x28, 0x7f, 0x00, 0x22, 0xe5, 0x27, 0x7f, 0x08, 0xb4,
+ 0x23, 0x02, 0x7f, 0x0c, 0x8f, 0x2c, 0x20, 0x13, 0x02, 0x61, 0x73, 0xad, 0x27, 0xaf, 0x29, 0x12,
+ 0x42, 0x1d, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x0a, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0x74, 0x03,
+ 0x61, 0x40, 0xaf, 0x2c, 0x80, 0x7d, 0x30, 0x13, 0x02, 0x61, 0x73, 0xaf, 0x29, 0x12, 0x42, 0xdd,
+ 0x8f, 0x28, 0xe5, 0x2b, 0xb4, 0x0a, 0x0c, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0xe5, 0x2b, 0xf0,
+ 0x7f, 0x84, 0x22, 0xe5, 0x28, 0x60, 0x09, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0x74, 0x03, 0xf0,
+ 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xe5, 0x2b, 0x75, 0xf0, 0x03, 0xa4, 0x24, 0xb8, 0xf5, 0x82,
+ 0xe4, 0x34, 0x0f, 0xaf, 0x82, 0xf5, 0x2c, 0x8f, 0x2d, 0x20, 0x13, 0x02, 0x61, 0x73, 0x12, 0x37,
+ 0xa7, 0x7b, 0x12, 0x12, 0x37, 0xe9, 0x12, 0x36, 0x3a, 0x12, 0x37, 0x2a, 0x78, 0x7c, 0x74, 0x70,
+ 0xf2, 0xe4, 0xf2, 0x12, 0x43, 0xf5, 0x70, 0x02, 0x05, 0x2c, 0x75, 0x9e, 0x07, 0x74, 0x0a, 0xf2,
+ 0x75, 0x9e, 0x0c, 0x12, 0x43, 0xf5, 0x70, 0x02, 0x05, 0x2c, 0xf5, 0x82, 0x85, 0x2c, 0x83, 0xe0,
+ 0xf2, 0x7f, 0x12, 0x7e, 0x00, 0x80, 0x67, 0xf1, 0xe9, 0x12, 0x31, 0x19, 0x8f, 0x28, 0xe5, 0x28,
+ 0x60, 0x1a, 0xb4, 0x9b, 0x0b, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0x74, 0x0c, 0xf0, 0x80, 0x09,
+ 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xf1,
+ 0xe9, 0x12, 0x42, 0xe9, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x09, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95,
+ 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x12, 0x44, 0x35, 0x12, 0x35, 0xd8, 0x8f, 0x28, 0xe5, 0x28,
+ 0x60, 0x18, 0x7f, 0x02, 0xb4, 0x8f, 0x02, 0x7f, 0x0e, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0xef,
+ 0xf0, 0xa2, 0x12, 0x92, 0x16, 0x71, 0x9d, 0xaf, 0x28, 0x22, 0xaf, 0x9e, 0x7e, 0x00, 0x12, 0x3b,
+ 0x28, 0x7f, 0x00, 0x22, 0x12, 0x3b, 0xd2, 0x7f, 0x00, 0x22, 0x74, 0x93, 0x25, 0x26, 0x71, 0x95,
+ 0x74, 0x07, 0xf0, 0x30, 0x11, 0x08, 0xa2, 0x12, 0x92, 0x16, 0x71, 0x9d, 0x80, 0x02, 0xb1, 0xaa,
+ 0x7f, 0x86, 0x22, 0x30, 0x11, 0x08, 0xa2, 0x12, 0x92, 0x16, 0x71, 0x9d, 0x80, 0x02, 0xb1, 0xaa,
+ 0x74, 0x93, 0x25, 0x26, 0x71, 0x95, 0x74, 0x09, 0xf0, 0x7f, 0x98, 0x22, 0x75, 0x54, 0x8c, 0x90,
+ 0x04, 0x9e, 0xe0, 0x24, 0x93, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0x90, 0x00, 0xad,
+ 0xe0, 0x60, 0x17, 0xf1, 0xb3, 0xec, 0x4d, 0x4e, 0x4f, 0x60, 0x0f, 0x20, 0x16, 0x0a, 0xf1, 0xa6,
+ 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0x00, 0xa3, 0xf0, 0xf1, 0xf1, 0x22, 0x12, 0x44, 0x2c, 0x75, 0x38,
+ 0x64, 0xe4, 0xf5, 0x39, 0xf5, 0x54, 0xe5, 0x34, 0x60, 0x03, 0x12, 0x43, 0x06, 0x90, 0x04, 0x32,
+ 0xe0, 0x54, 0x03, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x70, 0x0a, 0x71, 0x8f, 0x74, 0x0d,
+ 0xf0, 0x75, 0x54, 0x38, 0xa1, 0x7d, 0xb1, 0xa3, 0x12, 0x35, 0x06, 0xef, 0x60, 0x05, 0x75, 0x54,
+ 0x0c, 0xa1, 0x7d, 0xb1, 0xa3, 0x12, 0x32, 0x80, 0x12, 0x37, 0xc5, 0x4e, 0x70, 0x02, 0xa1, 0x7d,
+ 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x34, 0x70, 0x02, 0x81, 0xd7, 0x30, 0x24, 0x02, 0x81, 0xd7,
+ 0xb1, 0xa3, 0xd1, 0x25, 0xe4, 0x78, 0x18, 0xf2, 0x78, 0x15, 0x74, 0x22, 0xf2, 0xe4, 0x78, 0x1b,
+ 0xf2, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x49, 0x74, 0x88, 0xf2, 0xf2, 0x12, 0x3f, 0x9b, 0xe4,
+ 0xfb, 0x7d, 0x26, 0x7f, 0x64, 0x12, 0x15, 0x20, 0x80, 0x75, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x02,
+ 0xa3, 0xe0, 0x60, 0x70, 0xe5, 0x54, 0x70, 0x6c, 0x12, 0x17, 0x09, 0x12, 0x37, 0xe0, 0x12, 0x37,
+ 0xbd, 0xfd, 0x90, 0xe6, 0xa3, 0xe0, 0x30, 0xe2, 0x03, 0x30, 0x1f, 0xf6, 0x90, 0xe6, 0x91, 0xe0,
+ 0xc3, 0x94, 0x40, 0x50, 0x03, 0x30, 0x1f, 0xf4, 0x20, 0x1f, 0x20, 0x7a, 0xf0, 0x79, 0x00, 0x74,
+ 0xf0, 0x12, 0x37, 0x30, 0x7f, 0x40, 0xae, 0x07, 0x1f, 0xee, 0x60, 0x05, 0x12, 0x37, 0xd7, 0x80,
+ 0xf5, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0x0d, 0xbd, 0x08, 0xc7, 0x90, 0xe6, 0x9c, 0x74, 0x02,
+ 0xf0, 0xe4, 0xa3, 0xf0, 0x12, 0x1e, 0x34, 0x8f, 0x39, 0x12, 0x34, 0x25, 0x12, 0x36, 0x97, 0x7d,
+ 0x26, 0x7f, 0x34, 0x12, 0x15, 0x20, 0x12, 0x43, 0xc0, 0xe5, 0x39, 0x60, 0x02, 0xf5, 0x54, 0x12,
+ 0x17, 0x4d, 0x80, 0x86, 0x12, 0x17, 0xfc, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x48, 0x74, 0x88,
+ 0xf2, 0xf2, 0x12, 0x17, 0x1a, 0xe5, 0x54, 0x60, 0x02, 0xa1, 0x6d, 0x90, 0x04, 0x96, 0x12, 0x0c,
+ 0xe5, 0x00, 0x00, 0x00, 0x00, 0xa1, 0x6d, 0x90, 0x00, 0xe1, 0x12, 0x3f, 0xad, 0x20, 0x2a, 0x28,
+ 0xb1, 0xa3, 0xd1, 0x25, 0xe4, 0xfb, 0x7d, 0x26, 0xaf, 0x38, 0x12, 0x17, 0x16, 0xef, 0x70, 0x2a,
+ 0xf1, 0xe2, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0, 0x60, 0x1c, 0x71, 0x8f,
+ 0x74, 0x01, 0xf0, 0x75, 0x54, 0x37, 0x80, 0x65, 0x12, 0x1c, 0xac, 0x12, 0x34, 0x25, 0xe4, 0xfb,
+ 0x7d, 0x26, 0x7f, 0x34, 0x12, 0x17, 0x16, 0xef, 0x70, 0x22, 0x90, 0x04, 0x2a, 0xe0, 0xfc, 0xa3,
+ 0xe0, 0xfd, 0x7b, 0x00, 0x7a, 0x02, 0xaf, 0x34, 0x12, 0x41, 0x6a, 0x12, 0x1e, 0x34, 0xe5, 0x54,
+ 0x70, 0x0a, 0x90, 0x04, 0x96, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x34, 0x60, 0x10,
+ 0xe5, 0x54, 0x70, 0x0c, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x80, 0x60, 0x1b,
+ 0x12, 0x17, 0x1a, 0xef, 0x70, 0x17, 0xf1, 0xe2, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0,
+ 0x54, 0xe0, 0x60, 0x09, 0x71, 0x8c, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x2a, 0xe4, 0x90, 0xe6,
+ 0x18, 0xf0, 0xa3, 0x74, 0x20, 0xf0, 0xe5, 0x54, 0x60, 0x03, 0x75, 0x54, 0x37, 0x12, 0x44, 0x0d,
+ 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x34, 0x60, 0x12, 0x20, 0x1f, 0x0f, 0xf1, 0xb3,
+ 0xec, 0x4d, 0x4e, 0x4f, 0x60, 0x02, 0xb1, 0xaa, 0x85, 0x54, 0x5f, 0xd1, 0x1d, 0x12, 0x43, 0x1e,
+ 0xaf, 0x54, 0x22, 0xab, 0x35, 0xaa, 0x36, 0xa9, 0x37, 0x22, 0xe4, 0xf5, 0x3a, 0xf5, 0x3b, 0x78,
+ 0x04, 0x74, 0x80, 0xf2, 0x12, 0x0e, 0x99, 0xe5, 0xaa, 0x20, 0xe0, 0x2e, 0x90, 0xe6, 0xa3, 0xe0,
+ 0xc4, 0x54, 0x07, 0xff, 0x60, 0x13, 0x7e, 0x00, 0x90, 0x00, 0xa9, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd,
+ 0x12, 0x0b, 0x9e, 0x8e, 0x3a, 0x8f, 0x3b, 0x80, 0x11, 0x90, 0xe6, 0x90, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0x7c, 0x00, 0x24, 0x00, 0xf5, 0x3b, 0xec, 0x3e, 0xf5, 0x3a, 0xae, 0x3a, 0xaf, 0x3b, 0x12, 0x3b,
+ 0xc5, 0x40, 0x0d, 0x90, 0xe6, 0xa3, 0xe0, 0x44, 0x01, 0xf0, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22,
+ 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x7f, 0x02, 0x02, 0x12, 0x78, 0x30, 0x15, 0x06, 0xc2, 0x16, 0x71,
+ 0x9d, 0x80, 0x02, 0xb1, 0xaa, 0x71, 0x8f, 0xe5, 0x34, 0xf0, 0x75, 0x5f, 0x22, 0xc2, 0x00, 0x12,
+ 0x37, 0x37, 0xd2, 0x27, 0x22, 0x8b, 0x3a, 0x8a, 0x3b, 0x89, 0x3c, 0xc0, 0x03, 0xc0, 0x02, 0xc0,
+ 0x01, 0x12, 0x0c, 0x67, 0x12, 0x43, 0x98, 0x12, 0x0c, 0xad, 0x12, 0x0b, 0xc6, 0xd0, 0x01, 0xd0,
+ 0x02, 0xd0, 0x03, 0x12, 0x0c, 0x87, 0x90, 0x04, 0x39, 0xe0, 0xab, 0x3a, 0xaa, 0x3b, 0xa9, 0x3c,
+ 0x70, 0x1c, 0xf1, 0x1a, 0x90, 0x00, 0x02, 0xf1, 0x0c, 0x4f, 0xf5, 0x55, 0xee, 0x90, 0x00, 0x03,
+ 0xf1, 0x0c, 0x4f, 0xf5, 0x56, 0xee, 0x25, 0xe0, 0xf5, 0x57, 0xe4, 0xf5, 0x58, 0x22, 0x12, 0x0b,
+ 0x36, 0xf5, 0x55, 0xf1, 0x1a, 0xf5, 0x56, 0x90, 0x00, 0x02, 0x12, 0x0b, 0x4f, 0xf5, 0x57, 0x90,
+ 0x00, 0x03, 0x12, 0x0b, 0x4f, 0xf5, 0x58, 0x22, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x11, 0x75, 0x5f,
+ 0x02, 0x12, 0x37, 0x37, 0x90, 0xe6, 0xa3, 0x74, 0x01, 0xf0, 0x90, 0xe6, 0xa5, 0xf0, 0x22, 0x74,
+ 0x00, 0xf5, 0x9a, 0x74, 0x7e, 0xf5, 0x9b, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9a, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9b, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9c, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x9d, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x99, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x98, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x97, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0x96, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0xf1, 0x13, 0x24, 0xff, 0x92,
+ 0x10, 0xe0, 0x54, 0x0f, 0xff, 0xc2, 0x27, 0xa2, 0x10, 0x92, 0x11, 0x31, 0x54, 0x8f, 0x5f, 0x90,
+ 0x00, 0xff, 0xe0, 0x20, 0xe2, 0x05, 0x20, 0x27, 0x02, 0xd1, 0x1d, 0x22, 0x25, 0xe0, 0xff, 0x12,
+ 0x0b, 0x4f, 0xfe, 0xc4, 0x13, 0x13, 0x13, 0x54, 0x01, 0x22, 0x90, 0x00, 0x01, 0x02, 0x0b, 0x4f,
+ 0x8f, 0x2e, 0x74, 0xc5, 0x2f, 0x31, 0x4b, 0x64, 0x01, 0x60, 0x0a, 0x90, 0x00, 0xb7, 0x74, 0x11,
+ 0xf0, 0xa3, 0x74, 0x2a, 0xf0, 0xf1, 0x9f, 0xe0, 0x24, 0x04, 0x30, 0x1b, 0x0b, 0xf5, 0x82, 0xe4,
+ 0x3e, 0xf5, 0x83, 0x74, 0x05, 0xf0, 0x80, 0x08, 0xf5, 0x82, 0xe4, 0x3e, 0xf5, 0x83, 0xe4, 0xf0,
+ 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x43, 0x12, 0x0b, 0x36, 0xff, 0x90, 0x00, 0xb7, 0xe0, 0xfc, 0xa3,
+ 0xe0, 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0xef, 0xf0, 0xf1, 0x1a, 0x8d, 0x82, 0x8c, 0x83, 0x12, 0x34,
+ 0x30, 0x12, 0x39, 0xaa, 0x74, 0x10, 0xf0, 0xe5, 0x2e, 0xc4, 0x54, 0xf0, 0x90, 0x04, 0x85, 0xf0,
+ 0x74, 0xc5, 0x25, 0x2e, 0x31, 0x4b, 0x90, 0x04, 0x86, 0xf0, 0xf1, 0x9f, 0xe0, 0xaa, 0x06, 0xf9,
+ 0x7b, 0x01, 0x7f, 0x2a, 0x12, 0x26, 0xeb, 0x80, 0x03, 0x12, 0x3b, 0xfe, 0x7f, 0x00, 0x22, 0x90,
+ 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0x22, 0xe5, 0x4f, 0xb4, 0x05, 0x07, 0x90, 0xe6, 0xa5, 0xe0, 0x30,
+ 0xe2, 0xf9, 0x22, 0x90, 0x04, 0x96, 0x02, 0x0c, 0xa1, 0x7b, 0x09, 0xef, 0x70, 0x02, 0xc3, 0x22,
+ 0xbf, 0x01, 0x02, 0x7b, 0x0b, 0xf1, 0xb3, 0xa8, 0x03, 0x12, 0x0c, 0x41, 0x90, 0x00, 0x90, 0xe0,
+ 0x6e, 0x70, 0x03, 0xa3, 0xe0, 0x6f, 0xc3, 0x60, 0x01, 0xd3, 0x22, 0x12, 0x0c, 0xad, 0xc3, 0x02,
+ 0x0c, 0x30, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0x03, 0x22, 0x90, 0x00, 0x8d, 0xe0, 0xfd, 0xaf, 0x29,
+ 0x22, 0xf1, 0xa6, 0x78, 0xa5, 0x74, 0x01, 0xf2, 0x22, 0x90, 0x00, 0xba, 0xe0, 0xf4, 0xff, 0x90,
+ 0x00, 0xb9, 0xe0, 0xfe, 0x5f, 0xfd, 0x75, 0x4f, 0x05, 0xee, 0x60, 0x12, 0x90, 0x00, 0xad, 0x74,
+ 0x01, 0xf0, 0xed, 0x60, 0x04, 0x7f, 0x0a, 0x11, 0x1f, 0x20, 0x24, 0x02, 0xb1, 0xa5, 0x22, 0xe4,
+ 0xfe, 0xed, 0x30, 0xe0, 0x05, 0x90, 0x04, 0x9f, 0xe0, 0xfe, 0xed, 0x30, 0xe1, 0x06, 0x90, 0x04,
+ 0xa0, 0xe0, 0x42, 0x06, 0x12, 0x26, 0xea, 0xed, 0x11, 0x44, 0xee, 0x11, 0x68, 0xef, 0xf0, 0x7f,
+ 0x01, 0x02, 0x27, 0x93, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe2, 0x66, 0x22, 0x12, 0x26, 0xea, 0x74,
+ 0x10, 0x11, 0x44, 0xef, 0xf0, 0xe4, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe2, 0x68, 0xed, 0x11, 0x68,
+ 0x74, 0x09, 0xf0, 0x7f, 0x01, 0x02, 0x27, 0x93, 0xf0, 0x74, 0xc2, 0x90, 0xe2, 0x65, 0xf0, 0x90,
+ 0xe2, 0x64, 0x22, 0x12, 0x27, 0xf2, 0xe5, 0x37, 0xf0, 0xa3, 0xe5, 0x36, 0xf0, 0xa3, 0xe5, 0x39,
+ 0xf0, 0xa3, 0xe5, 0x38, 0xf0, 0xa3, 0xe5, 0x3b, 0xf0, 0xa3, 0xe5, 0x3a, 0xf0, 0xe5, 0x34, 0x11,
+ 0x6b, 0xe5, 0x35, 0xf0, 0x7f, 0x01, 0x02, 0x27, 0x93, 0x90, 0x04, 0xa7, 0x30, 0x15, 0x09, 0x74,
+ 0x43, 0xf0, 0xa3, 0x74, 0x16, 0xf0, 0x80, 0x07, 0x74, 0x02, 0xf0, 0xa3, 0x74, 0x18, 0xf0, 0x90,
+ 0x04, 0xa7, 0xe0, 0xf5, 0x18, 0xa3, 0xe0, 0xf5, 0x19, 0xe4, 0xf5, 0x1a, 0x75, 0x1b, 0x04, 0x90,
+ 0x00, 0xeb, 0x11, 0xfe, 0xa3, 0xe0, 0xf5, 0x1e, 0xa3, 0xe0, 0xf5, 0x1f, 0x31, 0x06, 0x11, 0x73,
+ 0x90, 0x04, 0xa7, 0xe0, 0x44, 0x80, 0xf5, 0x18, 0x90, 0x00, 0xef, 0xe0, 0xf5, 0x1a, 0xa3, 0xe0,
+ 0xf5, 0x1b, 0xa3, 0x11, 0xfe, 0x31, 0x06, 0x11, 0x73, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xe5, 0x00,
+ 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x22, 0xe0, 0xf5,
+ 0x1c, 0xa3, 0xe0, 0xf5, 0x1d, 0x22, 0x78, 0x34, 0x7c, 0x00, 0x7d, 0x00, 0x7b, 0x00, 0x7a, 0x00,
+ 0x79, 0x18, 0x7e, 0x00, 0x7f, 0x08, 0x02, 0x0b, 0x10, 0x8f, 0x2e, 0x8d, 0x2f, 0x90, 0x00, 0xc7,
+ 0xe0, 0xfd, 0xa3, 0xe0, 0x90, 0x00, 0xc7, 0xf0, 0x91, 0x45, 0x90, 0x00, 0xc7, 0xed, 0xf0, 0xe5,
+ 0x2e, 0x04, 0xfd, 0xe5, 0x2f, 0x20, 0xe0, 0x08, 0xe5, 0x60, 0x5d, 0x60, 0x03, 0x7f, 0x9b, 0x22,
+ 0xef, 0x14, 0x70, 0x12, 0x51, 0x91, 0xaf, 0x2f, 0x12, 0x1f, 0xc0, 0x12, 0x1f, 0xb2, 0x90, 0x04,
+ 0x37, 0xe0, 0xf5, 0x1a, 0x80, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x27, 0x75,
+ 0x19, 0x11, 0x75, 0x18, 0xc3, 0x74, 0xc5, 0x25, 0x2e, 0x12, 0x29, 0x4b, 0xf5, 0x1b, 0xe5, 0x2e,
+ 0xc4, 0x54, 0xf0, 0xf5, 0x1a, 0xe5, 0x2f, 0x54, 0x03, 0xf5, 0x1d, 0xe4, 0x90, 0x00, 0xb7, 0xf0,
+ 0x91, 0x30, 0x31, 0x06, 0x11, 0x73, 0x7f, 0x00, 0x22, 0x91, 0x45, 0x8f, 0x33, 0xe5, 0x33, 0xb4,
+ 0x02, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x03, 0x12, 0x2e, 0x0a, 0x7f, 0x84, 0x22, 0x20,
+ 0x14, 0x10, 0x30, 0x1b, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x0d, 0x12, 0x2e, 0x0a, 0x7f,
+ 0x38, 0x22, 0xe5, 0x33, 0x64, 0x01, 0x70, 0x23, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0, 0x02, 0x51,
+ 0x99, 0x51, 0x91, 0x30, 0x14, 0x0e, 0x7f, 0x01, 0x12, 0x15, 0x84, 0x51, 0x71, 0x12, 0x13, 0xc2,
+ 0x8f, 0x32, 0x80, 0x07, 0x51, 0x71, 0x12, 0x2b, 0xbb, 0x8f, 0x32, 0xd1, 0x9e, 0x20, 0x2a, 0x03,
+ 0x12, 0x1f, 0xb2, 0x30, 0x14, 0x23, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01,
+ 0xc0, 0x02, 0xc0, 0x03, 0x51, 0x7a, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00, 0xef, 0x80, 0x21, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xad, 0xc0,
+ 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0x51, 0x7a, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02,
+ 0xd0, 0x01, 0xd0, 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xd9, 0x30, 0x1e, 0x20,
+ 0x90, 0x00, 0xf3, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xeb, 0x12, 0x2f, 0xdb, 0x50, 0x0e, 0x90, 0x00,
+ 0xf7, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xef, 0x12, 0x2f, 0xdb, 0x40, 0x04, 0xd2, 0x15, 0x11, 0x99,
+ 0x30, 0x0a, 0x13, 0x90, 0x04, 0x76, 0xe0, 0xb4, 0x12, 0x0c, 0xe4, 0x90, 0x04, 0x80, 0xf0, 0x53,
+ 0x21, 0xfb, 0xc2, 0x15, 0x11, 0x99, 0x30, 0x20, 0x03, 0x12, 0x17, 0xab, 0xc2, 0x1f, 0xaf, 0x32,
+ 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31, 0x7f, 0x01, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31,
+ 0x90, 0x00, 0x05, 0x12, 0x0b, 0x4f, 0xfe, 0x90, 0x00, 0x06, 0x12, 0x0b, 0x4f, 0xfd, 0xed, 0xff,
+ 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0xdf, 0xf0, 0x22, 0x90, 0xe6, 0x01, 0x74, 0xa3, 0xf0, 0x90,
+ 0xe6, 0x09, 0x74, 0xff, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x01, 0xf0, 0x12, 0x3e, 0xa9, 0x80,
+ 0xe0, 0x74, 0xff, 0x90, 0x00, 0xfd, 0xf0, 0xa3, 0xf0, 0x74, 0xc5, 0x2f, 0x12, 0x29, 0x4b, 0x60,
+ 0x03, 0xed, 0x60, 0x03, 0x7f, 0x0a, 0x22, 0x91, 0x89, 0xef, 0x60, 0x03, 0x7f, 0x08, 0x22, 0x12,
+ 0x0c, 0x67, 0x8f, 0x0b, 0x8e, 0x0a, 0x8d, 0x09, 0x8c, 0x08, 0x51, 0x80, 0xf1, 0xc5, 0x51, 0x91,
+ 0x90, 0x04, 0x39, 0xe0, 0x70, 0x57, 0xaf, 0x0b, 0xae, 0x0a, 0xad, 0x09, 0x90, 0x04, 0x3b, 0x12,
+ 0x0c, 0xad, 0x91, 0x11, 0x71, 0xfa, 0xfd, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xad, 0x12, 0x1a, 0x43,
+ 0xb1, 0x31, 0xfc, 0x78, 0x09, 0x12, 0x0c, 0x54, 0xef, 0x24, 0xff, 0xf5, 0x13, 0xee, 0x34, 0xff,
+ 0xf5, 0x12, 0xed, 0x34, 0xff, 0xf5, 0x11, 0xec, 0x34, 0xff, 0xf5, 0x10, 0xaf, 0x13, 0xae, 0x12,
+ 0xad, 0x11, 0xfc, 0x71, 0xe8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0xaf, 0x13,
+ 0xae, 0x12, 0xad, 0x11, 0xac, 0x10, 0x91, 0x05, 0x40, 0x3e, 0x7f, 0x0c, 0x22, 0x71, 0xe8, 0xc0,
+ 0x00, 0x71, 0xf1, 0x12, 0x0c, 0x41, 0xd0, 0x00, 0x91, 0x11, 0x71, 0xf1, 0x12, 0x0c, 0x41, 0xa8,
+ 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0x71, 0xfa, 0xfd, 0x12, 0x1a, 0x43, 0x12, 0x0c, 0xa1,
+ 0x71, 0xe8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x12, 0x1a, 0x6a, 0x12, 0x0c,
+ 0xa1, 0x91, 0x05, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x85, 0x0b, 0x58, 0x85, 0x0a, 0x57, 0x85, 0x09,
+ 0x56, 0x85, 0x08, 0x55, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x80, 0x12, 0x17, 0x16, 0xef, 0x60, 0x03,
+ 0xaf, 0x54, 0x22, 0x85, 0x0f, 0x58, 0x85, 0x0e, 0x57, 0x85, 0x0d, 0x56, 0x85, 0x0c, 0x55, 0x7b,
+ 0x01, 0x7d, 0x26, 0x7f, 0x84, 0x12, 0x17, 0x16, 0xef, 0x60, 0x03, 0xaf, 0x54, 0x22, 0x12, 0x1c,
+ 0xac, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x98, 0x12, 0x17, 0x16, 0xef, 0x60, 0x03, 0xaf, 0x54, 0x22,
+ 0xe4, 0xf5, 0x54, 0x91, 0x25, 0xd1, 0x97, 0x7d, 0x26, 0x7f, 0x34, 0x12, 0x17, 0x16, 0x90, 0x00,
+ 0xfd, 0x12, 0x43, 0xc3, 0xe5, 0x54, 0x60, 0x0a, 0x90, 0x00, 0xfd, 0xe0, 0x70, 0x02, 0xa3, 0xe0,
+ 0x70, 0xde, 0x12, 0x1f, 0xb2, 0x7f, 0x00, 0x22, 0xab, 0x0b, 0xaa, 0x0a, 0xa9, 0x09, 0xa8, 0x08,
+ 0x22, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xa1, 0x78, 0x09, 0x22, 0x90, 0x04, 0x2a, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0xff, 0xe4, 0xfc, 0x22, 0xab, 0x0f, 0xaa, 0x0e, 0xa9, 0x0d, 0xa8, 0x0c, 0xd3, 0x02, 0x0c,
+ 0x30, 0x12, 0x0b, 0xe1, 0x8f, 0x0b, 0x8e, 0x0a, 0x8d, 0x09, 0x8c, 0x08, 0x8f, 0x0f, 0x8e, 0x0e,
+ 0x8d, 0x0d, 0x8c, 0x0c, 0x22, 0x90, 0x04, 0x33, 0xe0, 0xf5, 0x55, 0xa3, 0xe0, 0xf5, 0x56, 0x22,
+ 0xa3, 0xf0, 0x90, 0x00, 0xff, 0xe0, 0x44, 0x0c, 0xf0, 0x30, 0x22, 0x08, 0x30, 0x0b, 0xfa, 0x12,
+ 0x0f, 0xff, 0x80, 0xf5, 0x22, 0x90, 0x00, 0xc7, 0xe0, 0xfe, 0xa3, 0xe0, 0x5e, 0xbf, 0x01, 0x0e,
+ 0x54, 0x1e, 0x60, 0x0a, 0x90, 0x00, 0xba, 0xe0, 0x30, 0xe1, 0x03, 0x7f, 0x01, 0x22, 0x7f, 0x02,
+ 0x22, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x91, 0xd8, 0x00, 0x12, 0x0e, 0x8f, 0x90, 0x04, 0x38,
+ 0xe0, 0x90, 0xe2, 0x1f, 0xf0, 0x00, 0x90, 0xe2, 0x2e, 0x74, 0x03, 0xf0, 0x00, 0x90, 0xe2, 0x19,
+ 0x74, 0xa5, 0xf0, 0x00, 0x12, 0x0e, 0x8f, 0x41, 0x91, 0xe4, 0xfe, 0x90, 0x00, 0xfb, 0xe0, 0x60,
+ 0x1e, 0x90, 0xe2, 0xa4, 0xe0, 0x54, 0x03, 0xff, 0xbf, 0x03, 0x03, 0x7f, 0x08, 0x22, 0x90, 0xe2,
+ 0xa6, 0x74, 0x03, 0xf0, 0x90, 0xe2, 0xa4, 0x74, 0x01, 0xf1, 0xf5, 0x90, 0x00, 0xfb, 0xf0, 0xaf,
+ 0x06, 0x22, 0xc2, 0x1f, 0xe4, 0xff, 0x91, 0x89, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x91, 0xd8,
+ 0x12, 0x40, 0x68, 0x12, 0x2f, 0xa6, 0x12, 0x41, 0xe6, 0x12, 0x43, 0xd9, 0x7f, 0x1e, 0x12, 0x1f,
+ 0x7f, 0xc2, 0x07, 0xc2, 0x05, 0x02, 0x13, 0xa0, 0x90, 0xe2, 0x21, 0x74, 0x20, 0xf0, 0x22, 0xe4,
+ 0x90, 0x00, 0xe5, 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x44, 0x03, 0xf0, 0x90, 0xe2, 0xa4, 0x74, 0x01,
+ 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x54, 0xfc, 0xf0, 0x12, 0x1f, 0xf8, 0x60, 0x06, 0x51, 0x99, 0xf1,
+ 0xb5, 0x91, 0x61, 0x02, 0x13, 0xa0, 0x51, 0x80, 0xe4, 0xfc, 0xfd, 0x12, 0x0c, 0xb9, 0x12, 0x0b,
+ 0xc6, 0x90, 0x04, 0x2c, 0x12, 0x0c, 0xd9, 0x12, 0x1a, 0x6a, 0xb1, 0x31, 0xfc, 0x90, 0x04, 0x2c,
+ 0x12, 0x3b, 0xcb, 0x40, 0x09, 0x12, 0x2b, 0x8f, 0x74, 0x08, 0xf0, 0x7f, 0x0c, 0x22, 0x7f, 0x00,
+ 0x22, 0x12, 0x0c, 0xa1, 0xef, 0x24, 0x01, 0xff, 0xe4, 0x3e, 0xfe, 0xe4, 0x3d, 0xfd, 0xe4, 0x3c,
+ 0x22, 0x8f, 0x27, 0xe5, 0x60, 0x55, 0x27, 0x60, 0x03, 0x7f, 0x00, 0x22, 0xe5, 0x27, 0xf4, 0xff,
+ 0x90, 0x00, 0xba, 0xe0, 0x5f, 0xf0, 0xed, 0x60, 0x35, 0xe0, 0x45, 0x27, 0xf0, 0xe5, 0x27, 0x14,
+ 0xff, 0x91, 0x89, 0x30, 0x24, 0x3c, 0x20, 0x1d, 0x39, 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x33, 0x12,
+ 0x0f, 0xf8, 0x12, 0x0e, 0x99, 0xd2, 0x1d, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x00, 0x90, 0xe6, 0x12,
+ 0x74, 0xa0, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x12, 0x44, 0x02, 0x80, 0x14, 0x12, 0x29,
+ 0x47, 0xff, 0x60, 0x0c, 0x90, 0x00, 0xc7, 0xe0, 0x5f, 0x70, 0x05, 0x7f, 0x01, 0x12, 0x1f, 0xc0,
+ 0xb1, 0xa5, 0x7f, 0x01, 0x22, 0x30, 0x1d, 0x2f, 0x12, 0x0f, 0xf8, 0x7f, 0x02, 0x12, 0x12, 0x78,
+ 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x90, 0xe6, 0x12, 0x74, 0xa2, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18,
+ 0xf0, 0x00, 0x90, 0xe6, 0x13, 0x74, 0x22, 0xf0, 0x00, 0x90, 0xe6, 0x19, 0x74, 0x20, 0xf0, 0x00,
+ 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0xc2, 0x1d, 0x22, 0x91, 0x45, 0x90, 0x04, 0xa7, 0xef, 0xf0, 0xbf,
+ 0x02, 0x03, 0x7f, 0x84, 0x22, 0x12, 0x2f, 0x1a, 0xfe, 0x54, 0xc0, 0xff, 0xbf, 0xc0, 0x03, 0x7f,
+ 0x8f, 0x22, 0xee, 0x54, 0x3f, 0xff, 0x64, 0x3f, 0x60, 0x05, 0xef, 0x64, 0x1c, 0x70, 0x35, 0xf1,
+ 0xa7, 0x7b, 0x40, 0xf1, 0xe9, 0xd1, 0x3a, 0xf1, 0x2e, 0x90, 0xe6, 0x7c, 0x74, 0x03, 0xf0, 0xe4,
+ 0xf0, 0x90, 0x04, 0xa7, 0xe0, 0xb4, 0x01, 0x10, 0x90, 0x04, 0x32, 0xe0, 0x54, 0x03, 0x60, 0x08,
+ 0x90, 0xe6, 0x7c, 0x74, 0x80, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xe4, 0x90, 0xe6,
+ 0x7c, 0xf0, 0x80, 0x03, 0x7f, 0x85, 0x22, 0x7f, 0x00, 0x22, 0x8e, 0x4a, 0x8f, 0x4b, 0x8d, 0x4c,
+ 0x8a, 0x4d, 0x8b, 0x4e, 0xf1, 0xce, 0xe5, 0x4a, 0xf5, 0x9a, 0xe5, 0x4b, 0xf5, 0x9b, 0xe5, 0x4e,
+ 0xae, 0x4d, 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0xff, 0xe5, 0x4e, 0x54, 0x07,
+ 0xfd, 0xef, 0x1f, 0xaa, 0x06, 0x70, 0x01, 0x1e, 0x4a, 0x60, 0x0f, 0xac, 0x4c, 0x78, 0x7b, 0xec,
+ 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0x80, 0xe7, 0xaf, 0x05, 0x1d, 0xef, 0x60, 0x07,
+ 0x78, 0x7b, 0xe5, 0x4c, 0xf2, 0x80, 0xf3, 0x12, 0x0e, 0xd1, 0x85, 0x5e, 0xe8, 0x22, 0x12, 0x15,
+ 0x13, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0xe4, 0xf5, 0x57, 0xf5, 0x58, 0xfb, 0x22, 0x90, 0xe6,
+ 0x1a, 0x74, 0x40, 0xf0, 0x22, 0x8f, 0x39, 0x74, 0xff, 0xf5, 0x3a, 0xf5, 0x3b, 0xe4, 0xf5, 0x3c,
+ 0xe5, 0x3b, 0x15, 0x3b, 0xae, 0x3a, 0x70, 0x02, 0x15, 0x3a, 0x4e, 0x60, 0x0d, 0x90, 0xe6, 0xa5,
+ 0xe0, 0x55, 0x39, 0x60, 0x05, 0x12, 0x0e, 0x8f, 0x80, 0xe6, 0x90, 0xe6, 0xa5, 0xe0, 0x55, 0x39,
+ 0x60, 0x21, 0x75, 0x3c, 0x99, 0xe4, 0x90, 0xe6, 0x1a, 0xf0, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86,
+ 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0xd1, 0x9e, 0xe5, 0x4f, 0xd3, 0x94, 0x04, 0x40, 0x03,
+ 0x12, 0x39, 0x31, 0xaf, 0x3c, 0x22, 0xf1, 0xe0, 0xf1, 0x30, 0xe4, 0xf5, 0x38, 0x7f, 0x08, 0xd1,
+ 0xa5, 0xef, 0x60, 0x03, 0x7f, 0x99, 0x22, 0x74, 0xf8, 0xf1, 0xbd, 0xff, 0xf1, 0xd7, 0x0f, 0xbf,
+ 0x40, 0xfa, 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0xa3, 0x74, 0x40, 0xf0, 0x05, 0x38, 0xe5, 0x38, 0xc3,
+ 0x94, 0x08, 0x40, 0xd9, 0x12, 0x17, 0x09, 0x7f, 0x00, 0x22, 0x7a, 0xf8, 0x79, 0x00, 0x74, 0xf8,
+ 0xf5, 0x9d, 0x74, 0x00, 0xf5, 0x9e, 0x22, 0x90, 0x00, 0xad, 0xe0, 0x60, 0x69, 0xf1, 0xa7, 0x7f,
+ 0x02, 0x12, 0x12, 0x78, 0x12, 0x0e, 0xba, 0x7a, 0xf8, 0x79, 0x00, 0x7e, 0xf8, 0xf1, 0x2e, 0x78,
+ 0x7c, 0x74, 0x55, 0xf2, 0x74, 0x53, 0xf2, 0x74, 0x42, 0xf2, 0x74, 0x53, 0xf2, 0x90, 0x04, 0x9a,
+ 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0x90, 0x04, 0x99, 0xe0, 0xf2,
+ 0x90, 0x04, 0x98, 0xe0, 0xf2, 0x90, 0x04, 0x97, 0xe0, 0xf2, 0x90, 0x04, 0x96, 0xe0, 0xf2, 0xe5,
+ 0x5f, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01, 0x78, 0x7c, 0xef, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78,
+ 0x98, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x99, 0x74, 0x0d, 0xf2, 0x12, 0x0e, 0xe8, 0x90, 0x00, 0xab,
+ 0xe0, 0x60, 0x03, 0x12, 0x2f, 0xf1, 0x22, 0xe5, 0x4f, 0xb4, 0x05, 0x08, 0x90, 0xe6, 0xa5, 0xe0,
+ 0x54, 0x09, 0x70, 0xf8, 0x22, 0xe4, 0x90, 0xe6, 0x02, 0xf0, 0xa3, 0xf0, 0x22, 0xf5, 0x9a, 0x74,
+ 0x00, 0xf5, 0x9b, 0xe4, 0x22, 0x90, 0x04, 0x2a, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x85, 0xe8,
+ 0x5e, 0xe4, 0xf5, 0xe8, 0x02, 0x0e, 0xa3, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe6, 0x7b, 0xf0, 0x22,
+ 0x7a, 0xfc, 0x79, 0x00, 0x7e, 0xfc, 0x74, 0xfc, 0x22, 0x7e, 0xf8, 0x7f, 0x00, 0x7a, 0x00, 0xe4,
+ 0xfd, 0x22, 0x90, 0xe2, 0xa4, 0xf0, 0xe4, 0x90, 0xe2, 0xa6, 0xf0, 0x22, 0xc2, 0xdc, 0x32, 0xc0,
+ 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01,
+ 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x12, 0x22, 0x8f, 0x11,
+ 0x3c, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0x53, 0x91, 0xef, 0x75,
+ 0xa1, 0x00, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00,
+ 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0xe6, 0x80, 0xe0,
+ 0x30, 0xe7, 0x21, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0xcf, 0x11, 0xd6, 0x90, 0x00, 0x68,
+ 0x11, 0xf1, 0x90, 0x00, 0xa9, 0x74, 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x7d, 0x01, 0x7f, 0x06, 0x12,
+ 0x26, 0xc6, 0xd2, 0x24, 0x90, 0x00, 0x6c, 0xe0, 0xfe, 0xa3, 0xe0, 0xf9, 0x11, 0xbf, 0x90, 0x00,
+ 0x6e, 0xe0, 0xfe, 0xa3, 0xe0, 0xf9, 0x74, 0x07, 0x11, 0xc3, 0x90, 0x00, 0xa9, 0xe0, 0x78, 0x24,
+ 0xf2, 0xa3, 0xe0, 0x78, 0x25, 0xf2, 0x11, 0x3c, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x03,
+ 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x7b,
+ 0x01, 0x74, 0x02, 0xaa, 0x06, 0x90, 0x00, 0x01, 0x02, 0x0b, 0x7c, 0x11, 0x3c, 0x32, 0x11, 0x3c,
+ 0x32, 0x11, 0x3c, 0xd2, 0x25, 0x32, 0x90, 0x00, 0x6c, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xf0, 0x90,
+ 0x00, 0x68, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x00, 0x6c, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00,
+ 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x00, 0x6e, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xc0, 0xe0,
+ 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x05, 0xc0, 0x06, 0xc0,
+ 0x07, 0xe5, 0x4f, 0xd3, 0x94, 0x04, 0x40, 0x06, 0x31, 0x31, 0xc2, 0x28, 0xd2, 0x0d, 0x11, 0x3c,
+ 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0,
+ 0x32, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x26, 0xc6, 0x75, 0x4f, 0x04, 0x22, 0xc0, 0xe0, 0xc0, 0xf0,
+ 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0,
+ 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x78, 0x8b, 0xe2, 0xff, 0xc3, 0x90, 0x00,
+ 0xb2, 0xe0, 0x9f, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x94, 0x00, 0xf0, 0xe0, 0x70, 0x02, 0xa3, 0xe0,
+ 0x60, 0x05, 0x12, 0x27, 0xf8, 0xd2, 0x23, 0x31, 0xaa, 0x74, 0x0c, 0xf0, 0x90, 0x04, 0x85, 0x74,
+ 0x40, 0xf0, 0x78, 0x8b, 0x31, 0xb4, 0x7a, 0xe7, 0x79, 0x40, 0x12, 0x26, 0xeb, 0x11, 0x3c, 0xd0,
+ 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0,
+ 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0x74, 0x43, 0x90, 0x04, 0x83, 0xf0,
+ 0x90, 0x04, 0x84, 0x22, 0xe2, 0x90, 0x04, 0x86, 0xf0, 0xe2, 0xff, 0x7b, 0x01, 0x22, 0xc0, 0xe0,
+ 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0,
+ 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x31, 0xaa, 0x74, 0x0c, 0xf0,
+ 0x90, 0x04, 0x85, 0x74, 0x60, 0xf0, 0x78, 0x8d, 0x31, 0xb4, 0x7a, 0xe7, 0x79, 0x80, 0x12, 0x26,
+ 0xeb, 0x12, 0x27, 0xf8, 0x78, 0x8d, 0xe4, 0xf2, 0x53, 0x91, 0xef, 0xf5, 0xa1, 0xd0, 0x07, 0xd0,
+ 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0,
+ 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0x74, 0xc5, 0x2f, 0x12, 0x29, 0x4b, 0x60, 0x03,
+ 0xed, 0x60, 0x06, 0x7d, 0x0a, 0x7f, 0x02, 0x80, 0x43, 0xeb, 0x14, 0x60, 0x12, 0x14, 0x60, 0x17,
+ 0x24, 0x02, 0x70, 0x1c, 0x75, 0x59, 0x04, 0x75, 0x5a, 0x45, 0x75, 0x5b, 0x05, 0x80, 0x11, 0x75,
+ 0x59, 0x04, 0x75, 0x5a, 0x4a, 0x80, 0x06, 0x75, 0x59, 0x04, 0x75, 0x5a, 0x5b, 0x75, 0x5b, 0x11,
+ 0x74, 0x02, 0x31, 0xac, 0x74, 0x15, 0xf0, 0xe4, 0x90, 0x04, 0x85, 0xf0, 0x90, 0x04, 0x86, 0xe5,
+ 0x5b, 0xf0, 0xaa, 0x59, 0xa9, 0x5a, 0x7b, 0x01, 0xff, 0x02, 0x26, 0xeb, 0x12, 0x27, 0xf2, 0xed,
+ 0x12, 0x18, 0xd9, 0xef, 0x54, 0x0f, 0x51, 0x86, 0xe4, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0x02,
+ 0x27, 0x93, 0x90, 0x04, 0x83, 0xe0, 0x44, 0x80, 0x90, 0xe2, 0x65, 0xf0, 0x22, 0xc0, 0xe0, 0xc0,
+ 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x06, 0xc0, 0x07, 0xe4, 0x53,
+ 0x91, 0xef, 0xf5, 0xa1, 0x20, 0x00, 0x65, 0x90, 0xe6, 0xa3, 0xe0, 0x20, 0xe2, 0x5e, 0x90, 0xf0,
+ 0x00, 0xe0, 0xb4, 0x55, 0x17, 0xa3, 0xe0, 0xb4, 0x53, 0x12, 0xa3, 0xe0, 0xb4, 0x42, 0x0d, 0xa3,
+ 0xe0, 0xb4, 0x43, 0x08, 0x90, 0xe6, 0x91, 0xe0, 0x64, 0x1f, 0x60, 0x15, 0x90, 0x00, 0xab, 0x74,
+ 0x01, 0xf0, 0x78, 0x49, 0x74, 0x82, 0xf2, 0x78, 0xa3, 0x74, 0x01, 0xf2, 0x78, 0xa5, 0xf2, 0x80,
+ 0x2b, 0x7f, 0x00, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf0, 0xf5, 0x83, 0xe0, 0xfe, 0x74,
+ 0x7a, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xee, 0xf0, 0x0f, 0xbf, 0x1f, 0xe4, 0x90,
+ 0xf0, 0x00, 0xe4, 0xf0, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0xd2, 0x00, 0xd0, 0x07, 0xd0, 0x06,
+ 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0xe6, 0x15, 0x74, 0x62,
+ 0xf0, 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xf0, 0x22, 0xc2, 0x14, 0xc2, 0x15, 0x90, 0x00, 0xad, 0xe0,
+ 0x70, 0x02, 0x61, 0xbc, 0x90, 0x04, 0x98, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0x9f, 0xec, 0x9e,
+ 0x50, 0x06, 0xae, 0x04, 0xaf, 0x05, 0x80, 0x00, 0xee, 0x71, 0xbd, 0x4e, 0x60, 0x6e, 0x90, 0x00,
+ 0xa9, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x71, 0xc5, 0x50, 0x0c, 0xd2, 0x14, 0x90, 0x04, 0x98, 0xe0,
+ 0xff, 0xa3, 0xe0, 0xcf, 0x71, 0xbd, 0x90, 0x04, 0xa7, 0xe0, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00,
+ 0xa3, 0xe0, 0x78, 0x99, 0xf2, 0x12, 0x2f, 0xb3, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x04, 0xa7, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0xfb, 0xaa, 0x06, 0xe4, 0xf9, 0xf8, 0xd0, 0x07, 0xd0, 0x06, 0x12, 0x0b, 0xd3,
+ 0x90, 0x04, 0x96, 0x12, 0x0c, 0xd9, 0x90, 0x00, 0xaa, 0xe0, 0x24, 0xff, 0xff, 0x90, 0x00, 0xa9,
+ 0xe0, 0x34, 0xff, 0xfe, 0x90, 0x04, 0xa7, 0xe0, 0x5e, 0xfe, 0xa3, 0xe0, 0x5f, 0x4e, 0x60, 0x02,
+ 0xd2, 0x15, 0x20, 0x14, 0x07, 0xa2, 0x15, 0x92, 0x16, 0x12, 0x2b, 0x9d, 0x22, 0x90, 0x04, 0xa7,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xe4, 0xfc, 0xfd, 0x90, 0x04, 0x96, 0x12, 0x0c, 0xad, 0xd3, 0x02,
+ 0x0c, 0x30, 0x12, 0x37, 0x2a, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xe5, 0x14, 0xf0, 0xe4, 0xf0, 0xe5,
+ 0x15, 0xf0, 0xe5, 0x16, 0xf0, 0xe5, 0x17, 0xf0, 0x90, 0x04, 0x9f, 0xe0, 0x90, 0xe6, 0x7c, 0xf0,
+ 0x90, 0x04, 0xa0, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xaf, 0x9e, 0x7e, 0x00, 0x61, 0x28, 0x12, 0x2f,
+ 0x9f, 0xe0, 0x4e, 0x60, 0x39, 0x12, 0x37, 0xa7, 0xe4, 0xff, 0xef, 0x24, 0x04, 0xfd, 0xe4, 0x33,
+ 0xfc, 0x90, 0x00, 0xb7, 0xe0, 0xfa, 0xa3, 0xe0, 0x2d, 0xf5, 0x82, 0xea, 0x3c, 0xf5, 0x83, 0xe0,
+ 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf8, 0xf5, 0x83, 0xee, 0xf0, 0x0f, 0xbf, 0x24,
+ 0xd9, 0x7f, 0x24, 0x7e, 0x00, 0x71, 0x28, 0xe4, 0x90, 0x00, 0xb7, 0xf0, 0xa3, 0xf0, 0x22, 0x7e,
+ 0x01, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1b, 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x3c, 0xef, 0xd3,
+ 0x94, 0x01, 0x40, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0xff, 0x22, 0xef, 0x60, 0x10, 0x90,
+ 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x17, 0x20, 0x19, 0x02, 0x80, 0x12, 0xd2, 0x1b, 0x80, 0x18, 0x90,
+ 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x04, 0xe4, 0xfe, 0x80, 0x0d, 0x20, 0x19, 0x08, 0x90, 0x00, 0xdb,
+ 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x1b, 0xaf, 0x06, 0x22, 0xef, 0x60, 0x03, 0x7f, 0x01, 0x22,
+ 0x90, 0x00, 0xb9, 0xe0, 0x7f, 0x01, 0x30, 0xe0, 0x02, 0x7f, 0x00, 0x22, 0x12, 0x27, 0xf2, 0xef,
+ 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xeb, 0xf0, 0xa3, 0xe5, 0x29, 0xf0, 0xa3, 0xe5, 0x2a, 0xf0, 0xa3,
+ 0xe5, 0x2b, 0xf0, 0x74, 0xc0, 0x91, 0xc1, 0x74, 0x7f, 0xf0, 0x7f, 0x01, 0x02, 0x27, 0x93, 0x74,
+ 0x82, 0x90, 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0x12, 0x26, 0xea, 0x90, 0x03, 0x51, 0xe0,
+ 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x50, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xef, 0xf0, 0xe4,
+ 0xa3, 0xf0, 0x91, 0xbf, 0x74, 0x10, 0xf0, 0x7f, 0x01, 0x02, 0x27, 0x93, 0x12, 0x26, 0xea, 0x90,
+ 0x04, 0x6d, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x04, 0x6c, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xe4,
+ 0x12, 0x18, 0xdd, 0xef, 0x44, 0x80, 0x12, 0x30, 0x6b, 0x74, 0x01, 0xf0, 0xff, 0x02, 0x27, 0x93,
+ 0x12, 0x27, 0xf2, 0x74, 0x05, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x08, 0xf0, 0xe4, 0xa3, 0xf0,
+ 0x90, 0xe6, 0xb8, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x90, 0xe6, 0xb9, 0xe0, 0x90, 0xe2, 0x6a, 0xf0,
+ 0x90, 0xe2, 0x65, 0x74, 0x43, 0xf0, 0x90, 0xe2, 0x64, 0x74, 0x0c, 0x12, 0x26, 0xe5, 0x90, 0xe6,
+ 0xba, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0xbb, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6,
+ 0xbc, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe6, 0xbd, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6,
+ 0xbe, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x90, 0xe6, 0xbf, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0xb1, 0x77,
+ 0x74, 0x0c, 0xf0, 0x0f, 0x02, 0x27, 0x93, 0x74, 0xc3, 0x90, 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64,
+ 0x22, 0x53, 0x91, 0xdf, 0x32, 0x75, 0x92, 0xe6, 0x90, 0xe6, 0x0d, 0x74, 0x01, 0xf0, 0xa3, 0x74,
+ 0x0a, 0xf0, 0x90, 0xe6, 0x00, 0x74, 0x14, 0xf0, 0xc2, 0x88, 0x43, 0xb8, 0x04, 0xe4, 0xf5, 0x8e,
+ 0x78, 0x82, 0x74, 0x05, 0xf2, 0x75, 0xaf, 0x07, 0x78, 0x04, 0x74, 0x02, 0xf2, 0x00, 0x00, 0x00,
+ 0x78, 0x12, 0x74, 0xa2, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x18, 0xf2, 0x00, 0x00, 0x00, 0x78,
+ 0x04, 0x74, 0x04, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x13, 0x74, 0x22, 0xf2, 0x00, 0x00, 0x00, 0x78,
+ 0x19, 0x74, 0x20, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x00, 0x00, 0x00, 0x78,
+ 0x14, 0x74, 0xe2, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1a, 0x74, 0x40, 0xf2, 0x00, 0x00, 0x00, 0x78,
+ 0x04, 0x74, 0x08, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x15, 0x74, 0x62, 0xf2, 0x00, 0x00, 0x00, 0x78,
+ 0x1b, 0x74, 0x40, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x04, 0xf2, 0x00, 0x00, 0x00, 0x90, 0xe3,
+ 0x04, 0xf0, 0x90, 0xe2, 0xa6, 0xf0, 0xa3, 0xf0, 0x00, 0x00, 0x00, 0x78, 0x0b, 0x74, 0x03, 0xf2,
+ 0x00, 0x00, 0x00, 0x90, 0xe2, 0x1f, 0x74, 0x20, 0xf0, 0x90, 0xe4, 0xdf, 0xf0, 0x75, 0xe8, 0x03,
+ 0xd2, 0xdd, 0xc2, 0x19, 0xd2, 0x1a, 0x22, 0x90, 0x04, 0xa0, 0x74, 0x06, 0xf0, 0x90, 0x04, 0x9f,
+ 0xe0, 0x70, 0x0f, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0xf0, 0xe4, 0x90, 0xe2, 0xa4, 0xf0, 0x90, 0xe2,
+ 0xa6, 0xf0, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x90, 0xe2, 0x43, 0x74, 0x01, 0xf0, 0x90,
+ 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x06, 0x90, 0xe2, 0x41, 0x74, 0x01, 0xf0, 0xd0, 0x82, 0xd0, 0x83,
+ 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x07,
+ 0xc2, 0x8b, 0x90, 0x00, 0xe8, 0xe0, 0xff, 0x90, 0xe2, 0x31, 0xe0, 0x5f, 0x60, 0x05, 0x74, 0xff,
+ 0xf0, 0xd2, 0x05, 0xd0, 0x07, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x74, 0x30,
+ 0xd1, 0xd9, 0x74, 0x03, 0xd1, 0xcf, 0x74, 0x78, 0xf0, 0x90, 0x04, 0x3f, 0xe0, 0x90, 0xe6, 0x0d,
+ 0xf0, 0x12, 0x0e, 0x99, 0x90, 0x04, 0x36, 0xe0, 0x90, 0xe6, 0x0e, 0xf0, 0x12, 0x0e, 0x99, 0x90,
+ 0x04, 0x40, 0xe0, 0xf5, 0x8e, 0x22, 0xd1, 0xd7, 0x04, 0xd1, 0xcf, 0x04, 0xf0, 0x80, 0xda, 0xf0,
+ 0xa3, 0x14, 0xf0, 0x90, 0x04, 0x36, 0x22, 0x74, 0x02, 0x90, 0x00, 0xe4, 0xf0, 0x90, 0x04, 0x3f,
+ 0x22, 0xd1, 0xd7, 0x14, 0xf0, 0xa3, 0x04, 0xf0, 0x90, 0x04, 0x30, 0xe0, 0x90, 0x04, 0x36, 0xf0,
+ 0x80, 0xb7, 0x90, 0x00, 0xe4, 0x74, 0x01, 0xf0, 0x90, 0x04, 0x3f, 0xf0, 0xe4, 0xa3, 0xf0, 0x90,
+ 0x04, 0x31, 0xe0, 0x90, 0x04, 0x36, 0xf0, 0x80, 0xa0, 0xe4, 0x90, 0x04, 0x2a, 0xf0, 0xa3, 0xf0,
+ 0x90, 0x04, 0x33, 0xf0, 0xa3, 0xf0, 0x12, 0x1a, 0x6a, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00,
+ 0xe4, 0x90, 0x04, 0x32, 0xf0, 0x90, 0x04, 0x39, 0xf0, 0xc2, 0x2b, 0x90, 0x04, 0x37, 0xf0, 0xc2,
+ 0x2a, 0xa3, 0xf0, 0xc2, 0x29, 0xc2, 0x2a, 0x90, 0x04, 0x3a, 0xf0, 0x90, 0x04, 0x41, 0x12, 0x0c,
+ 0xe5, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x9e, 0x74, 0x02, 0xf1, 0x79, 0x90, 0xe2, 0x19, 0x74, 0xa5,
+ 0xf0, 0x12, 0x15, 0x13, 0xf1, 0x87, 0x12, 0x1b, 0xca, 0x12, 0x15, 0x13, 0xe4, 0x90, 0xe2, 0x32,
+ 0xf0, 0x12, 0x15, 0x13, 0xe4, 0xf1, 0x8f, 0xf1, 0x80, 0x90, 0xe2, 0x2e, 0x74, 0x03, 0xf0, 0x12,
+ 0x15, 0x13, 0x90, 0xe2, 0x29, 0x74, 0xff, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xf0, 0x02, 0x15, 0x13,
+ 0x90, 0xe2, 0x34, 0xf0, 0x02, 0x15, 0x13, 0xe4, 0x90, 0xe2, 0x1b, 0xf0, 0x02, 0x15, 0x13, 0x90,
+ 0xe2, 0x33, 0xf0, 0x12, 0x15, 0x13, 0xe4, 0x22, 0x12, 0x1f, 0x1c, 0x7d, 0x01, 0x7c, 0x00, 0x7f,
+ 0x30, 0xab, 0x07, 0xed, 0x90, 0xe2, 0x1c, 0xf0, 0xeb, 0x4c, 0xa3, 0xf0, 0x22, 0xe0, 0x54, 0x30,
+ 0xff, 0x90, 0x04, 0x2a, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x80, 0xe6, 0x90, 0x04, 0x65, 0xe0, 0x54,
+ 0x01, 0xff, 0x7e, 0x01, 0x90, 0x04, 0x35, 0xe0, 0xfb, 0x70, 0x17, 0xef, 0x70, 0x0a, 0x90, 0x04,
+ 0x66, 0xe0, 0x54, 0xfe, 0xc3, 0x13, 0x04, 0xfe, 0xaf, 0x06, 0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x09,
+ 0x80, 0x4a, 0xeb, 0x64, 0x01, 0x70, 0x58, 0xf5, 0x2d, 0x12, 0x17, 0x11, 0xef, 0x70, 0x50, 0x7d,
+ 0x40, 0x12, 0x43, 0xaa, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x34, 0x12, 0x17, 0x16, 0xef, 0x70, 0x3f,
+ 0x12, 0x10, 0xf8, 0x70, 0x3a, 0x90, 0xfc, 0x0a, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0xf5, 0x2d, 0x12,
+ 0x17, 0xec, 0x12, 0x17, 0x09, 0xe5, 0x2d, 0xd3, 0x94, 0x00, 0x40, 0x19, 0xe5, 0x2d, 0x94, 0x0a,
+ 0x50, 0x13, 0xe4, 0xff, 0x7e, 0x20, 0xfd, 0xfc, 0xa9, 0x2d, 0xa8, 0x01, 0x12, 0x0c, 0x54, 0x90,
+ 0x04, 0x3b, 0x02, 0x0c, 0xd9, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x22,
+ 0x12, 0x1f, 0xf8, 0xfe, 0x5f, 0xfd, 0x60, 0x0f, 0xff, 0xc2, 0x14, 0x12, 0x1f, 0x2c, 0xe4, 0xfb,
+ 0xfd, 0xff, 0x12, 0x15, 0x20, 0x11, 0x68, 0x43, 0xb4, 0x41, 0xe4, 0x90, 0x00, 0xc6, 0xf0, 0x43,
+ 0xa0, 0x40, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x12, 0x0e, 0x7e, 0x90, 0x00, 0xc8, 0xe0, 0x54,
+ 0xe1, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0xe1, 0xf0, 0x22, 0x90, 0x00, 0xc8, 0xe0, 0x5f, 0xff,
+ 0x90, 0x00, 0xe3, 0xe0, 0x70, 0x03, 0x7f, 0x11, 0x22, 0xef, 0x54, 0x1e, 0x60, 0x07, 0x11, 0x40,
+ 0x90, 0x00, 0xc8, 0xef, 0xf0, 0xe4, 0x90, 0x00, 0xe3, 0xf0, 0xff, 0x22, 0x22, 0x22, 0xe4, 0x90,
+ 0x00, 0xb6, 0xf0, 0x90, 0x00, 0xc7, 0xf0, 0x90, 0x00, 0xb9, 0xf0, 0xa3, 0xf0, 0xf5, 0x60, 0x90,
+ 0x00, 0xdd, 0xf0, 0x90, 0x00, 0xdc, 0xf0, 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xbb, 0x74, 0x08,
+ 0xf0, 0xa3, 0xe4, 0xf0, 0xa3, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xc9, 0x74,
+ 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x12, 0x1a, 0x6a, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4,
+ 0x90, 0x00, 0xc8, 0xf0, 0x31, 0x2e, 0x74, 0x38, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x02, 0xf0,
+ 0xc2, 0x20, 0x90, 0x00, 0xe6, 0x14, 0xf0, 0xc2, 0x1d, 0xe4, 0x90, 0x00, 0xc5, 0xf0, 0xa3, 0xf0,
+ 0xc2, 0x1e, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12,
+ 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xe7, 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0xa3, 0x74,
+ 0x01, 0xf0, 0xa3, 0xf0, 0xe4, 0xf5, 0xb2, 0x75, 0xb4, 0x40, 0x75, 0xa0, 0x40, 0x22, 0x90, 0x00,
+ 0xe1, 0x74, 0x14, 0xf0, 0x7a, 0xfc, 0x7b, 0x01, 0x79, 0x00, 0x90, 0x00, 0xde, 0x12, 0x0d, 0x22,
+ 0x90, 0x00, 0xe2, 0x22, 0xad, 0x07, 0x31, 0x2e, 0x74, 0x38, 0xf0, 0x12, 0x2f, 0xa6, 0x90, 0x00,
+ 0xdd, 0xe0, 0x54, 0xfd, 0xf0, 0xed, 0x60, 0x09, 0xd2, 0x1c, 0x90, 0xe2, 0x42, 0x74, 0x29, 0xf0,
+ 0x22, 0xc2, 0x1c, 0x90, 0xe2, 0x42, 0x74, 0x11, 0xf0, 0x22, 0x7e, 0x32, 0xef, 0x60, 0x31, 0x12,
+ 0x0f, 0xf8, 0x30, 0x24, 0x02, 0x7e, 0x0a, 0xaf, 0x06, 0x1e, 0xef, 0x60, 0x08, 0x90, 0x00, 0x7a,
+ 0xe0, 0xf5, 0x3a, 0x80, 0xf2, 0xe5, 0xaa, 0x20, 0xe0, 0x09, 0x90, 0xe6, 0x49, 0x74, 0x02, 0xf0,
+ 0x00, 0x80, 0xf2, 0x90, 0xe6, 0x18, 0x74, 0x30, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22,
+ 0xd3, 0xed, 0x94, 0x01, 0xec, 0x94, 0x00, 0x40, 0x1c, 0x90, 0xe6, 0xa4, 0xe0, 0x20, 0xe3, 0x04,
+ 0x30, 0x1f, 0xf6, 0x22, 0x31, 0xdf, 0x12, 0x15, 0x13, 0x31, 0xdf, 0x12, 0x15, 0x13, 0x90, 0xe6,
+ 0x19, 0x74, 0x30, 0xf0, 0x22, 0x90, 0xe6, 0xa4, 0xe0, 0x30, 0xe2, 0x04, 0x30, 0x1f, 0xf6, 0x22,
+ 0x90, 0xe6, 0x94, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xc3, 0x9b, 0xee, 0x9a, 0x40, 0xf1, 0x90,
+ 0xe6, 0x49, 0x74, 0x04, 0xf0, 0x22, 0x90, 0xe6, 0xa6, 0xe0, 0x30, 0xe2, 0xf9, 0x90, 0xe2, 0xe7,
+ 0xe0, 0x30, 0xe1, 0xf9, 0x90, 0xe2, 0xe7, 0xe0, 0x30, 0xe5, 0xf9, 0x22, 0x12, 0x1f, 0xf8, 0x60,
+ 0x0c, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x32, 0x99, 0x51, 0x14, 0x90, 0x00, 0xe5,
+ 0x74, 0x5a, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x90, 0x04, 0x38, 0xf0, 0x22, 0x8d, 0x2e, 0xe4,
+ 0xfd, 0x12, 0x34, 0x45, 0xac, 0x07, 0xbc, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x12, 0x37, 0xa7, 0x12,
+ 0x37, 0x2e, 0xe5, 0x2e, 0xb4, 0x23, 0x0c, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xf0, 0xf0, 0x74, 0x08,
+ 0xf0, 0x7d, 0x02, 0xec, 0x70, 0x2a, 0x90, 0x00, 0xbd, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xbe, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xc0, 0x51, 0xa9, 0x90, 0x00, 0xbb, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbc, 0x80, 0x31,
+ 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x12, 0x1a, 0x6e, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0x51, 0xcf,
+ 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x51, 0xc1, 0xe0, 0x90, 0xe6, 0x7c,
+ 0xf0, 0xef, 0x51, 0xb3, 0x51, 0xa9, 0x90, 0x00, 0xc9, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xca, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x7f, 0x00, 0x22, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xed, 0xf0,
+ 0xe4, 0xf0, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xce, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83,
+ 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcd, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x25,
+ 0xe0, 0x25, 0xe0, 0x24, 0xcc, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x12, 0x34, 0x45,
+ 0xbf, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x7f, 0x00, 0x22, 0xac, 0x07, 0x12, 0x34, 0x45, 0xbf, 0x02,
+ 0x03, 0x7f, 0x84, 0x22, 0xec, 0x04, 0xff, 0xed, 0x60, 0x05, 0xef, 0x42, 0x60, 0x80, 0x04, 0xef,
+ 0xf4, 0x52, 0x60, 0x7f, 0x00, 0x22, 0x90, 0x00, 0xfc, 0x74, 0x04, 0xf0, 0xe4, 0xf5, 0x8d, 0xf5,
+ 0x8b, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x10, 0xf5, 0x89, 0xd2, 0x8e, 0xd2, 0xab, 0x22, 0xe4, 0x90,
+ 0x00, 0xfc, 0xf0, 0xc2, 0xab, 0xc2, 0x8e, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x30, 0xf5, 0x89, 0x22,
+ 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0x30, 0x25, 0x0a, 0xc2, 0x25, 0x90, 0x00, 0xfc, 0x74, 0x04,
+ 0xf0, 0x80, 0x0d, 0x90, 0x00, 0xfc, 0xe0, 0x60, 0x07, 0x14, 0xf0, 0xe0, 0x70, 0x02, 0xd2, 0x1f,
+ 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0x7b, 0xe0,
+ 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0x7b, 0xe0,
+ 0x90, 0xe2, 0x6b, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x22, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0xac, 0x06, 0x8c, 0x44, 0xf5, 0x45, 0x85, 0x45, 0x82, 0x85, 0x44, 0x83, 0xa3, 0xa3, 0xe0,
+ 0x78, 0x8b, 0xf2, 0xee, 0x78, 0xb3, 0xf2, 0x22, 0x90, 0x00, 0xdb, 0xe0, 0x25, 0xe0, 0x25, 0xe0,
+ 0x24, 0xd3, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0xe4, 0xff, 0x12, 0x17, 0xf9, 0x90,
+ 0xe2, 0x1e, 0x74, 0x40, 0xf0, 0x22, 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4f, 0xf0, 0x02, 0x15, 0x13,
+ 0x90, 0x04, 0x2a, 0x74, 0xff, 0xf5, 0xf0, 0x02, 0x0b, 0xb0, 0x78, 0x83, 0x74, 0x02, 0xf2, 0x74,
+ 0x22, 0xf2, 0x74, 0x16, 0xf2, 0x74, 0x36, 0xf2, 0x22, 0x90, 0x00, 0xdd, 0xe0, 0x54, 0xfd, 0xf0,
+ 0x90, 0xe2, 0x42, 0x74, 0x25, 0xf0, 0x22, 0x75, 0xf0, 0x02, 0xef, 0x90, 0x10, 0xae, 0x12, 0x0d,
+ 0x16, 0x74, 0x01, 0x93, 0x22, 0x85, 0x2d, 0x82, 0x85, 0x2c, 0x83, 0xe0, 0xf2, 0x05, 0x2d, 0xe5,
+ 0x2d, 0x22, 0x7f, 0x02, 0x12, 0x12, 0x78, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0x90, 0xe2, 0x31,
+ 0x74, 0x08, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x22, 0x90, 0xe2, 0x0b, 0xe0, 0x54, 0x78, 0x13, 0x13,
+ 0x13, 0x22, 0xe0, 0xc4, 0x33, 0x33, 0x54, 0xc0, 0xff, 0xa3, 0xe0, 0x22, 0x8f, 0x34, 0x8b, 0x35,
+ 0x8a, 0x36, 0x89, 0x37, 0x22, 0x7b, 0x01, 0x7a, 0x00, 0x79, 0x8a, 0xaf, 0x29, 0x22, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0x8e, 0x50, 0xf5, 0x51, 0x22, 0xe4, 0x78, 0x5c, 0xf2, 0x78, 0x5e, 0xf2, 0x22, 0x00
+ }
+} ;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastfw_sd_mmc_rel_silicon.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1408 @@
+#define CYASTFW_SD_MMC_REL_SILICON_SIZE 22392
+union {
+ uint8_t fw_image[CYASTFW_SD_MMC_REL_SILICON_SIZE] ;
+ uint16_t dummy_for_word_alignment ;
+} cyastfw_sd_mmc_rel_silicon_array = {
+ {
+ 0x02, 0x10, 0xae, 0x02, 0x52, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x52, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x56, 0x1e, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x19, 0x99, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xe7, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x46, 0xe7, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x3e,
+ 0x88, 0x82, 0x8c, 0x83, 0xe7, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x32, 0xe3, 0x09, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x78, 0xe3, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x70, 0x88, 0x82, 0x8c, 0x83,
+ 0xe3, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x64, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x58, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x4c,
+ 0x80, 0xd2, 0x80, 0xfa, 0x80, 0xc6, 0x80, 0xd4, 0x80, 0x69, 0x80, 0xf2, 0x80, 0x33, 0x80, 0x10,
+ 0x80, 0xa6, 0x80, 0xea, 0x80, 0x9a, 0x80, 0xa8, 0x80, 0xda, 0x80, 0xe2, 0x80, 0xca, 0x80, 0x33,
+ 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83,
+ 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xe9, 0xde, 0xe7, 0x80,
+ 0x0d, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf6, 0x08, 0xdf, 0xf9, 0xec, 0xfa, 0xa9, 0xf0,
+ 0xed, 0xfb, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc,
+ 0xc5, 0x83, 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xea, 0xde,
+ 0xe8, 0x80, 0xdb, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf2, 0x08, 0xdf, 0xf9, 0x80, 0xcc,
+ 0x88, 0xf0, 0xef, 0x60, 0x01, 0x0e, 0x4e, 0x60, 0xc3, 0x88, 0xf0, 0xed, 0x24, 0x02, 0xb4, 0x04,
+ 0x00, 0x50, 0xb9, 0xf5, 0x82, 0xeb, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xaf, 0x23, 0x23, 0x45,
+ 0x82, 0x23, 0x90, 0x0a, 0x90, 0x73, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0x22, 0x50,
+ 0x02, 0xe7, 0x22, 0xbb, 0xfe, 0x02, 0xe3, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0x22, 0xbb,
+ 0x01, 0x0c, 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe0, 0x22, 0x50, 0x06,
+ 0xe9, 0x25, 0x82, 0xf8, 0xe6, 0x22, 0xbb, 0xfe, 0x06, 0xe9, 0x25, 0x82, 0xf8, 0xe2, 0x22, 0xe5,
+ 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe4, 0x93, 0x22, 0xf8, 0xbb, 0x01, 0x0d,
+ 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe8, 0xf0, 0x22, 0x50, 0x06, 0xe9,
+ 0x25, 0x82, 0xc8, 0xf6, 0x22, 0xbb, 0xfe, 0x05, 0xe9, 0x25, 0x82, 0xc8, 0xf2, 0x22, 0xef, 0x8d,
+ 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, 0x2e, 0xfe, 0x22,
+ 0xc5, 0xf0, 0xf8, 0xa3, 0xe0, 0x28, 0xf0, 0xc5, 0xf0, 0xf8, 0xe5, 0x82, 0x15, 0x82, 0x70, 0x02,
+ 0x15, 0x83, 0xe0, 0x38, 0xf0, 0x22, 0xef, 0x2b, 0xff, 0xee, 0x3a, 0xfe, 0xed, 0x39, 0xfd, 0xec,
+ 0x38, 0xfc, 0x22, 0xc3, 0xef, 0x9b, 0xff, 0xee, 0x9a, 0xfe, 0xed, 0x99, 0xfd, 0xec, 0x98, 0xfc,
+ 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, 0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c,
+ 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, 0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0,
+ 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, 0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc,
+ 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, 0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd,
+ 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, 0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22,
+ 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, 0xf0, 0xe8, 0x9c, 0x45, 0xf0,
+ 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, 0xee, 0x13, 0xfe, 0xef, 0x13,
+ 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33,
+ 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xa1, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x51, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x5d,
+ 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x69, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xd9, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xa3, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xaf,
+ 0x22, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x22, 0xe0, 0xf8, 0xa3,
+ 0xe0, 0xf9, 0xa3, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83,
+ 0x02, 0x0c, 0xad, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x79, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02,
+ 0x0d, 0x86, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x93, 0xec, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xa8, 0x82, 0x85, 0x83, 0xf0, 0xd0, 0x83, 0xd0, 0x82, 0x12, 0x0c,
+ 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0xe4, 0x73, 0xe4, 0x93, 0xa3, 0xc5,
+ 0x83, 0xc5, 0xf0, 0xc5, 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0xf0, 0xa3, 0xc5, 0x83, 0xc5, 0xf0, 0xc5,
+ 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5,
+ 0x83, 0x22, 0xeb, 0xf0, 0xa3, 0xea, 0xf0, 0xa3, 0xe9, 0xf0, 0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8,
+ 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, 0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93,
+ 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, 0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80,
+ 0xdf, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x08, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe2, 0xfc, 0x08,
+ 0xe2, 0xfd, 0x08, 0xe2, 0xfe, 0x08, 0xe2, 0xff, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd,
+ 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, 0xf9, 0x08, 0xe6,
+ 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xe2, 0xfb, 0x08, 0xe2, 0xf9, 0x08, 0xe2, 0xfa, 0x08, 0xe2,
+ 0xcb, 0xf8, 0x22, 0xe4, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf9, 0x74, 0x02, 0x93, 0xfa, 0x74, 0x03,
+ 0x93, 0xfb, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, 0xf6, 0x08, 0xef, 0xf6, 0x22, 0xec,
+ 0xf2, 0x08, 0xed, 0xf2, 0x08, 0xee, 0xf2, 0x08, 0xef, 0xf2, 0x22, 0xc1, 0x26, 0x41, 0x00, 0x60,
+ 0x00, 0x41, 0x00, 0x61, 0x00, 0x42, 0x00, 0xa9, 0x00, 0x40, 0x41, 0x00, 0xab, 0x00, 0x41, 0x00,
+ 0xac, 0x7c, 0x01, 0x14, 0x00, 0x41, 0x00, 0xae, 0x00, 0xc1, 0x24, 0x02, 0x15, 0x00, 0x00, 0x41,
+ 0x00, 0xaf, 0x00, 0x42, 0x00, 0xb1, 0x00, 0x00, 0xc1, 0x25, 0x02, 0x17, 0x00, 0xb3, 0x41, 0x00,
+ 0xb0, 0x00, 0xc1, 0x27, 0x41, 0x00, 0xad, 0x00, 0x44, 0x04, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x04, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x04, 0x87, 0x03, 0x90, 0x4a, 0x04, 0x89, 0x03,
+ 0x40, 0x03, 0x48, 0x03, 0x50, 0x03, 0x90, 0x00, 0x00, 0x48, 0x04, 0x6c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x83, 0x00, 0x41, 0x04, 0x84, 0x00, 0x41, 0x04, 0x85, 0x00,
+ 0x41, 0x04, 0x86, 0x00, 0x02, 0x20, 0x00, 0x00, 0x41, 0x00, 0xfd, 0x00, 0xc1, 0x2e, 0x41, 0x04,
+ 0x30, 0x16, 0x41, 0x04, 0x31, 0x0a, 0x01, 0x08, 0x01, 0x01, 0x09, 0x02, 0x02, 0x0a, 0x00, 0xc5,
+ 0x41, 0x04, 0xbf, 0x00, 0x41, 0x04, 0xc0, 0x00, 0x41, 0x04, 0xc1, 0x00, 0x41, 0x04, 0xc4, 0x01,
+ 0x42, 0x00, 0xb7, 0x00, 0x00, 0x41, 0x00, 0xfb, 0x00, 0xc1, 0x21, 0x00, 0x74, 0x00, 0xf5, 0x86,
+ 0x90, 0xfd, 0xa5, 0x7c, 0x05, 0xa3, 0xe5, 0x82, 0x45, 0x83, 0x70, 0xf9, 0x22, 0x74, 0x00, 0xf5,
+ 0x86, 0x90, 0xff, 0xe1, 0x02, 0x0e, 0x85, 0x74, 0x00, 0xf5, 0x86, 0x90, 0xff, 0x41, 0x02, 0x0e,
+ 0x85, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x5d, 0xa8, 0x5d, 0xe5, 0x9a, 0xf6, 0x15, 0x5d, 0xa8, 0x5d,
+ 0xe5, 0x9b, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x5d, 0xa8, 0x5d,
+ 0xe5, 0x9d, 0xf6, 0x15, 0x5d, 0xa8, 0x5d, 0xe5, 0x9e, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0,
+ 0x00, 0xc0, 0xe0, 0xa8, 0x5d, 0xe6, 0xf5, 0x9b, 0x05, 0x5d, 0xa8, 0x5d, 0xe6, 0xf5, 0x9a, 0x05,
+ 0x5d, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0xa8, 0x5d, 0xe6, 0xf5, 0x9e, 0x05,
+ 0x5d, 0xa8, 0x5d, 0xe6, 0xf5, 0x9d, 0x05, 0x5d, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc2, 0xdc, 0x32,
+ 0x02, 0x48, 0x4a, 0x00, 0x02, 0x4f, 0x00, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x48, 0x88, 0x00,
+ 0x02, 0x31, 0x4c, 0x00, 0x02, 0x4e, 0x74, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x4f, 0x06, 0x00, 0x02, 0x4f, 0x0a, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x4f, 0x7f, 0x00,
+ 0x02, 0x4f, 0xdf, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x08, 0x03, 0x05, 0x24,
+ 0x00, 0x02, 0x3a, 0x00, 0x03, 0x03, 0x00, 0x03, 0x11, 0x0c, 0x03, 0x12, 0x00, 0x05, 0x20, 0x00,
+ 0x05, 0x21, 0x00, 0x05, 0x26, 0x00, 0x06, 0x28, 0x00, 0x05, 0x04, 0x02, 0x02, 0x53, 0x02, 0x07,
+ 0x27, 0x00, 0x05, 0x39, 0x00, 0xff, 0xff, 0xff, 0xe3, 0x18, 0xe3, 0x19, 0xe3, 0x1a, 0xe3, 0x1b,
+ 0xe3, 0x12, 0xe3, 0x13, 0xe3, 0x14, 0xe3, 0x15, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0x22,
+ 0x00, 0x00, 0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0xb4, 0x04, 0x17, 0x47, 0x02, 0x00,
+ 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00,
+ 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00, 0x00, 0x02,
+ 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x00, 0x02, 0x00, 0x07, 0x05, 0x86, 0x02, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00,
+ 0x00, 0x02, 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x07, 0x05, 0x86,
+ 0x02, 0x40, 0x00, 0x00, 0x04, 0x03, 0x09, 0x04, 0x1a, 0x03, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00,
+ 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x30, 0x00,
+ 0x31, 0x00, 0x10, 0x03, 0x43, 0x00, 0x79, 0x00, 0x70, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00,
+ 0x73, 0x00, 0x18, 0x03, 0x57, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x42, 0x00,
+ 0x72, 0x00, 0x69, 0x00, 0x64, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x7f,
+ 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x92, 0xe6, 0x75, 0x81, 0x5d, 0x02, 0x10, 0xf8, 0x02, 0x40, 0x27,
+ 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0x40, 0x03, 0xf6, 0x80, 0x01, 0xf2, 0x08, 0xdf, 0xf4,
+ 0x80, 0x29, 0xe4, 0x93, 0xa3, 0xf8, 0x54, 0x07, 0x24, 0x0c, 0xc8, 0xc3, 0x33, 0xc4, 0x54, 0x0f,
+ 0x44, 0x20, 0xc8, 0x83, 0x40, 0x04, 0xf4, 0x56, 0x80, 0x01, 0x46, 0xf6, 0xdf, 0xe4, 0x80, 0x0b,
+ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x90, 0x0d, 0xbb, 0xe4, 0x7e, 0x01, 0x93, 0x60,
+ 0xbc, 0xa3, 0xff, 0x54, 0x3f, 0x30, 0xe5, 0x09, 0x54, 0x1f, 0xfe, 0xe4, 0x93, 0xa3, 0x60, 0x01,
+ 0x0e, 0xcf, 0x54, 0xc0, 0x25, 0xe0, 0x60, 0xa8, 0x40, 0xb8, 0xe4, 0x93, 0xa3, 0xfa, 0xe4, 0x93,
+ 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xf0, 0xa3, 0xc8,
+ 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xdf, 0xe9, 0xde, 0xe7, 0x80, 0xbe, 0x00, 0x00, 0x00,
+ 0x24, 0x00, 0x80, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72, 0x65, 0x73, 0x73,
+ 0x00, 0x41, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x53, 0x44, 0x20, 0x43, 0x61, 0x72, 0x64,
+ 0x00, 0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0x4a, 0x00, 0x00, 0xe3,
+ 0x4b, 0x00, 0x00, 0xe3, 0x4c, 0x00, 0x00, 0xe3, 0x4d, 0xe3, 0x4e, 0xe3, 0x4f, 0xe3, 0x38, 0xe3,
+ 0x39, 0xe3, 0x3a, 0xe3, 0x3b, 0xe4, 0xf5, 0x34, 0xef, 0x70, 0x12, 0xe5, 0x14, 0xc3, 0x94, 0x04,
+ 0x40, 0x54, 0x12, 0x50, 0xc5, 0x75, 0x14, 0x03, 0x12, 0x57, 0x67, 0x80, 0x49, 0xe5, 0x14, 0x24,
+ 0xfd, 0x60, 0x0c, 0x24, 0xfe, 0x60, 0x03, 0x04, 0x70, 0x39, 0x75, 0x34, 0x10, 0x80, 0x37, 0x90,
+ 0xe2, 0xa6, 0x74, 0x30, 0xf0, 0x74, 0x10, 0x12, 0x56, 0xbb, 0xf0, 0x78, 0x5d, 0x74, 0xff, 0xf2,
+ 0x53, 0x91, 0xef, 0x78, 0x5c, 0x74, 0x3b, 0xf2, 0x12, 0x50, 0xe1, 0x75, 0x14, 0x04, 0x90, 0x00,
+ 0xb9, 0xe0, 0x60, 0x03, 0x12, 0x41, 0xe3, 0x7f, 0x02, 0x12, 0x36, 0xf2, 0x78, 0x5e, 0x74, 0x1b,
+ 0xf2, 0x80, 0x03, 0x75, 0x34, 0x1b, 0xaf, 0x34, 0x22, 0xe4, 0xf5, 0x30, 0x90, 0x04, 0x81, 0xf0,
+ 0x53, 0x21, 0xf7, 0x90, 0x04, 0x77, 0xe0, 0x12, 0x0d, 0x2b, 0x12, 0x34, 0x00, 0x12, 0x39, 0x01,
+ 0x12, 0x3e, 0x02, 0x12, 0x4d, 0x04, 0x12, 0x81, 0x05, 0x12, 0x84, 0x06, 0x12, 0xaa, 0x07, 0x12,
+ 0xc5, 0x08, 0x12, 0xcc, 0x09, 0x13, 0x43, 0x0a, 0x12, 0xb1, 0x0d, 0x12, 0xbd, 0x0e, 0x14, 0x5d,
+ 0x13, 0x12, 0xdc, 0x14, 0x12, 0xef, 0x15, 0x14, 0x85, 0x17, 0x13, 0xf5, 0xa7, 0x13, 0xfc, 0xa8,
+ 0x00, 0x00, 0x14, 0xa9, 0x12, 0x3f, 0xfe, 0x61, 0x3f, 0x12, 0x30, 0xff, 0x61, 0x3f, 0x91, 0xb1,
+ 0xff, 0x31, 0x85, 0x91, 0xaf, 0x60, 0x02, 0x41, 0xeb, 0xf5, 0x5c, 0x41, 0xeb, 0x12, 0x0f, 0xf8,
+ 0xff, 0x24, 0x07, 0xf1, 0xa6, 0xe0, 0x90, 0x00, 0xb6, 0xf0, 0x8f, 0x82, 0x8e, 0x83, 0xe0, 0x90,
+ 0x04, 0xc2, 0xf0, 0x12, 0x3b, 0x02, 0xa3, 0xe0, 0xff, 0x90, 0x04, 0xc3, 0xf0, 0x12, 0x57, 0x05,
+ 0xf1, 0xd7, 0xe0, 0x24, 0x05, 0xf5, 0x82, 0xe4, 0x3a, 0xf5, 0x83, 0xe0, 0xfb, 0xf1, 0xf7, 0x80,
+ 0x47, 0x02, 0x28, 0x02, 0xf1, 0xc3, 0xa3, 0xa3, 0xa3, 0xe0, 0x60, 0x14, 0x8f, 0x82, 0x8e, 0x83,
+ 0xa3, 0xe0, 0xff, 0x12, 0x35, 0xed, 0x91, 0xaf, 0x54, 0x0f, 0x70, 0x0c, 0xc2, 0x25, 0x80, 0x08,
+ 0x91, 0xb1, 0xff, 0x12, 0x36, 0x3f, 0x8f, 0x30, 0x80, 0x41, 0x91, 0xb1, 0xff, 0x7d, 0x02, 0x80,
+ 0x11, 0x12, 0x3b, 0x02, 0xa3, 0xe0, 0xff, 0x12, 0x57, 0x05, 0x02, 0x30, 0x04, 0x91, 0xb1, 0xff,
+ 0x7d, 0x04, 0x02, 0x37, 0xfd, 0x12, 0x38, 0x64, 0x8f, 0x30, 0x80, 0x1f, 0x91, 0xb1, 0xff, 0x12,
+ 0x39, 0xde, 0x8f, 0x30, 0xe5, 0x30, 0x70, 0x02, 0x81, 0xae, 0x80, 0x64, 0x90, 0x00, 0xae, 0xe0,
+ 0xb4, 0x02, 0x05, 0x75, 0x30, 0x18, 0x80, 0x03, 0x12, 0x18, 0x87, 0xad, 0x30, 0x81, 0xa4, 0xf1,
+ 0xd7, 0xe0, 0xfb, 0xf5, 0x82, 0x8a, 0x83, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xf3, 0x12, 0x0c, 0xd9,
+ 0xeb, 0x24, 0x04, 0xf5, 0x82, 0xe4, 0x3a, 0xf5, 0x83, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xf7, 0x12,
+ 0x0c, 0xd9, 0xe4, 0xff, 0xfe, 0xfd, 0xfc, 0x90, 0x00, 0xf7, 0xf1, 0x4c, 0x70, 0x0b, 0x90, 0x00,
+ 0xf3, 0xf1, 0x48, 0x70, 0x04, 0xc2, 0x21, 0x80, 0x02, 0xd2, 0x21, 0x90, 0x00, 0xeb, 0x12, 0x0c,
+ 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4,
+ 0xfd, 0x81, 0xa4, 0xe4, 0xf5, 0x31, 0xf5, 0x32, 0x75, 0x33, 0x02, 0x12, 0x39, 0xd6, 0xfd, 0xec,
+ 0xf5, 0x9d, 0xed, 0xf5, 0x9e, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe6, 0x10, 0xf0, 0xe4, 0x90, 0xe6,
+ 0x8d, 0xf0, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe6, 0x11, 0xf0, 0x00, 0x00, 0x00, 0xe4, 0xf5, 0x32,
+ 0x90, 0xe6, 0x7c, 0xe0, 0xf5, 0x31, 0xe5, 0x32, 0x25, 0xe0, 0x24, 0xf0, 0xf5, 0x82, 0xe4, 0x34,
+ 0x0f, 0x12, 0x36, 0xd0, 0xe5, 0x31, 0xf0, 0x00, 0x00, 0x00, 0x05, 0x33, 0x05, 0x33, 0x05, 0x32,
+ 0xe5, 0x32, 0xb4, 0x04, 0xdb, 0x12, 0x30, 0xc6, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4a, 0xf0,
+ 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4b, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3,
+ 0x4c, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4d, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0,
+ 0x90, 0xe3, 0x4e, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4f, 0xf0, 0x00, 0x90, 0xe6,
+ 0x7c, 0xe0, 0x90, 0xe3, 0x38, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x39, 0xf0, 0x00,
+ 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x3a, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x3b,
+ 0xf0, 0xe4, 0xfd, 0x81, 0xa4, 0xe4, 0x90, 0x00, 0xfd, 0xf0, 0x80, 0x5c, 0x75, 0x31, 0x0f, 0x75,
+ 0x32, 0xe5, 0x90, 0x00, 0x86, 0xe0, 0x12, 0x45, 0x93, 0x24, 0xff, 0x92, 0x14, 0x91, 0xc2, 0x74,
+ 0x0f, 0xf0, 0xf1, 0xc3, 0xa3, 0xa3, 0xa3, 0xf1, 0xad, 0x05, 0x32, 0xe5, 0x32, 0x70, 0x02, 0x05,
+ 0x31, 0xef, 0xf1, 0xa4, 0xf1, 0xad, 0x05, 0x32, 0xe5, 0x32, 0x70, 0x02, 0x05, 0x31, 0x12, 0x0f,
+ 0xf8, 0xff, 0x24, 0x05, 0xf1, 0xa6, 0xf1, 0xad, 0xf1, 0xd0, 0xe0, 0x60, 0x0c, 0x30, 0x14, 0x06,
+ 0xc2, 0x1b, 0xf1, 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0xe4, 0x90, 0x00, 0xfd, 0xf0, 0x12, 0x0f,
+ 0xf8, 0xf5, 0x82, 0x8e, 0x83, 0xa3, 0xa3, 0xe0, 0xf5, 0x5b, 0x02, 0x45, 0x15, 0xe4, 0xf5, 0x31,
+ 0x90, 0x00, 0xb0, 0xe0, 0x30, 0xe1, 0x17, 0x90, 0xe6, 0x80, 0xe0, 0x44, 0x01, 0xf0, 0x7f, 0x0a,
+ 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x90, 0xe6, 0x80, 0xe0, 0x54, 0xfe, 0xf0, 0x80, 0x03, 0x75, 0x31,
+ 0x3e, 0xad, 0x31, 0x80, 0x1f, 0x75, 0x31, 0x0b, 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x14, 0xe4, 0xf5,
+ 0x31, 0xf1, 0xc3, 0xa3, 0xa3, 0xe0, 0x24, 0xff, 0x92, 0x1d, 0xf1, 0xd0, 0xa3, 0xe0, 0x24, 0xff,
+ 0x92, 0x1c, 0xad, 0x31, 0x7f, 0x03, 0x02, 0x2a, 0xeb, 0x7f, 0x03, 0x12, 0x2d, 0x18, 0x22, 0x8f,
+ 0x30, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0xf5, 0x82, 0x8e, 0x83, 0xa3, 0xe0, 0x22, 0x75,
+ 0x19, 0x8c, 0x90, 0x04, 0xbe, 0xe0, 0x24, 0xb3, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22,
+ 0x8f, 0x26, 0xa2, 0x11, 0xb3, 0x92, 0x12, 0x90, 0x00, 0x89, 0xe0, 0xf5, 0x27, 0xe4, 0x90, 0x04,
+ 0xb6, 0xf1, 0x48, 0xc3, 0x60, 0x01, 0xd3, 0x92, 0x13, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0xff,
+ 0xe5, 0x26, 0xd3, 0x9f, 0x40, 0x02, 0xe1, 0x2e, 0xaf, 0x26, 0x12, 0x51, 0x14, 0x8f, 0x29, 0x12,
+ 0x2e, 0xfe, 0xf5, 0x2a, 0x30, 0x2a, 0x24, 0x90, 0x04, 0xbe, 0xe0, 0xb5, 0x26, 0x1a, 0xe5, 0x27,
+ 0xb4, 0x2a, 0x15, 0x90, 0x00, 0x8b, 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x2c, 0xf1, 0x4c, 0x70, 0x08,
+ 0x90, 0x00, 0x91, 0xe0, 0x64, 0x80, 0x60, 0x03, 0x12, 0x1f, 0xb9, 0x90, 0x04, 0xbe, 0xe5, 0x26,
+ 0xf0, 0x91, 0xc6, 0xe0, 0xf5, 0x2b, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0xe4, 0xf0, 0xe5, 0x27,
+ 0x12, 0x0d, 0x2b, 0x15, 0xed, 0x00, 0x16, 0x1d, 0x03, 0x15, 0xb3, 0x12, 0x16, 0xdf, 0x15, 0x16,
+ 0xb2, 0x1a, 0x16, 0x73, 0x1b, 0x16, 0x9b, 0x1e, 0x15, 0xc2, 0x23, 0x15, 0xc2, 0x25, 0x15, 0x7a,
+ 0x28, 0x15, 0x8f, 0x2a, 0x16, 0x1a, 0x2f, 0x16, 0xdf, 0x35, 0x16, 0xdf, 0x55, 0x16, 0xdf, 0x5a,
+ 0x16, 0xdf, 0xa8, 0x16, 0xdf, 0xaa, 0x00, 0x00, 0x16, 0xf9, 0xaf, 0x2a, 0x12, 0x50, 0xee, 0x50,
+ 0x02, 0xe1, 0x2e, 0x30, 0x13, 0x05, 0x20, 0x11, 0x02, 0xe1, 0x2e, 0xd2, 0x14, 0x80, 0x13, 0xaf,
+ 0x2a, 0x12, 0x50, 0xee, 0x50, 0x02, 0xe1, 0x2e, 0x30, 0x13, 0x05, 0x30, 0x11, 0x02, 0xe1, 0x2e,
+ 0xc2, 0x14, 0x75, 0x2f, 0x01, 0x75, 0x30, 0x00, 0x75, 0x31, 0x8b, 0xaf, 0x29, 0x12, 0x49, 0x4f,
+ 0x8f, 0x28, 0x22, 0x20, 0x13, 0x02, 0xe1, 0x2e, 0xf1, 0xee, 0x12, 0x3a, 0x86, 0x8f, 0x28, 0x7f,
+ 0x00, 0x22, 0xe5, 0x27, 0x7f, 0x08, 0xb4, 0x23, 0x02, 0x7f, 0x0c, 0x8f, 0x2c, 0x20, 0x13, 0x02,
+ 0xe1, 0x2e, 0xad, 0x27, 0xaf, 0x29, 0x12, 0x4d, 0x8e, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x0a, 0x74,
+ 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xc1, 0xcb, 0xaf, 0x2c, 0xc1, 0x6f, 0x30, 0x13, 0x02,
+ 0xe1, 0x2e, 0xaf, 0x29, 0x12, 0x4e, 0x1d, 0x8f, 0x28, 0xe5, 0x2b, 0xb4, 0x0a, 0x0c, 0x74, 0xb3,
+ 0x25, 0x26, 0x91, 0xc8, 0xe5, 0x2b, 0xf0, 0x7f, 0x84, 0x22, 0xe5, 0x28, 0x60, 0x09, 0x74, 0xb3,
+ 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xe5, 0x2b, 0x75,
+ 0xf0, 0x03, 0xa4, 0x24, 0xb8, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0xaf, 0x82, 0xf5, 0x2c, 0x8f, 0x2d,
+ 0x20, 0x13, 0x02, 0xe1, 0x2e, 0x12, 0x47, 0x5a, 0x7b, 0x12, 0x12, 0x37, 0x2f, 0x7a, 0xf8, 0x79,
+ 0x00, 0x12, 0x47, 0x27, 0x78, 0x7c, 0x74, 0x70, 0xf2, 0xe4, 0xf2, 0x12, 0x56, 0xfa, 0xe5, 0x2d,
+ 0x70, 0x02, 0x05, 0x2c, 0x75, 0x9e, 0x07, 0x74, 0x0a, 0xf2, 0x75, 0x9e, 0x0c, 0x12, 0x56, 0xfa,
+ 0xe5, 0x2d, 0x70, 0x02, 0x05, 0x2c, 0xf5, 0x82, 0x85, 0x2c, 0x83, 0xe0, 0xf2, 0x7f, 0x12, 0x7e,
+ 0x00, 0x80, 0x66, 0xf1, 0xde, 0x12, 0x3b, 0xfe, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x1a, 0xb4, 0x9b,
+ 0x0b, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x0c, 0xf0, 0x80, 0x09, 0x74, 0xb3, 0x25, 0x26,
+ 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xf1, 0xde, 0x12, 0x4e, 0x58,
+ 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x09, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf,
+ 0x28, 0x22, 0xf1, 0xee, 0x12, 0x47, 0x68, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x18, 0x7f, 0x02, 0xb4,
+ 0x8f, 0x02, 0x7f, 0x0e, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0xef, 0xf0, 0xa2, 0x12, 0x92, 0x1b,
+ 0xf1, 0x53, 0xaf, 0x28, 0x22, 0xaf, 0x9e, 0x7e, 0x00, 0x12, 0x3b, 0x53, 0x7f, 0x00, 0x22, 0x74,
+ 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x07, 0xf0, 0x30, 0x11, 0x08, 0xa2, 0x12, 0x92, 0x1b, 0xf1,
+ 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0x7f, 0x86, 0x22, 0x74, 0x43, 0x12, 0x56, 0xe8, 0xe5, 0x2a,
+ 0xb4, 0x01, 0x04, 0x7f, 0x00, 0x80, 0x05, 0x90, 0x04, 0x37, 0xe0, 0xff, 0x90, 0x04, 0x85, 0xef,
+ 0xf0, 0xe4, 0x90, 0x04, 0x86, 0xf0, 0x90, 0x00, 0x87, 0xf0, 0xa3, 0xe0, 0x24, 0x04, 0xff, 0x7b,
+ 0x01, 0x7a, 0x00, 0x79, 0x87, 0x12, 0x2d, 0x51, 0x12, 0x3b, 0xf6, 0x7f, 0x00, 0x22, 0x30, 0x11,
+ 0x08, 0xa2, 0x12, 0x92, 0x1b, 0xf1, 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0x74, 0xb3, 0x25, 0x26,
+ 0x91, 0xc8, 0x74, 0x09, 0xf0, 0x7f, 0x98, 0x22, 0xff, 0xfe, 0xfd, 0xfc, 0x12, 0x0c, 0xad, 0xc3,
+ 0x02, 0x0c, 0x30, 0x90, 0x00, 0xad, 0xe0, 0x60, 0x14, 0x12, 0x4d, 0x13, 0x60, 0x0f, 0x20, 0x1b,
+ 0x0a, 0xf1, 0xb6, 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0x00, 0xa3, 0xf0, 0xf1, 0xe6, 0x22, 0xe4, 0xfe,
+ 0x7d, 0x02, 0xef, 0x5d, 0x90, 0x00, 0xb9, 0xf0, 0x90, 0xe6, 0x12, 0x70, 0x0b, 0x74, 0x22, 0xf0,
+ 0x90, 0xe6, 0x14, 0x74, 0x62, 0xf0, 0x80, 0x09, 0x74, 0xa2, 0xf0, 0x90, 0xe6, 0x14, 0x74, 0xe2,
+ 0xf0, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe1, 0x01, 0x0e, 0x30, 0x1c, 0x04, 0x30, 0x1d, 0x01, 0x0e,
+ 0xee, 0x14, 0xff, 0x22, 0x24, 0x04, 0xf5, 0x82, 0xe4, 0x3e, 0xf5, 0x83, 0x22, 0xe0, 0x85, 0x32,
+ 0x82, 0x85, 0x31, 0x83, 0xf0, 0x22, 0xe5, 0x14, 0xb4, 0x05, 0x07, 0x90, 0xe6, 0xa5, 0xe0, 0x30,
+ 0xe2, 0xf9, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xf5, 0x82, 0x8e, 0x83, 0x22,
+ 0x8f, 0x82, 0x8e, 0x83, 0xa3, 0xa3, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfa, 0xa3, 0x22, 0x90, 0x00,
+ 0x8d, 0xe0, 0xfd, 0xaf, 0x29, 0x22, 0xf1, 0xb6, 0x78, 0xa5, 0x74, 0x01, 0xf2, 0x22, 0x7b, 0x01,
+ 0x7a, 0x00, 0x79, 0x8a, 0xaf, 0x29, 0x22, 0x8d, 0x34, 0xac, 0x03, 0xe4, 0xfe, 0xf1, 0x6e, 0xae,
+ 0x07, 0x90, 0x00, 0xb9, 0xe0, 0x90, 0x00, 0xac, 0x60, 0x1e, 0xe0, 0x44, 0x80, 0xff, 0xf0, 0xec,
+ 0x54, 0x1f, 0x25, 0xe0, 0x25, 0xe0, 0xfd, 0xef, 0x54, 0x83, 0x4d, 0xff, 0xf0, 0xee, 0x54, 0x03,
+ 0xfe, 0xef, 0x54, 0xfc, 0x4e, 0xf0, 0x80, 0x03, 0x74, 0x7c, 0xf0, 0x90, 0x00, 0x74, 0x11, 0x5e,
+ 0x89, 0x82, 0xf5, 0x83, 0xec, 0xf0, 0x90, 0x00, 0x76, 0x11, 0x5e, 0xf5, 0x83, 0x89, 0x82, 0xec,
+ 0xf0, 0xe5, 0x34, 0x70, 0x0b, 0x75, 0x14, 0x03, 0x90, 0x00, 0xae, 0x74, 0x02, 0xf0, 0x80, 0x0b,
+ 0x75, 0x14, 0x03, 0x90, 0x00, 0xae, 0x74, 0x01, 0x11, 0x68, 0xf0, 0x7f, 0x00, 0x22, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0x24, 0x02, 0xf9, 0xe4, 0x3e, 0x22, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xff, 0xa3, 0xe0,
+ 0x90, 0x00, 0x6c, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0x90,
+ 0x00, 0x6e, 0xcf, 0xf0, 0xa3, 0xef, 0x22, 0x90, 0x00, 0x66, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x22,
+ 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x44, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x64,
+ 0xf0, 0x90, 0x00, 0x74, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x2b, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3,
+ 0x74, 0x4d, 0x11, 0x68, 0xf0, 0x74, 0x00, 0x24, 0x02, 0xff, 0xe4, 0x90, 0x00, 0x62, 0x12, 0x57,
+ 0x6f, 0x7c, 0x10, 0x7d, 0x02, 0x7b, 0x12, 0x7a, 0x00, 0x31, 0x58, 0x74, 0x00, 0x24, 0x22, 0xff,
+ 0xe4, 0x90, 0x00, 0x64, 0x12, 0x57, 0x6f, 0x7c, 0x10, 0x7d, 0x16, 0x7b, 0x0a, 0x7a, 0x00, 0x31,
+ 0x58, 0x7c, 0x01, 0x7d, 0x00, 0xed, 0x24, 0x42, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x72, 0xf0, 0xa3,
+ 0xce, 0xf0, 0xed, 0x24, 0xc2, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x70, 0xf0, 0xa3, 0xce, 0xf0, 0x74,
+ 0x00, 0x24, 0x42, 0xfe, 0x74, 0x01, 0x34, 0x01, 0x90, 0x00, 0x78, 0xf0, 0xa3, 0xce, 0xf0, 0x90,
+ 0x00, 0x6a, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xac, 0x06, 0x90, 0x00, 0x99, 0xec, 0x31, 0x46, 0xfb,
+ 0x7a, 0x00, 0xed, 0x2b, 0x90, 0x00, 0x9b, 0x31, 0x3f, 0x2d, 0x90, 0x00, 0x9d, 0x31, 0x3f, 0x2d,
+ 0xfe, 0xea, 0x3c, 0x90, 0x00, 0x9f, 0xf0, 0xa3, 0xce, 0x12, 0x2f, 0x81, 0x02, 0x2f, 0x87, 0xff,
+ 0xea, 0x3c, 0xfe, 0xad, 0x07, 0xfc, 0xf0, 0xa3, 0xed, 0xf0, 0xf5, 0x82, 0x8e, 0x83, 0xe0, 0x22,
+ 0x7b, 0x11, 0x7c, 0xe2, 0x7d, 0x08, 0x7a, 0x00, 0x8e, 0x54, 0x8f, 0x55, 0x8c, 0x56, 0x8d, 0x57,
+ 0x8a, 0x58, 0x8b, 0x59, 0x12, 0x57, 0x34, 0x12, 0x0e, 0xb8, 0xe5, 0x54, 0xf5, 0x9a, 0xe5, 0x55,
+ 0xf5, 0x9b, 0xe5, 0x56, 0xf5, 0x9d, 0xe5, 0x57, 0xf5, 0x9e, 0xe5, 0x59, 0x15, 0x59, 0xae, 0x58,
+ 0x70, 0x02, 0x15, 0x58, 0x4e, 0x60, 0x08, 0x78, 0x7c, 0xe2, 0x78, 0x7b, 0xf2, 0x80, 0xeb, 0x12,
+ 0x0e, 0xe6, 0x12, 0x0e, 0xcf, 0x85, 0x5a, 0xe8, 0x22, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0,
+ 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04,
+ 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x75, 0x53, 0x00, 0x53, 0x91, 0xdf, 0xc2, 0x2c, 0xc2, 0x2d,
+ 0x90, 0xe2, 0x6f, 0xe0, 0x90, 0x04, 0x6e, 0xf0, 0x90, 0xe2, 0x6e, 0xe0, 0x90, 0x04, 0x6f, 0xf0,
+ 0x90, 0xe2, 0x71, 0xe0, 0x90, 0x04, 0x70, 0xf0, 0x90, 0xe2, 0x70, 0xe0, 0x90, 0x04, 0x71, 0xf0,
+ 0x90, 0xe2, 0x73, 0xe0, 0x90, 0x04, 0x72, 0xf0, 0x90, 0xe2, 0x72, 0xe0, 0x90, 0x04, 0x73, 0xf0,
+ 0x90, 0xe2, 0x6d, 0xe0, 0x90, 0x04, 0x6c, 0xf0, 0x90, 0xe2, 0x6c, 0xe0, 0x90, 0x04, 0x6d, 0xf0,
+ 0x90, 0x04, 0x6c, 0xe0, 0xff, 0x54, 0x0f, 0xf5, 0x51, 0xa3, 0xe0, 0xf5, 0x52, 0xef, 0x20, 0xe6,
+ 0x61, 0xe5, 0x52, 0x70, 0x5a, 0xaf, 0x51, 0x04, 0xa8, 0x07, 0x08, 0x80, 0x02, 0xc3, 0x33, 0xd8,
+ 0xfc, 0xff, 0x90, 0x00, 0xfd, 0xe0, 0xfe, 0x5f, 0x70, 0x02, 0x81, 0xdd, 0xee, 0x6f, 0xf0, 0xe5,
+ 0x51, 0x64, 0x03, 0x60, 0x02, 0x81, 0xdd, 0xe0, 0x30, 0xe2, 0x17, 0x90, 0x04, 0x6c, 0xe0, 0x30,
+ 0xe4, 0x10, 0x12, 0x3b, 0x0f, 0x75, 0x5b, 0x00, 0x12, 0x45, 0x15, 0x90, 0x00, 0xfd, 0xe0, 0x54,
+ 0xfb, 0xf0, 0x20, 0x26, 0x02, 0x81, 0xdd, 0x12, 0x57, 0x4f, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x8b,
+ 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0xb5, 0xf0, 0xd2, 0xe8, 0xc2, 0x26, 0x81, 0xdd, 0x43,
+ 0x52, 0x80, 0xb1, 0x0e, 0xe0, 0xfc, 0x70, 0x6c, 0x12, 0x57, 0x2a, 0xf5, 0x83, 0xe5, 0x52, 0xf0,
+ 0x90, 0x04, 0x6c, 0xe0, 0x30, 0xe7, 0x44, 0x91, 0xf8, 0xe0, 0xfd, 0xb1, 0x3d, 0xb1, 0x0e, 0xe0,
+ 0x24, 0x06, 0xf0, 0xb1, 0x0e, 0xb1, 0x1a, 0xef, 0xf0, 0xe5, 0x51, 0xb4, 0x03, 0x1d, 0xe5, 0x52,
+ 0xb4, 0x0c, 0x04, 0xd2, 0x2d, 0x80, 0x16, 0xe5, 0x52, 0xb4, 0x0f, 0x0b, 0xc2, 0x25, 0x90, 0xe6,
+ 0xa0, 0xe0, 0x44, 0x80, 0xf0, 0x81, 0xce, 0xd2, 0x2c, 0x80, 0x02, 0xd2, 0x2c, 0xe5, 0x51, 0x70,
+ 0x73, 0xe5, 0x52, 0x64, 0x11, 0x70, 0x6d, 0xd2, 0x22, 0x80, 0x69, 0x90, 0x04, 0x6f, 0xe0, 0x25,
+ 0xe0, 0xb1, 0x1b, 0xef, 0xf0, 0x91, 0xf8, 0xe0, 0xfd, 0x12, 0x51, 0x71, 0xb1, 0x0e, 0xe0, 0x24,
+ 0x04, 0xf0, 0x80, 0x50, 0x12, 0x57, 0x2a, 0xf5, 0x83, 0xe0, 0x65, 0x52, 0x60, 0x02, 0x80, 0x2a,
+ 0xe5, 0x51, 0x25, 0xe0, 0x24, 0x89, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x12, 0x3a, 0x7c,
+ 0xad, 0x04, 0xb1, 0x3d, 0xb1, 0x0e, 0xe0, 0x24, 0x06, 0xf0, 0x90, 0x04, 0x6c, 0xe0, 0x30, 0xe7,
+ 0x23, 0xb1, 0x0e, 0xb1, 0x1a, 0xe0, 0xd3, 0x9f, 0x40, 0x0a, 0xb1, 0x1c, 0xe4, 0xf0, 0xb1, 0x0e,
+ 0xe4, 0xf0, 0x80, 0x10, 0xe5, 0x51, 0xb4, 0x03, 0x09, 0xe5, 0x52, 0xb4, 0x0c, 0x04, 0xd2, 0x2d,
+ 0x80, 0x02, 0xd2, 0x2c, 0x30, 0x2c, 0x41, 0xe5, 0x52, 0x64, 0xa7, 0x70, 0x26, 0x12, 0x47, 0x5a,
+ 0x7e, 0xf8, 0x7f, 0x00, 0x12, 0x17, 0xd7, 0xe0, 0xfb, 0x24, 0x02, 0xfd, 0xe4, 0x3a, 0xfc, 0x8b,
+ 0x82, 0x8a, 0x83, 0xa3, 0xe0, 0xfb, 0x7a, 0x00, 0x31, 0x58, 0x12, 0x14, 0xb1, 0xff, 0x7e, 0x00,
+ 0x12, 0x3b, 0x53, 0x74, 0x01, 0x7e, 0x00, 0xa8, 0x51, 0x08, 0x80, 0x05, 0xc3, 0x33, 0xce, 0x33,
+ 0xce, 0xd8, 0xf9, 0x42, 0x21, 0xee, 0x42, 0x20, 0x20, 0x2d, 0x02, 0x81, 0xdd, 0x12, 0x17, 0xc3,
+ 0xe0, 0xc4, 0x13, 0x54, 0x01, 0xfd, 0x90, 0x04, 0xaf, 0xf0, 0x8f, 0x82, 0x8e, 0x83, 0xa3, 0xe0,
+ 0x90, 0x04, 0xb0, 0xf0, 0xed, 0x60, 0x22, 0x90, 0xe6, 0xa2, 0xe0, 0x30, 0xe1, 0x05, 0x75, 0x53,
+ 0x04, 0x81, 0xce, 0x7e, 0xe7, 0x7f, 0xc0, 0xb1, 0x2f, 0xfc, 0x90, 0x04, 0xb0, 0xe0, 0xfb, 0x7a,
+ 0x00, 0xb1, 0x28, 0x90, 0xe6, 0x8f, 0xf0, 0x81, 0xce, 0x90, 0xe6, 0xbf, 0xe0, 0xfe, 0x90, 0xe6,
+ 0xbe, 0xe0, 0xfd, 0x90, 0x04, 0xab, 0x12, 0x4d, 0x0b, 0x12, 0x0f, 0xf8, 0xf5, 0x82, 0x8e, 0x83,
+ 0xe0, 0x30, 0xe4, 0x1f, 0x75, 0x1e, 0x00, 0x75, 0x1f, 0x00, 0x30, 0x24, 0x16, 0x90, 0x04, 0x87,
+ 0xa3, 0xe0, 0xff, 0x12, 0x17, 0xa4, 0xe0, 0x24, 0x17, 0xf0, 0xef, 0x24, 0x06, 0x12, 0x17, 0xa6,
+ 0xe0, 0x04, 0xf0, 0x90, 0x04, 0xab, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3, 0x95, 0x1f, 0xee, 0x95,
+ 0x1e, 0x50, 0x02, 0x81, 0x96, 0xef, 0x95, 0x1f, 0xff, 0xee, 0x95, 0x1e, 0xfe, 0xa3, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x12, 0x57, 0x5f, 0xd3, 0xef, 0x9d, 0xee, 0x9c, 0x40, 0x08, 0x90, 0x04, 0xad, 0xec,
+ 0xf0, 0xa3, 0xed, 0xf0, 0x12, 0x17, 0xc3, 0xe0, 0x30, 0xe3, 0x21, 0x30, 0x24, 0x68, 0x12, 0x57,
+ 0x5f, 0xef, 0x2d, 0xff, 0xec, 0x3e, 0xcf, 0x24, 0x02, 0xcf, 0x34, 0x00, 0xfe, 0x7b, 0x17, 0x7a,
+ 0x00, 0xad, 0x16, 0xac, 0x15, 0xb1, 0x28, 0x24, 0x17, 0xf0, 0x80, 0x4a, 0x12, 0x57, 0x4f, 0x90,
+ 0x04, 0xad, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x4a, 0x60, 0x09, 0x7e, 0xe7, 0x7f, 0x40, 0xb1, 0x2f,
+ 0xfc, 0x31, 0x58, 0x90, 0xe6, 0x8a, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0x04, 0xae, 0xe0, 0x90,
+ 0xe6, 0x8b, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0xa0, 0xe0, 0x20, 0xe1, 0xf9, 0x90, 0x04, 0xad,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0x25, 0x1f, 0xf5, 0x1f, 0xee, 0x35, 0x1e, 0xf5, 0x1e, 0x90, 0xe6, 0xb5,
+ 0xe4, 0xf0, 0xd2, 0xe8, 0x80, 0x38, 0xd3, 0x90, 0x04, 0xac, 0xe0, 0x95, 0x1f, 0x90, 0x04, 0xab,
+ 0xe0, 0x95, 0x1e, 0x40, 0x29, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x8a, 0xe4, 0xf0, 0x00, 0x00, 0x00,
+ 0x90, 0x04, 0xb0, 0xe0, 0x90, 0xe6, 0x8b, 0xf0, 0x00, 0x00, 0x00, 0xb1, 0x2f, 0xfc, 0x90, 0xe6,
+ 0xb3, 0xf0, 0xaf, 0x05, 0xef, 0xa3, 0xf0, 0x90, 0xe6, 0xa0, 0xe0, 0x20, 0xe1, 0xf9, 0xb1, 0x1c,
+ 0xe4, 0xf0, 0xb1, 0x0e, 0xe4, 0xf0, 0xad, 0x53, 0xaf, 0x51, 0x12, 0x2a, 0xeb, 0xd0, 0x07, 0xd0,
+ 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0,
+ 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xe5, 0x51, 0x25, 0xe0, 0x24, 0x89, 0xf5, 0x82,
+ 0xe4, 0x34, 0x04, 0xf5, 0x83, 0xe0, 0xfe, 0xa3, 0xe0, 0xaa, 0x06, 0xf9, 0x7b, 0x01, 0x74, 0x7e,
+ 0x25, 0x51, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0xe0, 0xff, 0x74, 0x79, 0x25, 0x51,
+ 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0x31, 0x58, 0x90, 0x04, 0xb0, 0xe0, 0x22, 0x90,
+ 0x04, 0x88, 0xe0, 0x24, 0x02, 0xfd, 0x90, 0x04, 0x87, 0xe0, 0x34, 0x00, 0x22, 0x8b, 0x54, 0x8a,
+ 0x55, 0x89, 0x56, 0x90, 0x04, 0x6e, 0xb1, 0x7c, 0x90, 0x04, 0x6f, 0xb1, 0x7c, 0xb1, 0x5b, 0x90,
+ 0x04, 0x73, 0xe0, 0x8d, 0x82, 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x90, 0x04, 0x70, 0xe0, 0xae,
+ 0x05, 0x0d, 0x8e, 0x82, 0x75, 0x83, 0x00, 0x12, 0x0b, 0x7c, 0x90, 0x04, 0x71, 0xe0, 0xae, 0x05,
+ 0x0d, 0x8e, 0x82, 0x75, 0x83, 0x00, 0x12, 0x0b, 0x7c, 0x90, 0x04, 0x72, 0xe0, 0xae, 0x05, 0x0d,
+ 0x8e, 0x82, 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x8f, 0x32, 0xe4, 0xf5, 0x33, 0x75, 0x34, 0x3f,
+ 0xf5, 0x19, 0x12, 0x53, 0xda, 0xf1, 0xf1, 0xe5, 0x32, 0xb4, 0x02, 0x0e, 0x30, 0x2b, 0x03, 0x75,
+ 0x1a, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xa4, 0x80, 0x09, 0x75, 0x1a, 0x40, 0xe4, 0xfb, 0x7d,
+ 0x26, 0x7f, 0x04, 0xd1, 0x6b, 0x12, 0x20, 0x07, 0xef, 0x60, 0x02, 0xc1, 0x6a, 0xe5, 0x32, 0xb4,
+ 0x02, 0x09, 0x90, 0xe2, 0x0a, 0xe0, 0x20, 0xe5, 0x0e, 0x80, 0x08, 0x90, 0xe2, 0x0a, 0xe0, 0x64,
+ 0xfe, 0x60, 0x04, 0x75, 0x19, 0x88, 0x22, 0xe5, 0x33, 0x70, 0x55, 0xe5, 0x34, 0x60, 0x51, 0xe5,
+ 0x32, 0x64, 0x02, 0x70, 0x20, 0xf5, 0x1a, 0xf5, 0x1b, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x12, 0x20,
+ 0x5d, 0xef, 0x70, 0x76, 0x30, 0x2b, 0x03, 0x75, 0x1a, 0x40, 0x75, 0x1b, 0x3c, 0xe4, 0xfb, 0x7d,
+ 0x26, 0x7f, 0xa4, 0x80, 0x0f, 0x75, 0x1a, 0x40, 0x75, 0x1b, 0xff, 0x75, 0x1c, 0x80, 0xe4, 0xfb,
+ 0x7d, 0x26, 0x7f, 0x04, 0xd1, 0x6b, 0x12, 0x20, 0x07, 0xef, 0x70, 0x4e, 0x90, 0xe2, 0x08, 0xe0,
+ 0x54, 0x02, 0xf5, 0x33, 0x70, 0xb1, 0x7f, 0x64, 0xfe, 0x12, 0x50, 0x6e, 0x15, 0x34, 0x80, 0xa7,
+ 0xe5, 0x33, 0x70, 0x04, 0x75, 0x19, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x45, 0x7b, 0x05, 0x31, 0x52,
+ 0x90, 0xe2, 0x08, 0xe0, 0x30, 0xe0, 0x06, 0x90, 0x04, 0x39, 0x74, 0x01, 0xf0, 0x90, 0xe2, 0x1e,
+ 0x74, 0x14, 0xf0, 0x12, 0x0e, 0x97, 0xf1, 0xf1, 0xe4, 0xfb, 0x7d, 0x7e, 0x7f, 0x08, 0x12, 0x20,
+ 0x5d, 0xef, 0x70, 0x06, 0x7e, 0x04, 0x7f, 0x4a, 0x31, 0x50, 0x22, 0xae, 0x07, 0xf1, 0xe2, 0x90,
+ 0xe2, 0x1a, 0xed, 0xf0, 0xd1, 0xe2, 0xe5, 0x1a, 0x54, 0xc0, 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03,
+ 0x4e, 0x90, 0xe2, 0x00, 0xf0, 0xd1, 0xe2, 0xe5, 0x1a, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x1b,
+ 0x90, 0xe2, 0x01, 0xf1, 0xa0, 0xe5, 0x1b, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x1c, 0xc4, 0x13,
+ 0x13, 0x54, 0x03, 0x4f, 0x90, 0xe2, 0x02, 0xf0, 0xd1, 0xe2, 0xe5, 0x1c, 0x25, 0xe0, 0x25, 0xe0,
+ 0xff, 0xe5, 0x1d, 0x90, 0xe2, 0x03, 0xf1, 0xa0, 0xe5, 0x1d, 0x25, 0xe0, 0x25, 0xe0, 0x90, 0xe2,
+ 0x04, 0xd1, 0xd1, 0xeb, 0x44, 0x01, 0x90, 0xe2, 0x21, 0xf0, 0x80, 0x16, 0x90, 0xe2, 0x00, 0x74,
+ 0x30, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x22, 0x74, 0xff, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x31, 0x74,
+ 0xff, 0xf0, 0x90, 0x00, 0xe4, 0xe0, 0xff, 0xef, 0x60, 0x04, 0x00, 0x1f, 0x80, 0xf9, 0x22, 0xc2,
+ 0x23, 0xef, 0x60, 0x1f, 0x12, 0x37, 0x8c, 0xf1, 0xa9, 0x30, 0x27, 0x0d, 0xe4, 0x90, 0xe6, 0x1b,
+ 0xf0, 0xd2, 0x23, 0x74, 0xe0, 0xf1, 0xdc, 0xf1, 0x5c, 0xf1, 0x5c, 0x90, 0xe6, 0x1a, 0x74, 0x48,
+ 0xf0, 0xe1, 0xe9, 0xe4, 0x90, 0xe6, 0x1b, 0x12, 0x25, 0xa8, 0xd1, 0xe2, 0x74, 0x88, 0xf1, 0x66,
+ 0x12, 0x27, 0xf3, 0xd1, 0xe2, 0x90, 0xe6, 0x1b, 0x74, 0x48, 0xf0, 0x22, 0x12, 0x17, 0xb6, 0x12,
+ 0x37, 0x8c, 0xf1, 0xa9, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
+ 0xf0, 0xd1, 0xe2, 0x74, 0xe2, 0xf1, 0xdc, 0x12, 0x49, 0x48, 0xd1, 0xe2, 0x90, 0xe6, 0x15, 0x74,
+ 0x62, 0xf0, 0xd1, 0xe2, 0x12, 0x56, 0xa0, 0xf1, 0xe9, 0xc2, 0x23, 0x22, 0x90, 0xe6, 0x48, 0x74,
+ 0x86, 0xf0, 0xd1, 0xe2, 0x74, 0x86, 0x90, 0xe6, 0x48, 0xf0, 0xc1, 0xe2, 0x74, 0x02, 0x12, 0x56,
+ 0xf3, 0x90, 0xe2, 0x19, 0x74, 0xa5, 0xf0, 0xd1, 0xe2, 0xf1, 0xe2, 0x90, 0xe2, 0x1e, 0x74, 0x14,
+ 0xf0, 0xd1, 0xe2, 0xe4, 0x90, 0xe2, 0x32, 0xf0, 0xd1, 0xe2, 0xe4, 0x12, 0x57, 0x46, 0x12, 0x57,
+ 0x58, 0x90, 0xe2, 0x2e, 0x74, 0x03, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x29, 0x74, 0xff, 0xf0, 0x22,
+ 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4f, 0xf0, 0xc1, 0xe2, 0xd1, 0xe2, 0xe4, 0x90, 0xe6, 0x1a, 0xf0,
+ 0xd1, 0xe2, 0x90, 0xe6, 0x04, 0x74, 0x06, 0xf0, 0x22, 0x12, 0x3c, 0x72, 0xc2, 0x2a, 0xd1, 0xcc,
+ 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0, 0xf1, 0xf1, 0x12, 0x47, 0x42, 0x12, 0x20, 0x07, 0xef, 0x60,
+ 0x03, 0xaf, 0x19, 0x22, 0xf1, 0xfe, 0xef, 0x60, 0x02, 0xaf, 0x19, 0x22, 0x90, 0xe6, 0x14, 0xf0,
+ 0xc1, 0xe2, 0xe4, 0x90, 0xe2, 0x1b, 0xf0, 0xc1, 0xe2, 0xd1, 0xe2, 0xe4, 0x90, 0xe6, 0x04, 0xf0,
+ 0x22, 0xe4, 0xf5, 0x1a, 0xf5, 0x1b, 0xf5, 0x1c, 0xf5, 0x1d, 0x22, 0xe0, 0xf5, 0x1b, 0xe4, 0xfb,
+ 0x7f, 0x34, 0x7d, 0x26, 0x12, 0x1e, 0x6b, 0x74, 0xff, 0xf5, 0x3b, 0xf5, 0x3c, 0x90, 0xe2, 0x22,
+ 0xe0, 0x54, 0x66, 0x70, 0x11, 0x12, 0x0e, 0x8d, 0xe5, 0x3c, 0x15, 0x3c, 0x70, 0x02, 0x15, 0x3b,
+ 0xe5, 0x3c, 0x45, 0x3b, 0x70, 0xe7, 0xe5, 0x19, 0x70, 0x28, 0x90, 0xe2, 0x22, 0xe0, 0x20, 0xe1,
+ 0x0d, 0x75, 0x19, 0x89, 0x12, 0x14, 0xc2, 0x74, 0x03, 0xf0, 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04,
+ 0x37, 0xe0, 0x60, 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60, 0x60, 0x06, 0x12, 0x14, 0xbf, 0x74,
+ 0x01, 0xf0, 0xaf, 0x19, 0x22, 0xe4, 0xf5, 0x1d, 0xfb, 0x7f, 0x18, 0x7d, 0x26, 0x12, 0x1e, 0x6b,
+ 0x80, 0xa5, 0x75, 0x31, 0x02, 0x7f, 0x02, 0x12, 0x1d, 0x88, 0xe5, 0x19, 0x60, 0x02, 0x21, 0xb4,
+ 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x0c, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xe2, 0x08,
+ 0xe0, 0x54, 0xfc, 0x64, 0x0c, 0x70, 0x37, 0x12, 0x57, 0x20, 0x54, 0x1f, 0x64, 0x02, 0x70, 0x2e,
+ 0x90, 0xe2, 0x08, 0x12, 0x56, 0xc7, 0xa3, 0xe0, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x33,
+ 0xf0, 0x90, 0xe2, 0x09, 0x12, 0x56, 0xc7, 0xa3, 0xe0, 0xfe, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90,
+ 0x04, 0x34, 0xf0, 0xe0, 0x70, 0x0c, 0x90, 0x04, 0x33, 0xe0, 0x70, 0x06, 0x80, 0xb2, 0x75, 0x19,
+ 0x8b, 0x22, 0x7f, 0x02, 0xd1, 0x6d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x12, 0x52, 0xea, 0x12, 0x44,
+ 0x6b, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xe2, 0x09, 0xe0, 0x30, 0xe3, 0x08, 0x90, 0x04, 0x3a, 0x74,
+ 0x01, 0xf0, 0x21, 0x9b, 0xb1, 0xb3, 0x12, 0x57, 0x19, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4,
+ 0x12, 0x57, 0x20, 0x54, 0x1f, 0x64, 0x04, 0x60, 0x04, 0x75, 0x19, 0x8a, 0x22, 0x7d, 0x08, 0x12,
+ 0x53, 0xd5, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0xcc, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x31,
+ 0xb5, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xfc, 0x00, 0xe0, 0x54, 0x0f, 0x90, 0x04, 0x35, 0xf0, 0x90,
+ 0xfc, 0x01, 0xe0, 0x30, 0xe2, 0x1c, 0x12, 0x57, 0x19, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4,
+ 0x12, 0x1f, 0xf1, 0x75, 0x1d, 0x02, 0xe4, 0x11, 0x58, 0xef, 0x70, 0x78, 0x90, 0xe2, 0x1f, 0x74,
+ 0x06, 0xf0, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0, 0x90, 0x04, 0x35, 0xe0, 0xd3, 0x94, 0x00, 0x40,
+ 0x4a, 0xe4, 0xf5, 0x1a, 0x75, 0x1b, 0xff, 0x75, 0x1c, 0xff, 0x75, 0x1d, 0xf1, 0x7d, 0x40, 0xff,
+ 0xf1, 0xcf, 0xb1, 0xac, 0xe4, 0x90, 0xfc, 0x0d, 0xf0, 0x7b, 0x04, 0x11, 0x59, 0x31, 0xb5, 0x70,
+ 0x43, 0x90, 0xfc, 0x0d, 0xe0, 0x30, 0xe1, 0x23, 0xb1, 0xac, 0xe4, 0x90, 0xfc, 0x10, 0xf0, 0x75,
+ 0x1a, 0x80, 0x7b, 0x04, 0x11, 0x59, 0x31, 0xb5, 0x70, 0x2a, 0x90, 0xfc, 0x10, 0xe0, 0x54, 0x0f,
+ 0x64, 0x01, 0x60, 0x04, 0x75, 0x19, 0x83, 0x22, 0x12, 0x52, 0xfb, 0x90, 0x04, 0x37, 0x74, 0x02,
+ 0xf0, 0x90, 0x00, 0xea, 0xe0, 0x60, 0x0d, 0xe5, 0xa0, 0x55, 0x31, 0x60, 0x07, 0x90, 0x04, 0x32,
+ 0xe0, 0x44, 0x01, 0xf0, 0x22, 0x7f, 0x10, 0x71, 0xe7, 0xef, 0x22, 0x74, 0x01, 0x12, 0x56, 0xf3,
+ 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x1e, 0x6b, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0x7f, 0x05,
+ 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x7f, 0x04, 0x12, 0x1d, 0x88, 0xe5, 0x19, 0x60, 0x02, 0x41, 0x90,
+ 0xe4, 0x90, 0x04, 0x33, 0xf0, 0xa3, 0x74, 0x03, 0xf0, 0xe4, 0xf5, 0x1a, 0x75, 0x1b, 0x03, 0xfb,
+ 0x7d, 0x26, 0x7f, 0x0c, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x41, 0x90, 0x7f, 0x04, 0xd1, 0x6d, 0xef,
+ 0x60, 0x02, 0x41, 0x90, 0x12, 0x52, 0xcf, 0x12, 0x44, 0x6b, 0x60, 0x02, 0x41, 0x90, 0x90, 0x04,
+ 0x35, 0xe0, 0xd3, 0x94, 0x03, 0x40, 0x73, 0x12, 0x53, 0x50, 0xb1, 0xac, 0xf1, 0xcb, 0xf1, 0xfa,
+ 0x7f, 0x20, 0x11, 0x5d, 0xef, 0x70, 0x69, 0x31, 0xb5, 0x70, 0x65, 0x75, 0x1a, 0x03, 0x75, 0x1b,
+ 0xb9, 0x75, 0x1c, 0x01, 0x11, 0x55, 0x90, 0xfc, 0xc4, 0xe0, 0xb4, 0x03, 0x05, 0x12, 0x52, 0xfb,
+ 0x80, 0x03, 0x12, 0x52, 0xea, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x3a, 0x90, 0xfc, 0xd7, 0xe0, 0xff,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfe, 0xd1, 0x5f, 0xef, 0xf0, 0x90, 0xfc, 0xd6, 0xe0, 0xff, 0xee, 0x12,
+ 0x4e, 0x36, 0xef, 0xf0, 0x90, 0xfc, 0xd5, 0xe0, 0xff, 0xee, 0x12, 0x4e, 0x4a, 0xef, 0xf0, 0x90,
+ 0xfc, 0xd4, 0xe0, 0xff, 0xee, 0x12, 0x4e, 0x28, 0xef, 0xf0, 0xee, 0xd1, 0x5f, 0x12, 0x56, 0x6b,
+ 0xd1, 0x5b, 0x12, 0x0c, 0xd9, 0xf1, 0xf3, 0x12, 0x0e, 0x7c, 0x90, 0x04, 0x37, 0x74, 0x04, 0xf0,
+ 0x22, 0x8f, 0x30, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x54, 0x1e, 0x60, 0x01, 0x22, 0x12, 0x52, 0xa7,
+ 0xe5, 0x30, 0x54, 0x1e, 0x70, 0x02, 0x61, 0x6e, 0x12, 0x53, 0x12, 0x12, 0x1f, 0x6c, 0xe4, 0x90,
+ 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xdc, 0xf0, 0x12, 0x47, 0xde, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0xe4, 0xf5, 0x19, 0x12, 0x1f, 0xf1, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x1e, 0x6b, 0x90, 0xe2,
+ 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0x7f, 0x05, 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x75, 0x1c, 0x01, 0x75,
+ 0x1d, 0xaa, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x20, 0x11, 0x5d, 0xe5, 0x19, 0x70, 0x18, 0x90, 0xe2,
+ 0x0b, 0xe0, 0xb4, 0x06, 0x0c, 0xa3, 0xe0, 0x54, 0xfc, 0xff, 0xbf, 0xa8, 0x04, 0xd2, 0x2b, 0x80,
+ 0x05, 0x75, 0x19, 0x9a, 0x80, 0x68, 0xe4, 0xf5, 0x19, 0x12, 0x1f, 0xf1, 0x12, 0x57, 0x19, 0x11,
+ 0x5d, 0xe5, 0x19, 0x70, 0x2c, 0x90, 0xe2, 0x08, 0xe0, 0x64, 0xdc, 0x70, 0x24, 0xe5, 0x30, 0x30,
+ 0xe1, 0x1f, 0x11, 0x62, 0x12, 0x53, 0xe1, 0xe5, 0x19, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44,
+ 0x02, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x02, 0xf0, 0x80,
+ 0x2d, 0xe5, 0x19, 0x64, 0x89, 0x70, 0x24, 0xe5, 0x30, 0x30, 0xe2, 0x1f, 0x31, 0xbb, 0x12, 0x53,
+ 0xe1, 0xe5, 0x19, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc7, 0xe0,
+ 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x04, 0xf0, 0x80, 0x03, 0xe4, 0xf5, 0x19, 0x12, 0x43,
+ 0x96, 0x70, 0x13, 0x90, 0xe6, 0x0d, 0x04, 0xf0, 0x12, 0x0e, 0x7c, 0x90, 0xe6, 0x0e, 0x74, 0x0a,
+ 0xf0, 0x12, 0x0e, 0x7c, 0x80, 0x32, 0xe4, 0xfd, 0x7f, 0x02, 0xf1, 0x84, 0xf1, 0xfa, 0x7f, 0x44,
+ 0x11, 0x5d, 0x31, 0xb5, 0x70, 0x21, 0x7f, 0x42, 0x7e, 0x57, 0x7d, 0x59, 0x7c, 0x43, 0x90, 0xfc,
+ 0x00, 0x12, 0x17, 0x4c, 0x70, 0x11, 0x7e, 0x00, 0x7f, 0xcb, 0x7c, 0xfc, 0x7d, 0x04, 0x12, 0x55,
+ 0xc3, 0x90, 0x00, 0xdc, 0x74, 0x01, 0xf0, 0x00, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x3f,
+ 0xff, 0xff, 0xb1, 0xac, 0x12, 0x56, 0x9a, 0xc2, 0x07, 0x12, 0x4d, 0x1e, 0x60, 0x04, 0x90, 0xe2,
+ 0x34, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x74, 0x02, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0xe2,
+ 0x21, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x80, 0x8f, 0x3b, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xa1, 0x8f,
+ 0x3f, 0x8e, 0x3e, 0x8d, 0x3d, 0x8c, 0x3c, 0xaf, 0x3f, 0xae, 0x3e, 0xad, 0x3d, 0xac, 0x3c, 0xec,
+ 0x4d, 0x4e, 0x4f, 0x60, 0x33, 0x20, 0x29, 0x30, 0x90, 0xe2, 0x31, 0xe0, 0x55, 0x3b, 0x70, 0x28,
+ 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x64, 0x70, 0x20, 0x20, 0x22, 0x1d, 0x12, 0x0e, 0x8d, 0xe5, 0x3f,
+ 0x24, 0xff, 0xf5, 0x3f, 0xe5, 0x3e, 0x34, 0xff, 0xf5, 0x3e, 0xe5, 0x3d, 0x34, 0xff, 0xf5, 0x3d,
+ 0xe5, 0x3c, 0x34, 0xff, 0xf5, 0x3c, 0x80, 0xbf, 0xe5, 0x19, 0x70, 0x2c, 0x90, 0xe2, 0x31, 0xe0,
+ 0x55, 0x3b, 0x70, 0x10, 0x20, 0x29, 0x0d, 0x75, 0x19, 0x89, 0x12, 0x14, 0xc2, 0x74, 0x03, 0xf0,
+ 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04, 0x37, 0xe0, 0x60, 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60,
+ 0x60, 0x06, 0x12, 0x14, 0xbf, 0x74, 0x01, 0xf0, 0xaf, 0x19, 0x22, 0x12, 0x4c, 0xf5, 0xe4, 0xf5,
+ 0x19, 0x12, 0x4c, 0xbe, 0xef, 0x60, 0x05, 0x75, 0x19, 0x0c, 0xa1, 0x86, 0x12, 0x4c, 0x1a, 0x12,
+ 0x3f, 0xdf, 0x12, 0x4d, 0x08, 0x4e, 0x70, 0x02, 0xa1, 0x86, 0x12, 0x44, 0x88, 0xe5, 0x35, 0x60,
+ 0x06, 0x20, 0x27, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x15, 0xe4, 0x30, 0x15, 0x0d, 0x12, 0x57,
+ 0x46, 0x90, 0xe2, 0x34, 0xb1, 0xa8, 0x12, 0x56, 0x9a, 0x80, 0x0a, 0x12, 0x57, 0x58, 0x90, 0xe2,
+ 0x1f, 0xe0, 0x44, 0x80, 0xf0, 0x12, 0x1e, 0xd4, 0x12, 0x4c, 0x1a, 0x12, 0x45, 0x9a, 0x30, 0x15,
+ 0x74, 0xb1, 0xac, 0xf1, 0xe1, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x02, 0xa1,
+ 0x57, 0xe5, 0x19, 0x60, 0x02, 0xa1, 0x57, 0x12, 0x47, 0xd0, 0x90, 0xe2, 0x41, 0xe0, 0x70, 0x03,
+ 0x00, 0x80, 0xf7, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x44, 0x12, 0x1e, 0x6b, 0x90, 0x04, 0x39, 0xe0,
+ 0x60, 0x0b, 0xe5, 0x1d, 0x24, 0x01, 0xf5, 0x1d, 0xe4, 0x35, 0x1c, 0x80, 0x09, 0xe4, 0x25, 0x1d,
+ 0xf5, 0x1d, 0xe5, 0x1c, 0x34, 0x02, 0xf5, 0x1c, 0xe4, 0x35, 0x1b, 0xf5, 0x1b, 0xe4, 0x35, 0x1a,
+ 0xf5, 0x1a, 0x12, 0x4c, 0xfe, 0x11, 0x07, 0x7f, 0x10, 0x71, 0xe7, 0x12, 0x41, 0xe3, 0x12, 0x49,
+ 0x13, 0xef, 0x60, 0x07, 0xe5, 0x19, 0x70, 0x03, 0x75, 0x19, 0x99, 0xf1, 0xf3, 0x00, 0xf0, 0x00,
+ 0xb1, 0xac, 0x00, 0x80, 0x90, 0xc2, 0x29, 0x90, 0x00, 0xe2, 0x12, 0x4d, 0x29, 0x7b, 0x04, 0x7d,
+ 0x26, 0x7f, 0x48, 0x11, 0x5d, 0x7f, 0x10, 0x71, 0xe7, 0x12, 0x1e, 0xcc, 0x90, 0xe2, 0x21, 0x74,
+ 0x01, 0xf0, 0x12, 0x1e, 0xe2, 0x11, 0x07, 0xc2, 0x29, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0x7f, 0xf0,
+ 0x00, 0xe4, 0x90, 0xe2, 0x33, 0xf0, 0x00, 0x90, 0xe2, 0x31, 0x74, 0xff, 0xf0, 0x00, 0x90, 0x00,
+ 0xe8, 0xe0, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0x00, 0xe5, 0x19, 0x60, 0x08, 0xb4, 0x99,
+ 0x02, 0xff, 0x22, 0x75, 0x19, 0x37, 0xe5, 0x35, 0x60, 0x1b, 0x85, 0x19, 0x5b, 0xe5, 0x19, 0x60,
+ 0x07, 0xc2, 0x1b, 0x12, 0x17, 0x53, 0x80, 0x0a, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xe5, 0x00, 0x00,
+ 0x00, 0x00, 0x12, 0x45, 0x15, 0xaf, 0x19, 0x22, 0xf0, 0x12, 0x1e, 0xe2, 0x90, 0xe6, 0x04, 0x74,
+ 0x08, 0xf0, 0x22, 0x90, 0x04, 0x65, 0xe0, 0x54, 0x01, 0xff, 0x7e, 0x01, 0x90, 0x04, 0x35, 0xe0,
+ 0xfb, 0x70, 0x17, 0xef, 0x70, 0x0a, 0x90, 0x04, 0x66, 0xe0, 0x54, 0xfe, 0xc3, 0x13, 0x04, 0xfe,
+ 0xaf, 0x06, 0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x09, 0x80, 0x46, 0xeb, 0x64, 0x01, 0x70, 0x54, 0xf5,
+ 0x32, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x11, 0x5d, 0xef, 0x70, 0x48, 0x7d, 0x40, 0x12, 0x53, 0xd5,
+ 0x7b, 0x04, 0x11, 0x00, 0xef, 0x70, 0x3c, 0x31, 0xb5, 0x70, 0x38, 0x90, 0xfc, 0x0a, 0xe0, 0xff,
+ 0xc4, 0x54, 0x0f, 0xf5, 0x32, 0xf1, 0xf3, 0xb1, 0xac, 0xe5, 0x32, 0xd3, 0x94, 0x00, 0x40, 0x19,
+ 0xe5, 0x32, 0x94, 0x0a, 0x50, 0x13, 0xe4, 0xff, 0x7e, 0x20, 0xfd, 0xfc, 0xa9, 0x32, 0xa8, 0x01,
+ 0x12, 0x0c, 0x54, 0x90, 0x04, 0x3b, 0x02, 0x0c, 0xd9, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xe5, 0x00,
+ 0x00, 0x00, 0x00, 0x22, 0x12, 0x0b, 0xe1, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed,
+ 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0xe5, 0x32, 0x2f, 0xf5, 0x32, 0xe5, 0x31, 0x3e, 0xf5,
+ 0x31, 0xe5, 0x30, 0x3d, 0xf5, 0x30, 0xe5, 0x2f, 0x3c, 0xf5, 0x2f, 0x90, 0x00, 0xdb, 0xe0, 0x25,
+ 0xe0, 0x25, 0xe0, 0x24, 0xcb, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x8f, 0x32, 0x12,
+ 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0xfb, 0x7d, 0x7e, 0x7f, 0x24, 0x11, 0x5d, 0xef, 0x60,
+ 0x03, 0x7f, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x5b, 0x12, 0x19, 0x50, 0xe5, 0x32, 0x64, 0x04, 0x60,
+ 0x05, 0xe5, 0x32, 0xb4, 0x08, 0x0a, 0x90, 0xe2, 0x09, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0x80, 0x03,
+ 0x12, 0x4c, 0x21, 0x90, 0x04, 0x35, 0xf0, 0xe5, 0x32, 0xb4, 0x02, 0x21, 0x90, 0x04, 0x35, 0xe0,
+ 0x60, 0x1b, 0x90, 0xe2, 0x10, 0x12, 0x0c, 0xa1, 0xee, 0x54, 0xfc, 0xfe, 0xe4, 0x24, 0x00, 0xff,
+ 0xee, 0x34, 0x04, 0x12, 0x4d, 0x41, 0xfc, 0x90, 0x00, 0xdb, 0xe0, 0x80, 0x6e, 0x90, 0xe2, 0x0e,
+ 0xe0, 0x54, 0x3c, 0x13, 0x13, 0x54, 0x3f, 0xfb, 0xa3, 0xe0, 0x54, 0x0f, 0xfe, 0xa3, 0xe0, 0xfd,
+ 0xed, 0xff, 0xe4, 0x8f, 0x36, 0x8e, 0x35, 0xf5, 0x34, 0xf5, 0x33, 0x90, 0xe2, 0x12, 0xe0, 0x54,
+ 0x0e, 0xc3, 0x13, 0xfa, 0xe5, 0x36, 0x24, 0x01, 0xf5, 0x36, 0xe4, 0x3e, 0xf5, 0x35, 0xe4, 0x35,
+ 0x34, 0xf5, 0x34, 0xe4, 0x35, 0x33, 0xf5, 0x33, 0x0a, 0x0a, 0xeb, 0x64, 0x09, 0x60, 0x05, 0xeb,
+ 0x24, 0xf7, 0x2a, 0xfa, 0x12, 0x3d, 0xb1, 0xac, 0x33, 0xab, 0x02, 0xa8, 0x03, 0x12, 0x0c, 0x54,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0x03,
+ 0xff, 0xbf, 0x01, 0x0c, 0xeb, 0xd1, 0x5f, 0x12, 0x56, 0x6b, 0xeb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xd1, 0x5f, 0x12, 0x56, 0x6b, 0xeb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9,
+ 0x90, 0xe2, 0x17, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0xff, 0x90, 0x04, 0x32, 0xe0, 0x54, 0xfc,
+ 0x4f, 0xf0, 0x90, 0xe2, 0x0f, 0xe0, 0x30, 0xe6, 0x18, 0x12, 0x1f, 0xf1, 0x75, 0x1a, 0x04, 0x75,
+ 0x1b, 0x04, 0xe4, 0xfb, 0xfd, 0x7f, 0x10, 0x12, 0x1e, 0x6b, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0,
+ 0xf9, 0x7f, 0x00, 0x22, 0xf1, 0xdf, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x15, 0x74, 0x62, 0xf2,
+ 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x22, 0x8f, 0x32, 0xad, 0x32, 0xe4, 0xff, 0xf1, 0xdf, 0x12, 0x1f,
+ 0xf1, 0xe4, 0xfb, 0x7f, 0x4c, 0x11, 0x02, 0xef, 0x70, 0x20, 0x90, 0xe2, 0x21, 0x74, 0x02, 0xf0,
+ 0x7f, 0x80, 0x71, 0xe7, 0xef, 0x70, 0x13, 0xad, 0x32, 0xe4, 0xff, 0xf1, 0x84, 0x7b, 0x04, 0x7f,
+ 0x38, 0x11, 0x5b, 0xef, 0x70, 0x04, 0x7f, 0x10, 0x71, 0xe7, 0x22, 0xe4, 0xfd, 0x7f, 0x02, 0xae,
+ 0x07, 0x90, 0xe2, 0x2c, 0xed, 0xf0, 0x12, 0x1e, 0xe2, 0x90, 0xe2, 0x2d, 0xee, 0xf0, 0x22, 0xf1,
+ 0xcf, 0x7d, 0x01, 0x7c, 0x00, 0x7f, 0x30, 0xab, 0x07, 0xed, 0x90, 0xe2, 0x1c, 0xf0, 0xeb, 0x4c,
+ 0xa3, 0xf0, 0x22, 0x90, 0xe6, 0x48, 0x74, 0x88, 0xf0, 0x22, 0x12, 0x1f, 0xf1, 0x7b, 0x04, 0x7d,
+ 0x26, 0x22, 0x75, 0x0d, 0x20, 0x75, 0x0c, 0x83, 0x90, 0x04, 0xc3, 0xe0, 0xf5, 0x0f, 0x90, 0x04,
+ 0xc2, 0xe0, 0xf5, 0x0e, 0x90, 0x00, 0xae, 0xe0, 0xff, 0xc3, 0x74, 0x02, 0x9f, 0xf5, 0x11, 0xe4,
+ 0xf5, 0x10, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x7c, 0x13, 0x13, 0x54, 0x3f, 0xf5, 0x13, 0x90, 0x00,
+ 0xb6, 0xe0, 0xf5, 0x12, 0x11, 0xbf, 0xd1, 0x83, 0xe5, 0x37, 0xf0, 0xa3, 0xe5, 0x36, 0xf0, 0xa3,
+ 0xe5, 0x39, 0xf0, 0xa3, 0xe5, 0x38, 0xf0, 0xa3, 0xe5, 0x3b, 0xf0, 0xa3, 0xe5, 0x3a, 0xf0, 0xe5,
+ 0x34, 0xf1, 0xce, 0xe5, 0x35, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0x90, 0x04, 0x9f, 0x30, 0x15, 0x09,
+ 0x74, 0x43, 0xf0, 0xa3, 0x74, 0x16, 0xf0, 0x80, 0x07, 0x74, 0x02, 0xf0, 0xa3, 0x74, 0x18, 0xf0,
+ 0x90, 0x04, 0x9f, 0xe0, 0xf5, 0x0c, 0xa3, 0xe0, 0xf5, 0x0d, 0xe4, 0xf5, 0x0e, 0x75, 0x0f, 0x04,
+ 0x90, 0x00, 0xeb, 0xf1, 0xea, 0xa3, 0xe0, 0xf5, 0x12, 0xa3, 0xe0, 0xf5, 0x13, 0x11, 0xbf, 0x11,
+ 0x36, 0x90, 0x04, 0x9f, 0xe0, 0x44, 0x80, 0xf5, 0x0c, 0x90, 0x00, 0xef, 0xe0, 0xf5, 0x0e, 0xa3,
+ 0xe0, 0xf5, 0x0f, 0xa3, 0xf1, 0xea, 0x11, 0xbf, 0x11, 0x36, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xe5,
+ 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x22, 0x7d,
+ 0x00, 0x7b, 0x00, 0x7e, 0x00, 0x78, 0x34, 0x7c, 0x00, 0x7a, 0x00, 0x79, 0x0c, 0x7f, 0x08, 0x02,
+ 0x0b, 0x10, 0x90, 0x04, 0x76, 0xe0, 0xf5, 0x26, 0x90, 0x03, 0x50, 0xe0, 0xff, 0xc4, 0x54, 0x0f,
+ 0xf5, 0x27, 0xef, 0x54, 0x0f, 0xf5, 0x28, 0xaf, 0x27, 0x74, 0x01, 0xa8, 0x07, 0x08, 0x80, 0x02,
+ 0xc3, 0x33, 0xd8, 0xfc, 0xf5, 0x29, 0x90, 0x03, 0x51, 0xe0, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1e,
+ 0x12, 0x4c, 0xec, 0xe5, 0x26, 0x12, 0x0d, 0x2b, 0x29, 0x39, 0x00, 0x29, 0x40, 0x01, 0x29, 0x49,
+ 0x02, 0x29, 0x60, 0x03, 0x29, 0x8a, 0x05, 0x2a, 0x47, 0x06, 0x2a, 0x4d, 0x07, 0x2a, 0x4d, 0x08,
+ 0x2a, 0x80, 0x0c, 0x2a, 0xc1, 0x0d, 0x29, 0x6b, 0x0f, 0x2a, 0x65, 0x10, 0x2a, 0x75, 0x11, 0x2a,
+ 0xde, 0x12, 0x2a, 0xc7, 0x13, 0x00, 0x00, 0x2a, 0xe2, 0x7f, 0xff, 0x12, 0x37, 0x93, 0x80, 0x05,
+ 0x7f, 0xff, 0x12, 0x43, 0x4d, 0xad, 0x07, 0x41, 0xda, 0xe4, 0xfd, 0xaf, 0x29, 0x12, 0x44, 0x03,
+ 0x8f, 0x2a, 0xd1, 0x62, 0xe5, 0x2a, 0x70, 0x02, 0x41, 0xe6, 0xad, 0x29, 0x7f, 0x0b, 0xe1, 0xa8,
+ 0x7d, 0x01, 0xaf, 0x29, 0x12, 0x44, 0x03, 0xe4, 0xff, 0xc1, 0x62, 0x75, 0x0d, 0x17, 0x75, 0x0c,
+ 0x82, 0xe4, 0xf5, 0x0f, 0x90, 0x03, 0x50, 0xe0, 0xf5, 0x0e, 0x74, 0xc5, 0x25, 0x27, 0xf1, 0x01,
+ 0xf5, 0x11, 0xe4, 0xf5, 0x10, 0x12, 0x42, 0xd4, 0x01, 0x36, 0x7e, 0x04, 0x7f, 0x97, 0x7b, 0x08,
+ 0x12, 0x37, 0x33, 0x74, 0xc5, 0x25, 0x27, 0xf1, 0x01, 0xfd, 0x60, 0x04, 0xe5, 0x28, 0x60, 0x06,
+ 0x7e, 0x00, 0x7f, 0x00, 0x80, 0x11, 0xe5, 0x27, 0x60, 0x05, 0x90, 0x00, 0xc9, 0x80, 0x03, 0x90,
+ 0x00, 0xbb, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x90, 0x04, 0x95, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x4e,
+ 0x70, 0x04, 0x7f, 0x01, 0xc1, 0x0d, 0x90, 0x04, 0x96, 0xe0, 0x90, 0x04, 0x98, 0xf0, 0x90, 0x04,
+ 0x95, 0xe0, 0x90, 0x04, 0x97, 0xf0, 0x90, 0x00, 0xdc, 0xe0, 0x90, 0x04, 0x9a, 0x60, 0x05, 0x74,
+ 0x02, 0xf0, 0x80, 0x03, 0x74, 0x01, 0xf0, 0xed, 0xb4, 0x01, 0x04, 0x7f, 0x01, 0x80, 0x16, 0x12,
+ 0x47, 0xc9, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x44, 0x80, 0xff, 0x90, 0x04, 0x3a, 0xe0,
+ 0xfe, 0x25, 0xe0, 0x4f, 0xff, 0x90, 0x04, 0x99, 0xef, 0xf0, 0x90, 0x04, 0x3b, 0xe0, 0x90, 0x04,
+ 0x9b, 0xf0, 0x90, 0x04, 0x3c, 0xe0, 0x90, 0x04, 0x9c, 0xf0, 0x90, 0x04, 0x3d, 0xe0, 0x90, 0x04,
+ 0x9d, 0xf0, 0x90, 0x04, 0x3e, 0xe0, 0x90, 0x04, 0x9e, 0xf0, 0xc2, 0xaf, 0x12, 0x47, 0x39, 0x74,
+ 0xc5, 0x25, 0x27, 0xf1, 0x01, 0x90, 0x04, 0x86, 0xf0, 0x74, 0x02, 0x12, 0x56, 0xe8, 0x7a, 0x04,
+ 0x79, 0x97, 0xf1, 0xe4, 0xd2, 0xaf, 0x22, 0x12, 0x57, 0x0f, 0x02, 0x40, 0xf0, 0x90, 0x03, 0x50,
+ 0xe0, 0xff, 0xa3, 0xe0, 0xfd, 0xf1, 0xdd, 0xe5, 0x26, 0x7e, 0x00, 0xb4, 0x07, 0x02, 0x7e, 0x01,
+ 0x8e, 0x30, 0x02, 0x3e, 0x40, 0xf1, 0xdd, 0xaf, 0x27, 0x12, 0x55, 0x23, 0x51, 0xe7, 0x90, 0x00,
+ 0xdc, 0x74, 0x01, 0xf0, 0x22, 0x12, 0x54, 0x85, 0x51, 0xe7, 0xe4, 0x90, 0x00, 0xdc, 0xf0, 0x22,
+ 0x90, 0x03, 0x53, 0xe0, 0xff, 0x54, 0x01, 0xfe, 0x74, 0xe9, 0x25, 0x27, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0xee, 0xf0, 0xe4, 0x90, 0x00, 0xe7, 0xf0, 0xa3, 0xf0, 0x90, 0x03, 0x52, 0xe0,
+ 0x60, 0x13, 0xef, 0x54, 0x02, 0xc3, 0x13, 0x90, 0x00, 0xe7, 0x60, 0x04, 0x74, 0x02, 0x80, 0x02,
+ 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x90, 0xe2, 0x34, 0xf0, 0xe4, 0xfd, 0x80,
+ 0x19, 0x12, 0x57, 0x0f, 0x02, 0x53, 0xf8, 0xe5, 0x27, 0x64, 0x01, 0x70, 0x19, 0xf1, 0xdd, 0xad,
+ 0x28, 0xaf, 0x27, 0x12, 0x3c, 0x7a, 0x8f, 0x2a, 0xad, 0x2a, 0x7f, 0x02, 0x80, 0x0d, 0xc2, 0x15,
+ 0x01, 0x5a, 0x7f, 0x02, 0xb1, 0x18, 0x22, 0xad, 0x07, 0x7f, 0x02, 0xd1, 0x83, 0xed, 0xf1, 0x81,
+ 0xef, 0x54, 0x0f, 0xd1, 0xf7, 0xe4, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xe4, 0xf5,
+ 0x26, 0x90, 0x04, 0x7e, 0xf0, 0x53, 0x21, 0xfe, 0x90, 0x04, 0x74, 0xe0, 0x12, 0x0d, 0x2b, 0x2b,
+ 0x3a, 0x00, 0x2b, 0x51, 0x04, 0x2b, 0x62, 0x05, 0x2b, 0x41, 0x06, 0x2b, 0x47, 0x07, 0x2c, 0x7a,
+ 0x08, 0x2c, 0x7f, 0x09, 0x2b, 0x76, 0x0b, 0x2b, 0xa4, 0x0c, 0x2c, 0xd3, 0x0d, 0x2c, 0xfc, 0x10,
+ 0x2d, 0x01, 0x11, 0x2d, 0x09, 0x13, 0x00, 0x00, 0x2d, 0x16, 0x7d, 0x10, 0xe4, 0xff, 0x02, 0x42,
+ 0x98, 0xe4, 0xff, 0xf1, 0x0a, 0x81, 0xfa, 0x90, 0x03, 0x41, 0xe0, 0x24, 0xff, 0x92, 0x2e, 0x81,
+ 0xfa, 0x75, 0x0c, 0x80, 0x75, 0x0d, 0x11, 0xe4, 0xf5, 0x0e, 0x12, 0x56, 0xa7, 0xe0, 0xf5, 0x0f,
+ 0x81, 0xc3, 0x90, 0x03, 0x42, 0xe0, 0xf5, 0x29, 0xa3, 0xe0, 0xf5, 0x2a, 0x12, 0x56, 0xa7, 0xe0,
+ 0x55, 0x29, 0x45, 0x2a, 0xa1, 0x10, 0x90, 0x03, 0x40, 0xe0, 0x14, 0x60, 0x0b, 0x04, 0x70, 0x13,
+ 0x53, 0xb4, 0xef, 0xe5, 0xa0, 0xc4, 0x80, 0x07, 0x53, 0xb4, 0xdf, 0xe5, 0xa0, 0xc4, 0x13, 0x54,
+ 0x01, 0xf5, 0x0f, 0xe4, 0xf5, 0x0e, 0x75, 0x0c, 0x80, 0x75, 0x0d, 0x12, 0xfd, 0xfb, 0x12, 0x57,
+ 0x3d, 0xfe, 0x81, 0xcc, 0x90, 0x03, 0x40, 0xe0, 0xff, 0xc3, 0x94, 0x02, 0x40, 0x21, 0xef, 0xd3,
+ 0x94, 0x06, 0x50, 0x1b, 0x90, 0xe2, 0xa4, 0xe0, 0x54, 0x0c, 0xff, 0xbf, 0x0c, 0x05, 0x75, 0x26,
+ 0x08, 0x80, 0x0c, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0xf0, 0x74, 0x04, 0x12, 0x47, 0x30, 0xf0, 0x90,
+ 0x03, 0x40, 0xe0, 0x12, 0x0d, 0x2b, 0x2b, 0xf2, 0x00, 0x2c, 0x03, 0x01, 0x2c, 0x11, 0x02, 0x2c,
+ 0x22, 0x03, 0x2c, 0x37, 0x04, 0x2c, 0x45, 0x05, 0x2c, 0x51, 0x06, 0x2c, 0x64, 0x07, 0x00, 0x00,
+ 0x2c, 0x76, 0x43, 0xb4, 0x10, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x54, 0xf0, 0xff, 0xe5, 0xa0, 0x54,
+ 0xef, 0x80, 0x2f, 0x43, 0xb4, 0x20, 0xf1, 0xd6, 0x54, 0xe0, 0xff, 0xe5, 0xa0, 0x54, 0xdf, 0x80,
+ 0x21, 0x43, 0xb4, 0x01, 0xe5, 0xa0, 0x54, 0xfe, 0xff, 0x90, 0x03, 0x41, 0xe0, 0x4f, 0xf5, 0xa0,
+ 0x80, 0x54, 0x43, 0xb4, 0x04, 0x90, 0x03, 0x41, 0xe0, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0xa0,
+ 0x54, 0xfb, 0x4f, 0xf5, 0xa0, 0x80, 0x3f, 0x43, 0xb2, 0x20, 0xf1, 0xd6, 0x54, 0xe0, 0xff, 0xe5,
+ 0x80, 0x54, 0xdf, 0x80, 0x1a, 0x43, 0xb2, 0x40, 0x12, 0x56, 0xc4, 0xe5, 0x80, 0x54, 0xbf, 0x80,
+ 0x0e, 0x43, 0xb2, 0x80, 0xf1, 0xd6, 0x33, 0x33, 0x54, 0x80, 0xff, 0xe5, 0x80, 0x54, 0x7f, 0x4f,
+ 0xf5, 0x80, 0x80, 0x12, 0x43, 0xb4, 0x40, 0x12, 0x56, 0xc4, 0xe5, 0xa0, 0x54, 0xbf, 0x4f, 0xf5,
+ 0xa0, 0xe4, 0x90, 0x04, 0xc4, 0xf0, 0xad, 0x26, 0x81, 0xfe, 0x12, 0x44, 0x71, 0xa1, 0x11, 0x90,
+ 0x03, 0x41, 0xe0, 0xf5, 0x27, 0x12, 0x44, 0x71, 0xe5, 0x27, 0x30, 0xe1, 0x0e, 0x53, 0xb4, 0xef,
+ 0x12, 0x0e, 0x8d, 0xe5, 0xa0, 0x20, 0xe4, 0x03, 0x43, 0x27, 0x20, 0xe4, 0x90, 0xe6, 0x74, 0xf0,
+ 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0xe6, 0x82, 0xe5, 0x27, 0xf0, 0xe4, 0xfd, 0xff, 0x51, 0xeb, 0xb1,
+ 0x38, 0x43, 0x87, 0x01, 0x00, 0x00, 0x00, 0x12, 0x42, 0x04, 0x12, 0x47, 0x1f, 0x75, 0x0c, 0xc0,
+ 0x75, 0x0d, 0x0a, 0x7d, 0x00, 0x7b, 0x00, 0x12, 0x57, 0x3d, 0x7e, 0x00, 0x7f, 0x08, 0x12, 0x0b,
+ 0x10, 0x01, 0x36, 0x90, 0x03, 0x41, 0xe0, 0x60, 0x10, 0x90, 0x03, 0x40, 0xe0, 0x90, 0x04, 0x31,
+ 0x60, 0x02, 0x80, 0x0e, 0x74, 0x0a, 0xf0, 0x80, 0x11, 0x90, 0x03, 0x40, 0xe0, 0x90, 0x04, 0x30,
+ 0x60, 0x05, 0x74, 0x14, 0xf0, 0x80, 0x03, 0x74, 0x16, 0xf0, 0x80, 0x15, 0x7d, 0x3b, 0xe4, 0x80,
+ 0x12, 0xe4, 0xfd, 0xff, 0x51, 0xeb, 0xc2, 0x22, 0x22, 0x90, 0x03, 0x41, 0xe0, 0x90, 0x00, 0xe6,
+ 0xf0, 0xe4, 0xfd, 0xff, 0x41, 0xeb, 0xe4, 0xff, 0xb1, 0x38, 0x90, 0x04, 0x6d, 0xe0, 0x90, 0xe2,
+ 0x66, 0xf0, 0x90, 0x04, 0x6c, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xe4, 0xf1, 0x85, 0xef, 0x44, 0x80,
+ 0xf1, 0xce, 0x74, 0x01, 0xf0, 0xff, 0xa1, 0xf7, 0x53, 0xe8, 0xfc, 0x90, 0xe2, 0x75, 0xe0, 0x20,
+ 0xe4, 0xf9, 0x53, 0xe8, 0xfc, 0x90, 0xe2, 0x75, 0xe0, 0x20, 0xe4, 0xf9, 0x22, 0xe2, 0xff, 0x7b,
+ 0x01, 0x8f, 0x41, 0x8b, 0x42, 0x8a, 0x43, 0x89, 0x44, 0x12, 0x0e, 0xa1, 0xaa, 0x43, 0xa9, 0x44,
+ 0xae, 0x02, 0xee, 0xf5, 0x9a, 0xaf, 0x01, 0xef, 0xf5, 0x9b, 0xe5, 0x41, 0xd3, 0x94, 0x04, 0x50,
+ 0x21, 0xb1, 0x38, 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x56,
+ 0x45, 0xd1, 0xf3, 0x90, 0x04, 0x84, 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xb1, 0xf7, 0x02,
+ 0x0e, 0xcf, 0xb1, 0x38, 0xe4, 0x90, 0xe2, 0x67, 0xf0, 0xe5, 0x41, 0x04, 0xc3, 0x13, 0x04, 0x90,
+ 0xe2, 0x66, 0xf0, 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x56,
+ 0x55, 0x90, 0x04, 0x83, 0xe0, 0x90, 0xe2, 0x65, 0xf0, 0xb1, 0xed, 0x15, 0x41, 0x15, 0x41, 0xb1,
+ 0x38, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0x7b, 0x12, 0x56, 0x45, 0xe5,
+ 0x41, 0xd3, 0x94, 0x06, 0x50, 0x05, 0xd1, 0xf3, 0x75, 0x41, 0x06, 0xb1, 0xed, 0x74, 0xfa, 0x25,
+ 0x41, 0xf5, 0x41, 0x70, 0xda, 0x12, 0x0e, 0xcf, 0xd2, 0xe8, 0xd2, 0xe9, 0x22, 0x90, 0x04, 0x84,
+ 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x00, 0x15, 0x5d, 0xa8, 0x5d, 0xa6, 0x07, 0x00, 0x00, 0x00,
+ 0x00, 0xa8, 0x5d, 0xe6, 0x60, 0x04, 0xd2, 0xe8, 0xd2, 0xe9, 0x05, 0x5d, 0x22, 0xae, 0x07, 0xd1,
+ 0x83, 0x74, 0x04, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90,
+ 0x03, 0x50, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x03, 0x53, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90,
+ 0x03, 0x52, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x74, 0x02, 0x12, 0x56, 0xd1, 0x04, 0xf0, 0x7f, 0x00,
+ 0xb1, 0xf7, 0xb1, 0x38, 0x90, 0x03, 0x55, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x54, 0xe0,
+ 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xee, 0xf0, 0xe4, 0xf1, 0x87, 0xf1, 0xfa, 0x74, 0x03, 0xf0, 0x0f,
+ 0x80, 0x95, 0xb1, 0x38, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x50, 0xe0,
+ 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0xa3, 0xf0, 0xf1, 0xfa, 0x74, 0x10, 0xf0, 0x7f,
+ 0x01, 0xa1, 0xf7, 0xb1, 0x38, 0x90, 0xe2, 0x66, 0x22, 0xd1, 0x83, 0x74, 0x05, 0xf0, 0xe4, 0xa3,
+ 0xf0, 0xa3, 0x74, 0x08, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0xe6, 0xb8, 0xe0, 0x90, 0xe2, 0x6b, 0xf0,
+ 0x90, 0xe6, 0xb9, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90, 0xe2, 0x65, 0x74, 0x43, 0xf0, 0x90, 0xe2,
+ 0x64, 0x74, 0x0c, 0xf0, 0x7f, 0x00, 0xb1, 0xf7, 0xb1, 0x38, 0x90, 0xe6, 0xba, 0xe0, 0x90, 0xe2,
+ 0x67, 0xf0, 0x90, 0xe6, 0xbb, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0xbc, 0xe0, 0x90, 0xe2,
+ 0x69, 0xf0, 0x90, 0xe6, 0xbd, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0xbe, 0xe0, 0x90, 0xe2,
+ 0x6b, 0xf0, 0x90, 0xe6, 0xbf, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x12, 0x56, 0xcf, 0x74, 0x0c, 0xf0,
+ 0x0f, 0xa1, 0xf7, 0x90, 0x04, 0x83, 0xe0, 0x44, 0x80, 0x90, 0xe2, 0x65, 0xf0, 0x22, 0x74, 0xc5,
+ 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0, 0x22, 0x8f, 0x2b, 0x75, 0x2c, 0x01, 0x12,
+ 0x42, 0x2b, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0xf5, 0x2d, 0xe4, 0xf5, 0x2e, 0x12, 0x43, 0xa0,
+ 0xf0, 0x74, 0xc5, 0x25, 0x2c, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe4, 0xf0, 0x90, 0xe2,
+ 0x24, 0xf0, 0x00, 0x12, 0x42, 0x91, 0x12, 0x0e, 0x7c, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0x7f, 0x1e,
+ 0x12, 0x3d, 0xf5, 0x12, 0x41, 0xe3, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0x65, 0x2d, 0x60, 0x30,
+ 0xe5, 0x2b, 0x60, 0x16, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0xfe, 0x45, 0x2d, 0xff, 0xe5, 0x2d,
+ 0xd3, 0x9e, 0x7d, 0x00, 0x40, 0x02, 0x7d, 0x01, 0xf1, 0x8e, 0xe5, 0x2c, 0x60, 0x07, 0x90, 0x00,
+ 0xb9, 0xe0, 0x20, 0xe0, 0x05, 0x90, 0x04, 0xb3, 0x80, 0x03, 0x90, 0x04, 0xb4, 0x74, 0x0a, 0xf0,
+ 0x22, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x22, 0xb1, 0x38,
+ 0x74, 0x10, 0xf1, 0xf2, 0xef, 0xf0, 0xe4, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe2, 0x68, 0xed, 0xf1,
+ 0xcb, 0x74, 0x09, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xe4, 0xfe, 0xed, 0x30, 0xe0, 0x05, 0x90, 0x04,
+ 0xbf, 0xe0, 0xfe, 0xed, 0x30, 0xe1, 0x06, 0x90, 0x04, 0xc0, 0xe0, 0x42, 0x06, 0xb1, 0x38, 0xed,
+ 0xf1, 0xf2, 0xee, 0xf1, 0xcb, 0xef, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xf0, 0x74, 0xc2, 0x90, 0xe2,
+ 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x33, 0x22, 0x7b, 0x01, 0x7a,
+ 0x03, 0x79, 0x52, 0x22, 0x7b, 0x01, 0x7f, 0x08, 0xa1, 0x51, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5,
+ 0x11, 0x22, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe2, 0x66, 0x22, 0x74, 0x82, 0x90, 0xe2, 0x65, 0xf0,
+ 0x90, 0xe2, 0x64, 0x22, 0xae, 0x05, 0xe4, 0xfd, 0xef, 0x54, 0x0f, 0xff, 0xd3, 0x94, 0x0f, 0x50,
+ 0x05, 0x11, 0x3b, 0x4a, 0x70, 0x04, 0x7d, 0x15, 0x80, 0x1c, 0x11, 0x3b, 0xf5, 0x82, 0x8a, 0x83,
+ 0xe0, 0xfc, 0xee, 0x60, 0x05, 0xec, 0x44, 0x05, 0x80, 0x03, 0xec, 0x54, 0xfa, 0xfe, 0x11, 0x3b,
+ 0xf5, 0x82, 0x8a, 0x83, 0xee, 0xf0, 0x7f, 0x03, 0x02, 0x2a, 0xeb, 0xef, 0x25, 0xe0, 0x24, 0x65,
+ 0xf5, 0x82, 0xe4, 0x34, 0x11, 0xf5, 0x83, 0xe4, 0x93, 0xfa, 0x74, 0x01, 0x93, 0x22, 0x7f, 0x02,
+ 0xe4, 0xfe, 0xee, 0x11, 0xb0, 0xe0, 0xfd, 0x20, 0xe6, 0x42, 0x11, 0xa5, 0x11, 0x45, 0xf5, 0x82,
+ 0x8a, 0x83, 0xe4, 0xf0, 0x90, 0xe3, 0x04, 0xef, 0xf0, 0x00, 0x00, 0x00, 0x44, 0x80, 0xfc, 0x90,
+ 0xe3, 0x49, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x53, 0x05, 0x03, 0xee, 0x60, 0x03, 0xbe, 0x02, 0x15,
+ 0xed, 0x70, 0x07, 0x90, 0xe3, 0x49, 0xec, 0xf0, 0x7d, 0x03, 0xbd, 0x03, 0x08, 0x90, 0xe3, 0x49,
+ 0xec, 0xf0, 0x00, 0x00, 0x00, 0x11, 0xa5, 0x11, 0xb9, 0x74, 0x11, 0xf0, 0x0f, 0x0f, 0x0e, 0xee,
+ 0x64, 0x04, 0x70, 0xae, 0x22, 0xee, 0x25, 0xe0, 0x24, 0xe8, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0x22,
+ 0x25, 0xe0, 0x24, 0xf0, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01,
+ 0x93, 0xf5, 0x82, 0x8c, 0x83, 0x22, 0x11, 0x4e, 0xe4, 0xff, 0x7e, 0x02, 0xef, 0xc3, 0x94, 0x04,
+ 0x50, 0x2c, 0xef, 0x11, 0xb0, 0xe0, 0x30, 0xe6, 0x20, 0xef, 0x11, 0xa6, 0xf5, 0x83, 0xd1, 0xb6,
+ 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04, 0xee, 0xf0, 0x00,
+ 0x00, 0x00, 0x8d, 0x82, 0x8c, 0x83, 0x74, 0x05, 0xf0, 0x0f, 0x0e, 0x0e, 0x80, 0xce, 0x22, 0xe5,
+ 0x14, 0xc3, 0x94, 0x04, 0x40, 0x03, 0x12, 0x50, 0xc5, 0x11, 0xc6, 0xe4, 0x90, 0xe3, 0x12, 0xf0,
+ 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x7f, 0x03, 0x51, 0x3c, 0x74, 0x01, 0x93,
+ 0x70, 0x02, 0xe4, 0x93, 0x60, 0x07, 0x51, 0x3c, 0x11, 0xbb, 0xe4, 0xf0, 0x00, 0x0f, 0xbf, 0x10,
+ 0xea, 0x90, 0xe2, 0xeb, 0x74, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xe4, 0xf0, 0x7e, 0xe2, 0x7f, 0x86,
+ 0x7b, 0x1c, 0xfa, 0xfd, 0xf1, 0x37, 0x12, 0x57, 0x67, 0xf5, 0x14, 0x22, 0xc0, 0xe0, 0xc0, 0xf0,
+ 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0,
+ 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xf1, 0xf3, 0x90, 0x00, 0xab, 0xe4, 0xf0,
+ 0x78, 0xa3, 0xf2, 0x78, 0xa5, 0xf2, 0x78, 0x1a, 0x74, 0x40, 0xf2, 0x78, 0x48, 0x74, 0x86, 0xf2,
+ 0x00, 0xf2, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x7f, 0x02, 0xd1, 0xf2, 0x11, 0x4e, 0x11, 0xc8,
+ 0xe4, 0xff, 0x51, 0x3c, 0x74, 0x01, 0x93, 0x70, 0x02, 0xe4, 0x93, 0x60, 0x08, 0x51, 0x3c, 0x11,
+ 0xbb, 0xe0, 0x54, 0xfd, 0xf0, 0x0f, 0xbf, 0x10, 0xe9, 0x90, 0x00, 0xa9, 0xe4, 0xf0, 0xa3, 0x74,
+ 0x40, 0xf0, 0x78, 0x24, 0xe4, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x25, 0x74, 0x40, 0xf2, 0x90, 0x00,
+ 0x60, 0xe4, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee, 0x12, 0x4e,
+ 0xf8, 0x90, 0x00, 0x66, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x00, 0x6e, 0xec, 0xf0, 0xa3, 0xed,
+ 0xf0, 0xaa, 0x06, 0xa9, 0x07, 0x7b, 0x01, 0xd1, 0xbd, 0xaa, 0x04, 0xa9, 0x05, 0x74, 0x07, 0xd1,
+ 0xbf, 0x30, 0x25, 0x0b, 0xc2, 0x26, 0x90, 0x04, 0x81, 0xe4, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90,
+ 0x00, 0xad, 0xe4, 0xf0, 0xc2, 0x27, 0xc2, 0x24, 0xc2, 0x25, 0xc2, 0x00, 0x90, 0x04, 0xb4, 0xf0,
+ 0x90, 0x04, 0xb3, 0xf0, 0xe5, 0x14, 0xc3, 0x94, 0x04, 0x40, 0x06, 0xe4, 0xfd, 0x7f, 0x04, 0xf1,
+ 0x0e, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xef, 0x75, 0xf0, 0x02,
+ 0x90, 0x11, 0x65, 0x02, 0x0d, 0x16, 0xef, 0x14, 0x60, 0x15, 0x14, 0x60, 0x1a, 0x24, 0x81, 0x60,
+ 0x12, 0x24, 0xfb, 0x60, 0x16, 0x24, 0x86, 0x70, 0x1c, 0x51, 0xa9, 0xe4, 0xf0, 0x80, 0x33, 0x78,
+ 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0xe2, 0x54, 0x01,
+ 0x51, 0xa9, 0xf0, 0x80, 0x1d, 0x53, 0x07, 0x0f, 0x51, 0x3c, 0xd1, 0xb6, 0x4c, 0x70, 0x03, 0x7f,
+ 0x15, 0x22, 0x51, 0x3c, 0xd1, 0xd2, 0xe0, 0x7f, 0x00, 0x30, 0xe1, 0x02, 0x7f, 0x01, 0x51, 0xa9,
+ 0xef, 0xf0, 0x51, 0xa9, 0xa3, 0xe4, 0xf0, 0x78, 0x8b, 0x74, 0x02, 0xf2, 0xe5, 0x17, 0x78, 0xb3,
+ 0xf2, 0xe5, 0x18, 0x78, 0xb4, 0xf2, 0x7f, 0x00, 0x22, 0x85, 0x18, 0x82, 0x85, 0x17, 0x83, 0x22,
+ 0x78, 0xb8, 0xe2, 0xf5, 0x41, 0x78, 0xb9, 0xe2, 0xf5, 0x42, 0x78, 0xba, 0xe2, 0xf5, 0x43, 0x78,
+ 0xbb, 0xe2, 0xf5, 0x44, 0x78, 0xbc, 0xe2, 0xf5, 0x45, 0xe5, 0x41, 0x54, 0x03, 0xff, 0xc2, 0x17,
+ 0xc2, 0x18, 0xe5, 0x41, 0x54, 0x60, 0x90, 0x00, 0xaf, 0xf0, 0xc2, 0x24, 0x64, 0x20, 0x60, 0x05,
+ 0xe0, 0x64, 0x40, 0x70, 0x75, 0x90, 0x00, 0xac, 0xe0, 0xfe, 0x30, 0xe7, 0x69, 0x54, 0x7c, 0xfe,
+ 0x13, 0x13, 0x54, 0x3f, 0x65, 0x45, 0x70, 0x5e, 0xef, 0x64, 0x01, 0x70, 0x59, 0xd2, 0x17, 0xe5,
+ 0x42, 0x24, 0x02, 0x60, 0x32, 0x14, 0x60, 0x02, 0xa1, 0xe5, 0xe5, 0x41, 0x64, 0x21, 0x60, 0x02,
+ 0xa1, 0xe5, 0xe5, 0x43, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0xbe, 0xe2, 0x60, 0x02, 0xa1, 0xe5, 0x53,
+ 0x91, 0xef, 0x75, 0xa1, 0x01, 0x90, 0x00, 0xab, 0xf0, 0x7e, 0x00, 0x7f, 0x7a, 0x7b, 0x1f, 0xfa,
+ 0xfd, 0xf1, 0x37, 0xc2, 0x00, 0xa1, 0xa0, 0xe5, 0x41, 0x64, 0xa1, 0x60, 0x02, 0xa1, 0xe5, 0xe5,
+ 0x43, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0xbe, 0xe2, 0x64, 0x01, 0x60, 0x02, 0xa1, 0xe5, 0x90, 0x00,
+ 0xac, 0xe0, 0x54, 0x03, 0x81, 0xeb, 0xd2, 0x18, 0xa1, 0xa0, 0x90, 0x00, 0xae, 0xe0, 0x64, 0x02,
+ 0x60, 0x02, 0x81, 0x3a, 0xe5, 0x42, 0xb4, 0x09, 0x05, 0x12, 0x47, 0xf0, 0x80, 0x14, 0xe5, 0x42,
+ 0x70, 0x10, 0xe5, 0x41, 0xb4, 0x82, 0x0b, 0xd2, 0x17, 0xaf, 0x45, 0x51, 0x46, 0xef, 0x60, 0x02,
+ 0xa1, 0xe5, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02, 0x81, 0x31, 0x90, 0x00, 0xac, 0xe0, 0x30, 0xe7,
+ 0x39, 0xe5, 0x42, 0x64, 0x06, 0x70, 0x2b, 0xe5, 0x44, 0x64, 0x02, 0x60, 0x06, 0xe5, 0x44, 0x64,
+ 0x07, 0x70, 0x1f, 0xd2, 0x24, 0x90, 0x00, 0x76, 0xf1, 0xe0, 0x30, 0x27, 0x06, 0xe5, 0x44, 0x64,
+ 0x02, 0x60, 0x08, 0x20, 0x27, 0x14, 0xe5, 0x44, 0xb4, 0x07, 0x0f, 0x90, 0x00, 0x74, 0xf1, 0xe0,
+ 0x80, 0x08, 0xe5, 0x42, 0xb4, 0x0b, 0x03, 0x12, 0x56, 0xd9, 0xe5, 0x42, 0x64, 0x03, 0x70, 0x32,
+ 0xe5, 0x41, 0xb4, 0x02, 0x15, 0xe5, 0x43, 0x70, 0x11, 0xe5, 0x45, 0x64, 0x02, 0x60, 0x05, 0xe5,
+ 0x45, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x45, 0xb1, 0xed, 0xe5, 0x41, 0x70, 0x14, 0xe5, 0x43,
+ 0xb4, 0x01, 0x08, 0x90, 0x00, 0xb0, 0x74, 0x03, 0xf0, 0x80, 0x07, 0xe5, 0x43, 0xb4, 0x02, 0x02,
+ 0xd2, 0x17, 0xe5, 0x42, 0x64, 0x01, 0x70, 0x29, 0xe5, 0x41, 0xb4, 0x02, 0x15, 0xe5, 0x43, 0x70,
+ 0x11, 0xe5, 0x45, 0x64, 0x02, 0x60, 0x05, 0xe5, 0x45, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x45,
+ 0xd1, 0x3f, 0xe5, 0x41, 0x70, 0x0b, 0xe5, 0x43, 0xb4, 0x01, 0x06, 0x90, 0x00, 0xb0, 0x74, 0x01,
+ 0xf0, 0x30, 0x17, 0x02, 0xa1, 0xa0, 0xd2, 0x18, 0xa1, 0xa0, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02,
+ 0xa1, 0xe5, 0xd2, 0x17, 0xe5, 0x42, 0x12, 0x0d, 0x2b, 0x35, 0x13, 0x00, 0x35, 0x3e, 0x01, 0x35,
+ 0x75, 0x03, 0x34, 0x65, 0x06, 0x35, 0x0b, 0x08, 0x34, 0xfa, 0x09, 0x34, 0xe7, 0x0a, 0x34, 0xef,
+ 0x0b, 0x00, 0x00, 0x35, 0xe5, 0xe5, 0x44, 0x24, 0xfe, 0x60, 0x29, 0x14, 0x60, 0x3d, 0x24, 0xfd,
+ 0x60, 0x13, 0x14, 0x60, 0x2a, 0x24, 0x06, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0x8b, 0x74, 0x12, 0xf2,
+ 0x90, 0x00, 0x62, 0x80, 0x08, 0x78, 0x8b, 0x74, 0x0a, 0xf2, 0x90, 0x00, 0x64, 0xe0, 0x78, 0xb3,
+ 0xf2, 0xa3, 0x80, 0x14, 0x90, 0x00, 0x6c, 0x12, 0x56, 0x7f, 0x90, 0x00, 0x6d, 0x80, 0x09, 0x90,
+ 0x00, 0x6e, 0x12, 0x56, 0x7f, 0x90, 0x00, 0x6f, 0xe0, 0xa1, 0x30, 0xe5, 0x43, 0xc3, 0x94, 0x08,
+ 0x50, 0x15, 0xe5, 0x43, 0x25, 0xe0, 0x24, 0x99, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0xff, 0x4e, 0x70, 0x06, 0xd2, 0x18, 0xc2, 0x17, 0xa1, 0xa0, 0x8e, 0x48, 0x8f,
+ 0x49, 0x8e, 0x4a, 0x8f, 0x4b, 0x85, 0x4b, 0x82, 0x85, 0x4a, 0x83, 0xe0, 0x78, 0x8b, 0xf2, 0xe5,
+ 0x48, 0x78, 0xb3, 0xf2, 0xef, 0x80, 0x49, 0x90, 0x00, 0x60, 0xe0, 0xd1, 0xdd, 0x80, 0x41, 0x12,
+ 0x56, 0xd9, 0x90, 0x00, 0x60, 0xe5, 0x43, 0xf0, 0xa1, 0xa0, 0xad, 0x43, 0x7f, 0x05, 0xf1, 0x0e,
+ 0x90, 0x00, 0x61, 0xe5, 0x43, 0xf0, 0x12, 0x47, 0xf0, 0xa1, 0xa0, 0x90, 0x00, 0x61, 0xe0, 0xd1,
+ 0xdd, 0x80, 0x1d, 0xe5, 0x41, 0x24, 0x7f, 0x60, 0x09, 0x14, 0x60, 0x19, 0x24, 0x02, 0x60, 0x02,
+ 0xa1, 0xe5, 0x90, 0x00, 0xb0, 0xe0, 0x51, 0xa9, 0xf0, 0xa3, 0xe4, 0xf0, 0x74, 0x02, 0xd1, 0xe6,
+ 0x78, 0xb4, 0xf2, 0x80, 0x6b, 0xaf, 0x45, 0x51, 0x46, 0xef, 0x60, 0x64, 0xa1, 0xe5, 0xe5, 0x41,
+ 0xb4, 0x02, 0x1f, 0xe5, 0x43, 0x70, 0x1b, 0xaf, 0x45, 0xd1, 0x3f, 0xef, 0x60, 0x02, 0xa1, 0xe5,
+ 0xe5, 0x45, 0x64, 0x02, 0x60, 0x0c, 0xe5, 0x45, 0x64, 0x86, 0x60, 0x06, 0xad, 0x45, 0x7f, 0x07,
+ 0xf1, 0x0e, 0xe5, 0x41, 0x70, 0x3a, 0xe5, 0x43, 0x64, 0x01, 0x70, 0x34, 0x90, 0x00, 0xb0, 0xe0,
+ 0x54, 0xfd, 0xf0, 0x80, 0x2b, 0xe5, 0x41, 0x24, 0xfe, 0x60, 0x1a, 0x24, 0x02, 0x70, 0x66, 0xe5,
+ 0x43, 0xb4, 0x01, 0x09, 0x90, 0x00, 0xb0, 0xe0, 0x44, 0x02, 0xf0, 0x80, 0x13, 0xe5, 0x43, 0x64,
+ 0x02, 0x60, 0x0d, 0x80, 0x50, 0xe5, 0x43, 0x70, 0x4c, 0xaf, 0x45, 0xb1, 0xed, 0xef, 0x70, 0x45,
+ 0x30, 0x18, 0x38, 0x30, 0x25, 0x11, 0xe4, 0x90, 0x04, 0x81, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90,
+ 0x00, 0xb1, 0xf0, 0xa3, 0xf0, 0xc2, 0x26, 0xf1, 0xd8, 0xe5, 0x41, 0x20, 0xe7, 0x18, 0x78, 0xbf,
+ 0xe2, 0x90, 0x00, 0xb1, 0xf0, 0x78, 0xbe, 0xe2, 0xa3, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x70, 0x02,
+ 0xa3, 0xe0, 0x60, 0x02, 0xd2, 0x26, 0xd2, 0x25, 0x12, 0x2e, 0x89, 0x30, 0x17, 0x0e, 0x78, 0xa0,
+ 0xe2, 0x44, 0x80, 0xf2, 0x22, 0x90, 0xe6, 0xa0, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0xef, 0x54, 0x0f,
+ 0xfe, 0xef, 0x14, 0x60, 0x1a, 0x14, 0x60, 0x1f, 0x24, 0x82, 0x60, 0x0b, 0x14, 0x60, 0x14, 0x24,
+ 0xfb, 0x60, 0x18, 0x24, 0x86, 0x70, 0x1b, 0x78, 0xa0, 0xe2, 0x44, 0x01, 0xf2, 0x80, 0x2d, 0x78,
+ 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0x74, 0x01, 0xf2,
+ 0x80, 0x1a, 0x75, 0xf0, 0x02, 0xee, 0x51, 0x40, 0xd1, 0xb6, 0x4c, 0x70, 0x03, 0x7f, 0x15, 0x22,
+ 0x75, 0xf0, 0x02, 0xee, 0x51, 0x40, 0xd1, 0xd2, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x00, 0x22, 0xad,
+ 0x07, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x60, 0x51, 0x24, 0xfe, 0x60, 0x18, 0x24, 0x81, 0x60, 0x0e,
+ 0x24, 0xfb, 0x60, 0x1f, 0x24, 0x85, 0x70, 0x26, 0xe4, 0x78, 0xa1, 0xf2, 0x80, 0x3b, 0xe4, 0x78,
+ 0xa2, 0xf2, 0x80, 0x35, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x2f, 0x78, 0xa3, 0xf2, 0x7f, 0x02, 0xd1,
+ 0xf2, 0x80, 0x26, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x20, 0x78, 0xa5, 0xf2, 0x80, 0x1b, 0xec, 0x51,
+ 0x3d, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0x4e, 0x70, 0x03, 0x7f, 0x15, 0x22, 0x75, 0xf0, 0x02,
+ 0xec, 0x51, 0x40, 0xd1, 0xd2, 0xe0, 0x54, 0xfd, 0xf0, 0xed, 0x30, 0xe7, 0x03, 0x43, 0x04, 0x10,
+ 0xd1, 0xc5, 0xe0, 0x30, 0xe7, 0x0d, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x20, 0xe7, 0x03, 0x43, 0x04,
+ 0x10, 0xd1, 0xc5, 0x7f, 0x00, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0x22, 0x74, 0x02, 0x90,
+ 0x00, 0x01, 0x02, 0x0b, 0x7c, 0x90, 0xe6, 0x83, 0xec, 0xf0, 0x44, 0x20, 0xf0, 0xec, 0xf0, 0x22,
+ 0xf5, 0x83, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x85, 0x18, 0x82,
+ 0x85, 0x17, 0x83, 0xf0, 0x74, 0x01, 0x78, 0x8b, 0xf2, 0xe5, 0x17, 0x78, 0xb3, 0xf2, 0xfe, 0xe5,
+ 0x18, 0x22, 0xef, 0x44, 0x80, 0xfe, 0xf1, 0x8c, 0x00, 0xef, 0xf0, 0x00, 0xe4, 0xf0, 0x00, 0x90,
+ 0xe6, 0x49, 0xee, 0xf0, 0x00, 0xf0, 0x30, 0x20, 0x04, 0x00, 0xf0, 0x00, 0xf0, 0x22, 0xae, 0x07,
+ 0x12, 0x2d, 0x38, 0xf1, 0xd8, 0x90, 0xe2, 0x66, 0xee, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xed, 0xf0,
+ 0xe4, 0x12, 0x2f, 0x87, 0x12, 0x56, 0xcf, 0x74, 0x0b, 0xf0, 0x7f, 0x01, 0x02, 0x2d, 0xf7, 0x7e,
+ 0xf8, 0x7f, 0x00, 0x7a, 0x00, 0xe4, 0xfd, 0x8e, 0x4c, 0x8f, 0x4d, 0x8d, 0x4e, 0x8a, 0x4f, 0x8b,
+ 0x50, 0x12, 0x57, 0x34, 0xe5, 0x4c, 0xf5, 0x9a, 0xe5, 0x4d, 0xf5, 0x9b, 0xe5, 0x50, 0xae, 0x4f,
+ 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0xff, 0xe5, 0x50, 0x54, 0x07, 0xfd, 0xef,
+ 0x1f, 0xaa, 0x06, 0x70, 0x01, 0x1e, 0x4a, 0x60, 0x0f, 0xac, 0x4e, 0x78, 0x7b, 0xec, 0xf2, 0xf2,
+ 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0x80, 0xe7, 0xaf, 0x05, 0x1d, 0xef, 0x60, 0x07, 0x78, 0x7b,
+ 0xe5, 0x4e, 0xf2, 0x80, 0xf3, 0x12, 0x0e, 0xcf, 0x85, 0x5a, 0xe8, 0x22, 0x90, 0xe6, 0x04, 0x74,
+ 0x80, 0xf0, 0x22, 0x8f, 0x2b, 0x90, 0x00, 0xe3, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xf4,
+ 0x55, 0x2b, 0x70, 0x03, 0x7f, 0x10, 0x22, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0xe5, 0x2b, 0x54, 0x1e,
+ 0x60, 0x0c, 0xf1, 0x8c, 0x12, 0x0e, 0x97, 0xaf, 0x2b, 0x12, 0x3d, 0xf5, 0xf1, 0xe9, 0x20, 0x20,
+ 0x04, 0x7f, 0x04, 0xd1, 0xf2, 0xf1, 0x8c, 0x00, 0x74, 0x06, 0xf0, 0x00, 0x74, 0x08, 0xf0, 0x00,
+ 0xe4, 0xf0, 0x12, 0x41, 0xe3, 0x7f, 0x00, 0x22, 0x90, 0x00, 0xfd, 0xe0, 0x44, 0x08, 0xf0, 0x22,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0x8e, 0x15, 0xf5, 0x16, 0x22, 0x7f, 0x02, 0xd1, 0xf2, 0xe4, 0x90, 0xe6,
+ 0x04, 0xf0, 0x22, 0x53, 0x91, 0xef, 0x75, 0xa1, 0x00, 0x22, 0xf1, 0xf3, 0x32, 0xef, 0x54, 0x0f,
+ 0xfe, 0xd3, 0x94, 0x0f, 0x50, 0x07, 0xee, 0x12, 0x30, 0x3c, 0x4a, 0x70, 0x26, 0xee, 0x64, 0x01,
+ 0x70, 0x1a, 0xbd, 0x02, 0x17, 0xbf, 0x01, 0x05, 0x90, 0xe6, 0xa1, 0x80, 0x08, 0xef, 0x64, 0x81,
+ 0x70, 0x28, 0x90, 0xe6, 0xa2, 0xe0, 0x54, 0x01, 0xf5, 0x0f, 0x80, 0x1e, 0x7d, 0x15, 0x7f, 0x03,
+ 0x02, 0x2a, 0xeb, 0xee, 0x25, 0xe0, 0x24, 0x65, 0xf5, 0x82, 0xe4, 0x34, 0x11, 0x12, 0x36, 0xd0,
+ 0xe0, 0x5d, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01, 0x8f, 0x0f, 0xbd, 0x02, 0x05, 0x75, 0x0d, 0x22,
+ 0x80, 0x03, 0x75, 0x0d, 0x26, 0x75, 0x0c, 0x83, 0xe4, 0xf5, 0x0e, 0xfd, 0xfb, 0xfe, 0x12, 0x28,
+ 0xc5, 0x02, 0x28, 0x36, 0xc2, 0x15, 0x12, 0x0f, 0xf8, 0xff, 0x12, 0x14, 0xb8, 0xf5, 0x34, 0x12,
+ 0x17, 0xd0, 0xa3, 0xe0, 0xf5, 0x35, 0x90, 0x00, 0xae, 0xe0, 0xb4, 0x02, 0x03, 0x7f, 0x18, 0x22,
+ 0xe5, 0x34, 0x24, 0xfe, 0x60, 0x14, 0x14, 0x60, 0x1e, 0x14, 0x60, 0x2f, 0x14, 0x60, 0x45, 0x24,
+ 0x04, 0x60, 0x02, 0x21, 0x20, 0x90, 0x00, 0x62, 0x80, 0x03, 0x90, 0x00, 0x64, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0x8e, 0x36, 0xf5, 0x37, 0x80, 0x7c, 0x90, 0x00, 0x70, 0x31, 0xa4, 0xd2, 0x15, 0x90, 0x00,
+ 0x68, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x6c, 0x80, 0x12, 0x90, 0x00, 0x72, 0x31, 0xa4,
+ 0xd2, 0x15, 0x90, 0x00, 0x66, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x6e, 0xee, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x80, 0x4f, 0x90, 0x00, 0x78, 0x31, 0xa4, 0x31, 0xd6, 0xf5, 0x82, 0x8c, 0x83, 0xe0,
+ 0xfd, 0xd3, 0x94, 0x08, 0x50, 0x14, 0xe5, 0x35, 0xfb, 0x7a, 0x00, 0xef, 0x2b, 0xff, 0xea, 0x3e,
+ 0xfe, 0xc3, 0xef, 0x94, 0x40, 0xee, 0x94, 0x03, 0x40, 0x03, 0x7f, 0x17, 0x22, 0x90, 0x00, 0x78,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x75, 0xf0, 0x02, 0xed, 0x90, 0x00, 0x99, 0x12, 0x0d, 0x16, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x78, 0xe4, 0x85, 0x35, 0xf0, 0x12, 0x0b, 0xb0, 0x80, 0x03,
+ 0x7f, 0x17, 0x22, 0x90, 0x04, 0x88, 0xe0, 0x24, 0x04, 0xff, 0x12, 0x1d, 0x36, 0xa9, 0x07, 0x7b,
+ 0x01, 0x8b, 0x38, 0xf5, 0x39, 0x89, 0x3a, 0xfc, 0xad, 0x01, 0xe5, 0x35, 0xfb, 0x31, 0xb0, 0x30,
+ 0x15, 0x5f, 0xe5, 0x37, 0x24, 0x07, 0xf5, 0x82, 0xe4, 0x35, 0x36, 0xf5, 0x83, 0xe0, 0x30, 0xe6,
+ 0x08, 0x90, 0x00, 0xb0, 0x74, 0x01, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x00, 0xb0, 0xf0, 0x90, 0x00,
+ 0xb9, 0xe0, 0x60, 0x3d, 0x31, 0xc4, 0x24, 0x17, 0xf0, 0x31, 0xc4, 0x04, 0xf0, 0xe5, 0x34, 0xb4,
+ 0x03, 0x0e, 0x90, 0x00, 0x71, 0xe0, 0x90, 0x00, 0x70, 0x31, 0xb9, 0x90, 0x00, 0x76, 0x80, 0x0c,
+ 0x90, 0x00, 0x73, 0xe0, 0x90, 0x00, 0x72, 0x31, 0xb9, 0x90, 0x00, 0x74, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xaa, 0x06, 0x75, 0x38, 0x01, 0x8a, 0x39, 0xf5, 0x3a, 0xac, 0x39, 0xad, 0x3a, 0x7b, 0x17, 0x31,
+ 0xb0, 0x7f, 0x00, 0x22, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xac, 0x06, 0x8c, 0x36, 0xf5, 0x37, 0x22,
+ 0x7a, 0x00, 0xaf, 0x37, 0xae, 0x36, 0x02, 0x19, 0x58, 0x25, 0x35, 0xff, 0xe0, 0x34, 0x00, 0xf5,
+ 0x36, 0x8f, 0x37, 0x22, 0x74, 0x02, 0x25, 0x37, 0xf5, 0x37, 0xe4, 0x35, 0x36, 0xf5, 0x36, 0x85,
+ 0x37, 0x82, 0xf5, 0x83, 0xe0, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfc, 0xa3, 0xe0, 0x22, 0x90, 0x00,
+ 0xae, 0xe0, 0xb4, 0x02, 0x03, 0x7f, 0x18, 0x22, 0xef, 0x24, 0xfe, 0x60, 0x13, 0x14, 0x60, 0x19,
+ 0x14, 0x60, 0x20, 0x24, 0x03, 0x70, 0x2f, 0x90, 0x00, 0x62, 0x51, 0x5b, 0x7e, 0x12, 0x80, 0x29,
+ 0x90, 0x00, 0x64, 0x51, 0x5b, 0x7e, 0x0a, 0x80, 0x20, 0x90, 0x00, 0x68, 0x51, 0x5b, 0x90, 0x00,
+ 0x68, 0x80, 0x08, 0x90, 0x00, 0x66, 0x51, 0x5b, 0x90, 0x00, 0x66, 0x51, 0x7e, 0x90, 0x00, 0x02,
+ 0x12, 0x0b, 0x4f, 0xfe, 0x80, 0x03, 0x7f, 0x17, 0x22, 0x51, 0x6d, 0xe4, 0xf0, 0xa3, 0xee, 0xf0,
+ 0x74, 0x03, 0x51, 0x74, 0x74, 0x24, 0x51, 0x6c, 0xe0, 0x90, 0x04, 0x85, 0x51, 0x6c, 0xa3, 0xe0,
+ 0x90, 0x04, 0x86, 0xf0, 0xee, 0x24, 0x02, 0xff, 0xe5, 0x35, 0x24, 0x02, 0xfd, 0xe4, 0x35, 0x34,
+ 0xfa, 0xa9, 0x05, 0x7b, 0x01, 0x12, 0x2d, 0x51, 0x7f, 0x00, 0x22, 0xe0, 0xfe, 0xa3, 0xe0, 0x24,
+ 0xfe, 0xf9, 0xee, 0x34, 0xff, 0xaf, 0x01, 0xf5, 0x34, 0x8f, 0x35, 0x22, 0xf0, 0x85, 0x35, 0x82,
+ 0x85, 0x34, 0x83, 0x22, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x84, 0x22, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xaa, 0x06, 0xf9, 0x7b, 0x01, 0x22, 0x8f, 0x2e, 0x12, 0x2e, 0xfe, 0x64, 0x01, 0x60, 0x0a, 0x90,
+ 0x00, 0xb7, 0x74, 0x11, 0xf0, 0xa3, 0x74, 0x3d, 0xf0, 0x90, 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0x24, 0x04, 0x30, 0x1e, 0x08, 0x12, 0x17, 0xa6, 0x74, 0x05, 0xf0, 0x80, 0x05, 0x12, 0x17, 0xa6,
+ 0xe4, 0xf0, 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x45, 0x12, 0x0b, 0x36, 0xff, 0x90, 0x00, 0xb7, 0x71,
+ 0x05, 0xef, 0xf0, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0x8d, 0x82, 0x8c, 0x83, 0x71, 0xf4, 0xf1,
+ 0xcd, 0x90, 0x04, 0x83, 0x74, 0x43, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x10, 0xf0, 0xe5, 0x2e, 0xc4,
+ 0x54, 0xf0, 0x90, 0x04, 0x85, 0xf0, 0x74, 0xc5, 0x25, 0x2e, 0x12, 0x2f, 0x01, 0x90, 0x04, 0x86,
+ 0xf0, 0x90, 0x00, 0xb7, 0x51, 0x7c, 0x7f, 0x2a, 0x12, 0x2d, 0x51, 0x80, 0x02, 0x71, 0x0f, 0x7f,
+ 0x00, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0x22, 0x90,
+ 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0xe0, 0x4e, 0x60, 0x39, 0x12, 0x47, 0x5a, 0xe4, 0xff, 0xef, 0x24,
+ 0x04, 0xfd, 0xe4, 0x33, 0xfc, 0x90, 0x00, 0xb7, 0xe0, 0xfa, 0xa3, 0xe0, 0x2d, 0xf5, 0x82, 0xea,
+ 0x3c, 0xf5, 0x83, 0xe0, 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf8, 0xf5, 0x83, 0xee,
+ 0xf0, 0x0f, 0xbf, 0x24, 0xd9, 0x7f, 0x24, 0x7e, 0x00, 0x71, 0x53, 0xe4, 0x90, 0x00, 0xb7, 0xf0,
+ 0xa3, 0xf0, 0x22, 0xc2, 0x19, 0xc2, 0x1a, 0x90, 0x00, 0xad, 0xe0, 0x70, 0x02, 0x61, 0xeb, 0x90,
+ 0x04, 0xb8, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0x9f, 0xec, 0x9e, 0x50, 0x06, 0xae, 0x04, 0xaf,
+ 0x05, 0x80, 0x00, 0xee, 0x71, 0xec, 0x4e, 0x60, 0x72, 0x90, 0x00, 0xa9, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xff, 0x12, 0x47, 0x4d, 0x50, 0x0c, 0xd2, 0x19, 0x90, 0x04, 0xb8, 0xe0, 0xff, 0xa3, 0xe0, 0xcf,
+ 0x71, 0xec, 0x90, 0x04, 0xb1, 0xe0, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00, 0xa3, 0xe0, 0x78, 0x99,
+ 0xf2, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x04, 0xb1, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0xfb, 0xaa, 0x06, 0xe4, 0xf9, 0xf8, 0xd0, 0x07, 0xd0, 0x06, 0x12, 0x0b, 0xd3, 0x90,
+ 0x04, 0xb6, 0x12, 0x0c, 0xd9, 0x90, 0x00, 0xaa, 0xe0, 0x24, 0xff, 0xff, 0x90, 0x00, 0xa9, 0xe0,
+ 0x34, 0xff, 0xfe, 0x90, 0x04, 0xb1, 0xe0, 0x5e, 0xfe, 0xa3, 0xe0, 0x5f, 0x4e, 0x60, 0x02, 0xd2,
+ 0x1a, 0x20, 0x19, 0x07, 0xa2, 0x1a, 0x92, 0x1b, 0x12, 0x17, 0x53, 0x22, 0x90, 0x04, 0xb1, 0xf0,
+ 0xa3, 0xef, 0xf0, 0x22, 0xa3, 0xf0, 0x90, 0x00, 0xfd, 0xe0, 0x44, 0x0c, 0xf0, 0x22, 0x8f, 0x2e,
+ 0x8d, 0x2f, 0x90, 0x00, 0xc7, 0xe0, 0xfd, 0xa3, 0xe0, 0x90, 0x00, 0xc7, 0xf0, 0x12, 0x4d, 0x72,
+ 0x90, 0x00, 0xc7, 0xed, 0xf0, 0xe5, 0x2e, 0x04, 0xfd, 0xe5, 0x2f, 0x20, 0xe0, 0x08, 0xe5, 0x5c,
+ 0x5d, 0x60, 0x03, 0x7f, 0x9b, 0x22, 0xef, 0x14, 0x70, 0x11, 0x91, 0x72, 0xaf, 0x2f, 0x12, 0x43,
+ 0xae, 0xb1, 0xb9, 0x90, 0x04, 0x37, 0xe0, 0xf5, 0x0e, 0x80, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00,
+ 0xb6, 0xe0, 0x60, 0x2b, 0x75, 0x0d, 0x11, 0x75, 0x0c, 0xc3, 0x74, 0xc5, 0x25, 0x2e, 0x12, 0x2f,
+ 0x01, 0xf5, 0x0f, 0xe5, 0x2e, 0xc4, 0x54, 0xf0, 0xf5, 0x0e, 0xe5, 0x2f, 0x54, 0x03, 0xf5, 0x11,
+ 0xe4, 0x90, 0x00, 0xb7, 0xf0, 0x71, 0xf4, 0xf1, 0xcd, 0x12, 0x28, 0xbf, 0x12, 0x28, 0x36, 0x7f,
+ 0x00, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0xdf, 0xf0, 0x22, 0x74, 0xff, 0x90, 0x04, 0x9f, 0xf0,
+ 0xa3, 0xf0, 0x12, 0x2e, 0xfe, 0x60, 0x03, 0xed, 0x60, 0x03, 0x7f, 0x0a, 0x22, 0x12, 0x42, 0x41,
+ 0xef, 0x60, 0x03, 0x7f, 0x08, 0x22, 0x12, 0x0c, 0x67, 0x8f, 0x2e, 0x8e, 0x2d, 0x8d, 0x2c, 0x8c,
+ 0x2b, 0xf1, 0xdf, 0x12, 0x4d, 0x08, 0x91, 0x72, 0x90, 0x04, 0x39, 0xe0, 0x70, 0x50, 0xaf, 0x2e,
+ 0xae, 0x2d, 0xad, 0x2c, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xad, 0xb1, 0xe1, 0xb1, 0xca, 0xfd, 0x90,
+ 0x04, 0x3b, 0x12, 0x0c, 0xad, 0x12, 0x26, 0x34, 0x12, 0x4d, 0x38, 0xfc, 0x78, 0x09, 0x12, 0x0c,
+ 0x54, 0xef, 0x24, 0xff, 0xf5, 0x36, 0xee, 0x34, 0xff, 0xf5, 0x35, 0xed, 0x34, 0xff, 0xf5, 0x34,
+ 0xec, 0x34, 0xff, 0xf5, 0x33, 0xb1, 0xb1, 0xfc, 0xb1, 0xa8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03,
+ 0x7f, 0x0c, 0x22, 0xb1, 0xb1, 0xac, 0x33, 0xb1, 0xd5, 0x40, 0x3e, 0x7f, 0x0c, 0x22, 0xb1, 0xa8,
+ 0xc0, 0x00, 0xb1, 0xc1, 0x12, 0x0c, 0x41, 0xd0, 0x00, 0xb1, 0xe1, 0xb1, 0xc1, 0x12, 0x0c, 0x41,
+ 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xb1, 0xca, 0xfd, 0x12, 0x26, 0x34, 0x12, 0x0c,
+ 0xa1, 0xb1, 0xa8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x12, 0x26, 0x5b, 0x12,
+ 0x0c, 0xa1, 0xb1, 0xd5, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x85, 0x2e, 0x1d, 0x85, 0x2d, 0x1c, 0x85,
+ 0x2c, 0x1b, 0x85, 0x2b, 0x1a, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x80, 0x12, 0x20, 0x5d, 0xef, 0x60,
+ 0x03, 0xaf, 0x19, 0x22, 0x85, 0x32, 0x1d, 0x85, 0x31, 0x1c, 0x85, 0x30, 0x1b, 0x85, 0x2f, 0x1a,
+ 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x84, 0x12, 0x20, 0x5d, 0xef, 0x60, 0x03, 0xaf, 0x19, 0x22, 0x12,
+ 0x1f, 0xf1, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x98, 0x12, 0x20, 0x5d, 0xef, 0x60, 0x03, 0xaf, 0x19,
+ 0x22, 0xe4, 0xf5, 0x19, 0x12, 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0x12, 0x1f, 0xff, 0x90,
+ 0x04, 0x9f, 0x12, 0x4d, 0x01, 0xe5, 0x19, 0x60, 0x0a, 0x90, 0x04, 0x9f, 0xe0, 0x70, 0x02, 0xa3,
+ 0xe0, 0x70, 0xde, 0xb1, 0xb9, 0x7f, 0x00, 0x22, 0xab, 0x2e, 0xaa, 0x2d, 0xa9, 0x2c, 0xa8, 0x2b,
+ 0x22, 0xaf, 0x36, 0xae, 0x35, 0xad, 0x34, 0x22, 0xf0, 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x20, 0xf0,
+ 0x22, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xa1, 0x78, 0x09, 0x22, 0x90, 0x04, 0x2a, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0xff, 0xe4, 0xfc, 0x22, 0xab, 0x32, 0xaa, 0x31, 0xa9, 0x30, 0xa8, 0x2f, 0xd3, 0x02, 0x0c,
+ 0x30, 0x12, 0x0b, 0xe1, 0x8f, 0x2e, 0x8e, 0x2d, 0x8d, 0x2c, 0x8c, 0x2b, 0x8f, 0x32, 0x8e, 0x31,
+ 0x8d, 0x30, 0x8c, 0x2f, 0x22, 0x8f, 0x2f, 0x7f, 0x03, 0x7e, 0x01, 0xc2, 0xe9, 0x90, 0xe2, 0x75,
+ 0xe0, 0x20, 0xe4, 0xf9, 0x90, 0xe2, 0xa4, 0xe0, 0x5f, 0x6f, 0x60, 0x19, 0x90, 0xe2, 0xa6, 0xef,
+ 0xf0, 0xee, 0x12, 0x56, 0xbb, 0xb1, 0xb8, 0x12, 0x50, 0x90, 0xd1, 0x28, 0xf1, 0xee, 0xaf, 0x2f,
+ 0x12, 0x22, 0x91, 0xb1, 0xb9, 0xd2, 0xe9, 0x22, 0x90, 0xe6, 0x01, 0x74, 0xa3, 0xf0, 0x90, 0xe6,
+ 0x09, 0x74, 0xff, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x01, 0xf0, 0x12, 0x52, 0xb2, 0x81, 0x72,
+ 0x8f, 0x2b, 0x8d, 0x2c, 0x8b, 0x2d, 0x8a, 0x2e, 0x89, 0x2f, 0xe5, 0x2b, 0xc4, 0x54, 0x0f, 0xf5,
+ 0x32, 0xf1, 0xdf, 0xee, 0xf5, 0x33, 0xed, 0xf5, 0x34, 0x90, 0x00, 0x07, 0x12, 0x0b, 0x4f, 0x24,
+ 0xff, 0x92, 0x10, 0xe5, 0x30, 0x70, 0x27, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x03, 0x20, 0x1f,
+ 0x1d, 0xf1, 0xc2, 0x90, 0xe6, 0x04, 0x74, 0x04, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x49, 0x74,
+ 0x84, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0xaf, 0x32,
+ 0x12, 0x42, 0x41, 0x8f, 0x31, 0xe5, 0x31, 0x60, 0x02, 0xe1, 0x22, 0xad, 0x2c, 0xaf, 0x2b, 0x12,
+ 0x55, 0xe2, 0x8f, 0x31, 0xe5, 0x31, 0x70, 0x7a, 0xd3, 0xe5, 0x34, 0x94, 0xff, 0xe5, 0x33, 0x94,
+ 0x0f, 0x40, 0x05, 0x75, 0x31, 0x3a, 0x80, 0x6a, 0xe5, 0x30, 0x60, 0x11, 0x90, 0x00, 0xdd, 0xe0,
+ 0x20, 0xe1, 0x03, 0x30, 0x1f, 0x07, 0xf1, 0xc2, 0xe4, 0xff, 0x12, 0x54, 0x4f, 0xe4, 0xfd, 0x7f,
+ 0x23, 0x12, 0x2f, 0xa8, 0xe5, 0x32, 0x64, 0x01, 0x70, 0x1b, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0,
+ 0x02, 0xd1, 0x28, 0x91, 0x72, 0xe5, 0x30, 0x60, 0x0c, 0xe4, 0xff, 0x12, 0x1e, 0xef, 0xf1, 0xb9,
+ 0x12, 0x24, 0x6b, 0x8f, 0x31, 0xe5, 0x30, 0x70, 0x29, 0xe5, 0x32, 0x64, 0x01, 0x70, 0x1d, 0x91,
+ 0x72, 0xf1, 0xb9, 0x12, 0x4a, 0x43, 0x8f, 0x31, 0x90, 0xe2, 0xa6, 0xe0, 0x44, 0x03, 0x12, 0x43,
+ 0x43, 0xe0, 0x54, 0xfc, 0xf0, 0x90, 0x00, 0xfb, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe6, 0x19, 0x74,
+ 0x20, 0xf0, 0xe5, 0x31, 0x60, 0x5b, 0xe5, 0x30, 0x60, 0x18, 0xe4, 0x90, 0xe6, 0x1b, 0xf0, 0x00,
+ 0x12, 0x25, 0xac, 0x00, 0x12, 0x27, 0xf3, 0x00, 0xf0, 0x00, 0x12, 0x56, 0x9a, 0x12, 0x42, 0x2b,
+ 0x80, 0x05, 0x7f, 0x04, 0x12, 0x36, 0xf2, 0x30, 0x22, 0x1b, 0x90, 0xe2, 0x40, 0x74, 0x04, 0xf0,
+ 0x90, 0xe2, 0xea, 0x74, 0x30, 0xf0, 0x12, 0x0e, 0x97, 0xe4, 0x90, 0xe2, 0x40, 0xf0, 0x90, 0xe2,
+ 0xea, 0xf0, 0x75, 0x31, 0x22, 0x90, 0x04, 0x83, 0x74, 0x02, 0xf0, 0x74, 0x14, 0xf1, 0xf6, 0xe5,
+ 0x30, 0xf0, 0x90, 0x04, 0x86, 0xe5, 0x31, 0xf0, 0x7a, 0x03, 0x79, 0x50, 0x12, 0x2f, 0xe4, 0x80,
+ 0x07, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x2a, 0xeb, 0xe5, 0x31, 0x70, 0x0d, 0xe5, 0x14, 0xc3, 0x94,
+ 0x04, 0x40, 0x1d, 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x17, 0xe5, 0x30, 0x60, 0x0d, 0x20, 0x22, 0x0a,
+ 0x12, 0x42, 0x2b, 0x7f, 0x05, 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x12, 0x0e, 0x7c, 0x12, 0x41, 0xe3,
+ 0xc2, 0x22, 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xa1, 0xb8, 0xab, 0x2d, 0xaa, 0x2e, 0xa9, 0x2f, 0xe4,
+ 0xff, 0x22, 0xe4, 0x90, 0xe2, 0x41, 0xf0, 0xa3, 0xe0, 0x54, 0xfe, 0xf0, 0x22, 0x30, 0x25, 0x08,
+ 0x30, 0x0b, 0xfa, 0x12, 0x11, 0xe9, 0x80, 0xf5, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31, 0x90,
+ 0x00, 0x05, 0x12, 0x0b, 0x4f, 0xfe, 0x90, 0x00, 0x06, 0x12, 0x0b, 0x4f, 0xfd, 0x22, 0xe4, 0x90,
+ 0xe6, 0x02, 0xf0, 0xa3, 0xf0, 0x22, 0x90, 0x04, 0x84, 0xf0, 0x90, 0x04, 0x85, 0x22, 0xe4, 0x78,
+ 0x8a, 0xf2, 0x78, 0xb5, 0xf2, 0x12, 0x18, 0x87, 0x75, 0x14, 0x01, 0x75, 0x17, 0x00, 0x75, 0x18,
+ 0xb3, 0xe5, 0x18, 0x30, 0xe0, 0x08, 0x05, 0x18, 0xe5, 0x18, 0x70, 0x02, 0x05, 0x17, 0x22, 0x71,
+ 0x3b, 0x78, 0x68, 0x74, 0x0b, 0xf2, 0x22, 0xe4, 0x90, 0x04, 0x93, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
+ 0x87, 0xa3, 0xe0, 0x30, 0xe0, 0x0a, 0x90, 0x04, 0x87, 0x11, 0xe9, 0x90, 0x04, 0x8f, 0x11, 0xe9,
+ 0x12, 0x51, 0xaa, 0x11, 0x1f, 0x31, 0xad, 0xd2, 0xaf, 0xc2, 0xac, 0xd2, 0xa8, 0xd2, 0xaa, 0x90,
+ 0xe2, 0x7a, 0xe0, 0x54, 0xbf, 0xf0, 0x90, 0xe2, 0x7e, 0xe0, 0x44, 0x04, 0xf0, 0xf1, 0x1f, 0x7d,
+ 0x03, 0x7f, 0x40, 0x51, 0x98, 0x90, 0x00, 0xe5, 0xe0, 0xb4, 0x5a, 0x04, 0x51, 0x04, 0x80, 0x02,
+ 0xd1, 0x7a, 0x90, 0x00, 0xfd, 0xe0, 0x20, 0xe0, 0xf9, 0x30, 0x2e, 0x1b, 0x90, 0x04, 0x93, 0x11,
+ 0xe9, 0x90, 0x04, 0x93, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x0c, 0xf5, 0x29, 0xf5, 0x2a, 0xf5,
+ 0x2b, 0xfb, 0xfd, 0xff, 0x12, 0x51, 0x86, 0xc2, 0xaf, 0x30, 0x00, 0x0b, 0x90, 0x00, 0xfd, 0xe0,
+ 0x20, 0xe2, 0x04, 0xd2, 0xaf, 0x91, 0x91, 0xd2, 0xaf, 0x30, 0x08, 0x03, 0x12, 0x2a, 0xfe, 0x30,
+ 0x09, 0x08, 0x30, 0x2a, 0x03, 0x12, 0x1f, 0xb9, 0x51, 0xe4, 0x30, 0x0a, 0x09, 0x30, 0x2a, 0x03,
+ 0x12, 0x1f, 0xb9, 0x12, 0x28, 0xd2, 0x30, 0x0b, 0x09, 0x30, 0x2a, 0x03, 0x12, 0x1f, 0xb9, 0x12,
+ 0x11, 0xe9, 0x30, 0x05, 0x0d, 0x90, 0x00, 0xe8, 0xe0, 0x60, 0x05, 0x7f, 0x01, 0x12, 0x2f, 0x0a,
+ 0xc2, 0x05, 0x30, 0x07, 0x94, 0x31, 0xc2, 0x80, 0x90, 0xe4, 0x75, 0xf0, 0x01, 0x02, 0x0b, 0xb0,
+ 0xae, 0x07, 0xac, 0x03, 0x7b, 0xff, 0x74, 0xc5, 0x2e, 0x12, 0x2f, 0x01, 0x70, 0x01, 0xfb, 0xed,
+ 0x60, 0x02, 0x7b, 0x01, 0xaf, 0x06, 0xad, 0x04, 0x12, 0x55, 0xca, 0xef, 0x60, 0x02, 0x7b, 0x02,
+ 0xeb, 0xf4, 0x60, 0x05, 0xaf, 0x03, 0x02, 0x2e, 0x0d, 0x74, 0xc5, 0x2e, 0x12, 0x2f, 0x01, 0xfb,
+ 0x90, 0x04, 0x9f, 0xe4, 0xf0, 0xa3, 0xeb, 0xf0, 0xee, 0x70, 0x1b, 0x90, 0x00, 0xbb, 0x31, 0xa2,
+ 0xef, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa7, 0xcf, 0xf0, 0xa3, 0xef,
+ 0xf0, 0x90, 0x00, 0xbd, 0x80, 0x19, 0x90, 0x00, 0xc9, 0x31, 0xa2, 0xef, 0x12, 0x4e, 0x44, 0xe0,
+ 0xfb, 0xa3, 0xe0, 0x90, 0x04, 0xa7, 0xcb, 0xf0, 0xa3, 0xeb, 0xf0, 0xef, 0x12, 0x26, 0x5f, 0xe0,
+ 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa9, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0x90, 0x04, 0xa3, 0x12,
+ 0x2f, 0x86, 0xa3, 0x11, 0xea, 0x90, 0x04, 0xa7, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x05, 0x90,
+ 0x04, 0xa9, 0x11, 0xea, 0x90, 0x04, 0x83, 0x74, 0x02, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x13, 0xf0,
+ 0xf1, 0x39, 0x90, 0x04, 0x86, 0xec, 0xf0, 0x7b, 0x01, 0x7a, 0x04, 0x79, 0x9f, 0x7f, 0x0c, 0x02,
+ 0x2d, 0x51, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa1, 0xcf, 0xf0, 0xa3, 0x22, 0x90, 0x04, 0xc0,
+ 0x74, 0x06, 0xf0, 0x90, 0x04, 0xbf, 0xe0, 0x70, 0x08, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0x71, 0x43,
+ 0xf0, 0x22, 0xc2, 0x22, 0xe4, 0xff, 0x51, 0x41, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x51, 0x91,
+ 0x71, 0x9d, 0xf0, 0x12, 0x17, 0xb6, 0x51, 0x2b, 0xf1, 0xd0, 0x7f, 0x1e, 0x12, 0x3d, 0xf5, 0xc2,
+ 0x07, 0xc2, 0x05, 0x90, 0x00, 0xe1, 0x74, 0x02, 0xf0, 0x7a, 0xf8, 0xf1, 0x11, 0x74, 0x26, 0xf0,
+ 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe2, 0x42, 0xe0, 0x54, 0xfe, 0xf0, 0xe4, 0x90,
+ 0xe2, 0x41, 0xf0, 0x22, 0xe4, 0x90, 0x00, 0xe5, 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x44, 0x03, 0xf0,
+ 0x90, 0xe2, 0xa4, 0x74, 0x01, 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x54, 0xfc, 0xf0, 0x71, 0x96, 0x60,
+ 0x08, 0x12, 0x3e, 0x28, 0x12, 0x3f, 0xee, 0x51, 0x68, 0x80, 0xb8, 0x90, 0xe6, 0xa6, 0xe0, 0x30,
+ 0xe2, 0xf9, 0x90, 0xe2, 0xe7, 0xe0, 0x30, 0xe1, 0xf9, 0x90, 0xe2, 0xe7, 0xe0, 0x30, 0xe5, 0xf9,
+ 0x22, 0xe4, 0xfe, 0x90, 0x00, 0xfb, 0xe0, 0x60, 0x1c, 0x90, 0xe2, 0xa4, 0xe0, 0x54, 0x03, 0xff,
+ 0xbf, 0x03, 0x03, 0x7f, 0x08, 0x22, 0x90, 0xe2, 0xa6, 0x74, 0x03, 0xf0, 0x74, 0x01, 0xf1, 0x30,
+ 0xf0, 0x90, 0x00, 0xfb, 0xf0, 0xaf, 0x06, 0x22, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x51, 0x91,
+ 0x00, 0x12, 0x0e, 0x8d, 0x90, 0x04, 0x38, 0xe0, 0x90, 0xe2, 0x1f, 0xf0, 0x00, 0x90, 0xe2, 0x2e,
+ 0x74, 0x03, 0xf0, 0x00, 0x90, 0xe2, 0x19, 0x74, 0xa5, 0xf0, 0x00, 0x12, 0x0e, 0x8d, 0x02, 0x3c,
+ 0x72, 0x90, 0xe2, 0x21, 0x74, 0x20, 0xf0, 0x22, 0x8f, 0x2b, 0x8d, 0x0d, 0x85, 0x2b, 0x0c, 0x75,
+ 0x0f, 0x05, 0xe4, 0xf5, 0x0e, 0x85, 0x08, 0x11, 0xf5, 0x10, 0x85, 0x09, 0x13, 0x51, 0xd2, 0x12,
+ 0x28, 0x36, 0xe5, 0x2b, 0x44, 0x80, 0xf5, 0x0c, 0x85, 0x0b, 0x0f, 0x85, 0x0a, 0x0e, 0x90, 0x04,
+ 0xbf, 0xe0, 0xf5, 0x11, 0xa3, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5, 0x13, 0xe4, 0x51, 0xd2, 0x02,
+ 0x28, 0x36, 0xf5, 0x12, 0x78, 0x34, 0x7c, 0x00, 0xfd, 0xfb, 0x7a, 0x00, 0x79, 0x0c, 0xfe, 0x7f,
+ 0x08, 0x02, 0x0b, 0x10, 0xe4, 0xf5, 0x26, 0x90, 0x04, 0x7f, 0xf0, 0x53, 0x21, 0xfd, 0x90, 0x04,
+ 0x75, 0xe0, 0x70, 0x42, 0x90, 0x03, 0x49, 0xe0, 0x14, 0x60, 0x1e, 0x14, 0x60, 0x29, 0x24, 0x02,
+ 0x70, 0x2a, 0x90, 0xe6, 0x80, 0xe0, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x30, 0xe3, 0x02,
+ 0x71, 0x3b, 0x90, 0xe2, 0xa6, 0x74, 0x30, 0x80, 0x09, 0x7f, 0x1e, 0x71, 0x4d, 0x90, 0xe2, 0xa6,
+ 0x74, 0x03, 0x71, 0x43, 0xf0, 0x80, 0x08, 0x75, 0x26, 0x01, 0x80, 0x03, 0x75, 0x26, 0x26, 0xad,
+ 0x26, 0x7f, 0x01, 0x02, 0x2a, 0xeb, 0x7f, 0x01, 0x02, 0x2d, 0x18, 0x90, 0xe6, 0x80, 0xe0, 0x44,
+ 0x08, 0xf0, 0x22, 0xf0, 0xe4, 0x90, 0xe2, 0xa4, 0xf0, 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x00, 0xc8,
+ 0xe0, 0x5f, 0xff, 0x90, 0x00, 0xe3, 0xe0, 0x70, 0x03, 0x7f, 0x11, 0x22, 0xef, 0x54, 0x1e, 0x60,
+ 0x07, 0x71, 0x6f, 0x90, 0x00, 0xc8, 0xef, 0xf0, 0xe4, 0x90, 0x00, 0xe3, 0xf0, 0xff, 0x22, 0x71,
+ 0x96, 0xfe, 0x5f, 0xfd, 0x60, 0x0f, 0xff, 0xc2, 0x14, 0x71, 0xe5, 0xe4, 0xfb, 0xfd, 0xff, 0x12,
+ 0x1e, 0x6b, 0x71, 0x9d, 0xf0, 0x43, 0xb4, 0x41, 0xe4, 0x90, 0x00, 0xc6, 0xf0, 0x43, 0xa0, 0x40,
+ 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x90, 0x00, 0xc8, 0xe0, 0x54, 0x1e, 0x22, 0x12, 0x0e, 0x7c,
+ 0x90, 0x00, 0xc8, 0xe0, 0x54, 0xe1, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0xe1, 0x22, 0xe4, 0xf5,
+ 0x19, 0xef, 0x30, 0xe0, 0x1c, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x70, 0x25, 0x91, 0x6b, 0x70,
+ 0x21, 0x90, 0x00, 0xc7, 0xe0, 0xff, 0x71, 0x96, 0xfe, 0xef, 0x4e, 0x90, 0x00, 0xc7, 0xf0, 0x80,
+ 0x11, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x60, 0x04, 0xc2, 0x14, 0x71, 0xe5, 0x71, 0xa7, 0xf0,
+ 0x91, 0x88, 0xaf, 0x19, 0x22, 0xe4, 0xfc, 0x12, 0x1f, 0xf1, 0x30, 0x14, 0x04, 0xf1, 0x42, 0x7c,
+ 0x26, 0xad, 0x04, 0xe4, 0xfb, 0x7f, 0x1c, 0x12, 0x1e, 0x6b, 0xec, 0x60, 0x03, 0x12, 0x20, 0x07,
+ 0xaf, 0x19, 0x22, 0x8f, 0x2b, 0xe5, 0x5c, 0x55, 0x2b, 0x60, 0x03, 0x7f, 0x00, 0x22, 0xe5, 0x2b,
+ 0xf4, 0xff, 0x90, 0x00, 0xba, 0xe0, 0x5f, 0xf0, 0xed, 0x60, 0x35, 0xe0, 0x45, 0x2b, 0xf0, 0xe5,
+ 0x2b, 0x14, 0xff, 0x51, 0x41, 0x30, 0x27, 0x40, 0x20, 0x20, 0x3d, 0x90, 0x00, 0xb9, 0xe0, 0x60,
+ 0x37, 0x12, 0x37, 0x8c, 0x12, 0x0e, 0x97, 0xd2, 0x20, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x00, 0x90,
+ 0xe6, 0x12, 0x74, 0xa0, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x12, 0x37, 0xe9, 0x80, 0x18,
+ 0x74, 0xc5, 0x25, 0x2b, 0x12, 0x2f, 0x01, 0xff, 0x60, 0x0b, 0x90, 0x00, 0xc7, 0xe0, 0x5f, 0x70,
+ 0x04, 0x7f, 0x01, 0x71, 0xae, 0x12, 0x48, 0x17, 0x7f, 0x01, 0x22, 0xd2, 0x14, 0x71, 0xe5, 0xef,
+ 0x22, 0x71, 0x96, 0x60, 0x0c, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x3e, 0x28, 0x91,
+ 0x88, 0x90, 0x00, 0xe5, 0x74, 0x5a, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x90, 0x04, 0x38, 0xf0,
+ 0x22, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x10, 0x75, 0x5b, 0x02, 0xb1, 0x1c, 0x90, 0xe6, 0xa3, 0x74,
+ 0x01, 0xf0, 0x90, 0xe6, 0xa5, 0xf0, 0x22, 0x74, 0x00, 0xf5, 0x9a, 0x74, 0x7e, 0xf5, 0x9b, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xba, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbb, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbc, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbd, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb9, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb8, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb7, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb6, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0xb1, 0x93, 0x24, 0xff, 0x92, 0x10, 0xe0, 0x54, 0x0f, 0xff, 0xc2, 0x2f, 0xa2,
+ 0x10, 0x92, 0x11, 0x12, 0x14, 0xd0, 0x8f, 0x5b, 0x90, 0x00, 0xfd, 0xe0, 0x20, 0xe2, 0x05, 0x20,
+ 0x2f, 0x02, 0xb1, 0x15, 0x22, 0xc2, 0x00, 0xb1, 0x1c, 0xd2, 0x2f, 0x22, 0x90, 0x00, 0xad, 0xe0,
+ 0x60, 0x69, 0xf1, 0x5a, 0x7f, 0x02, 0x12, 0x36, 0xf2, 0x12, 0x0e, 0xb8, 0x7a, 0xf8, 0x79, 0x00,
+ 0x7e, 0xf8, 0xf1, 0x27, 0x78, 0x7c, 0x74, 0x55, 0xf2, 0x74, 0x53, 0xf2, 0x74, 0x42, 0xf2, 0x74,
+ 0x53, 0xf2, 0x90, 0x04, 0xba, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2,
+ 0x90, 0x04, 0xb9, 0xe0, 0xf2, 0x90, 0x04, 0xb8, 0xe0, 0xf2, 0x90, 0x04, 0xb7, 0xe0, 0xf2, 0x90,
+ 0x04, 0xb6, 0xe0, 0xf2, 0xe5, 0x5b, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01, 0x78, 0x7c, 0xef, 0xf2,
+ 0x00, 0x00, 0x00, 0xe4, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x99, 0x74, 0x0d, 0xf2, 0x12,
+ 0x0e, 0xe6, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x03, 0x12, 0x17, 0xe6, 0x22, 0x25, 0xe0, 0xff, 0x12,
+ 0x0b, 0x4f, 0xfe, 0xc4, 0x13, 0x13, 0x13, 0x54, 0x01, 0x22, 0x8b, 0x3b, 0x8a, 0x3c, 0x89, 0x3d,
+ 0xc0, 0x03, 0xc0, 0x02, 0xc0, 0x01, 0x12, 0x0c, 0x67, 0xf1, 0xde, 0x12, 0x0c, 0xad, 0x12, 0x0b,
+ 0xc6, 0xd0, 0x01, 0xd0, 0x02, 0xd0, 0x03, 0x12, 0x0c, 0x87, 0x90, 0x04, 0x39, 0xe0, 0xab, 0x3b,
+ 0xaa, 0x3c, 0xa9, 0x3d, 0x70, 0x20, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0x90, 0x00, 0x02, 0xb1,
+ 0x8c, 0x4f, 0xf5, 0x1a, 0xee, 0x90, 0x00, 0x03, 0xb1, 0x8c, 0x4f, 0xf5, 0x1b, 0xee, 0x25, 0xe0,
+ 0xf5, 0x1c, 0xe4, 0xf5, 0x1d, 0x22, 0x12, 0x0b, 0x36, 0xf5, 0x1a, 0x90, 0x00, 0x01, 0x12, 0x0b,
+ 0x4f, 0xf5, 0x1b, 0x90, 0x00, 0x02, 0x12, 0x0b, 0x4f, 0xf5, 0x1c, 0x90, 0x00, 0x03, 0x12, 0x0b,
+ 0x4f, 0xf5, 0x1d, 0x22, 0x30, 0x15, 0x07, 0xc2, 0x1b, 0x12, 0x17, 0x53, 0x80, 0x02, 0xd1, 0x1b,
+ 0x12, 0x14, 0xc2, 0xe5, 0x34, 0xf0, 0x75, 0x5b, 0x22, 0xa1, 0x15, 0xe4, 0xf5, 0x3b, 0xf5, 0x3c,
+ 0x78, 0x04, 0x74, 0x80, 0xf2, 0x12, 0x0e, 0x97, 0xe5, 0xaa, 0x20, 0xe0, 0x2e, 0x90, 0xe6, 0xa3,
+ 0xe0, 0xc4, 0x54, 0x07, 0xff, 0x60, 0x13, 0x7e, 0x00, 0x90, 0x00, 0xa9, 0xe0, 0xfc, 0xa3, 0xe0,
+ 0xfd, 0x12, 0x0b, 0x9e, 0x8e, 0x3b, 0x8f, 0x3c, 0x80, 0x11, 0x90, 0xe6, 0x90, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0x7c, 0x00, 0x24, 0x00, 0xf5, 0x3c, 0xec, 0x3e, 0xf5, 0x3b, 0xae, 0x3b, 0xaf, 0x3c, 0xf1,
+ 0x4d, 0x40, 0x0d, 0x90, 0xe6, 0xa3, 0xe0, 0x44, 0x01, 0xf0, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22,
+ 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x7f, 0x02, 0x02, 0x36, 0xf2, 0xe4, 0x90, 0x00, 0xb6, 0xf0, 0x90,
+ 0x00, 0xc7, 0xf0, 0x90, 0x00, 0xb9, 0xf0, 0xa3, 0xf0, 0xf5, 0x5c, 0x90, 0x00, 0xdd, 0xf0, 0x90,
+ 0x00, 0xdc, 0xf0, 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xbb, 0x74, 0x08, 0xf0, 0xa3, 0xe4, 0xf0,
+ 0xa3, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xc9, 0x74, 0x02, 0xf0, 0xa3, 0xe4,
+ 0xf0, 0x12, 0x26, 0x5b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x00, 0xc8, 0xf0,
+ 0xf1, 0x09, 0x74, 0x38, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x02, 0xf0, 0xc2, 0x23, 0xe4, 0x90,
+ 0x00, 0xe6, 0xf0, 0xc2, 0x20, 0x90, 0x00, 0xc5, 0xf0, 0xa3, 0xf0, 0xc2, 0x21, 0x90, 0x00, 0xeb,
+ 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0x90, 0x00, 0xe7, 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0xa3, 0x74, 0x01, 0xf0, 0xa3, 0xf0, 0xe4,
+ 0xf5, 0xb2, 0x75, 0xb4, 0x40, 0x75, 0xa0, 0x40, 0x22, 0x90, 0x00, 0xe1, 0x74, 0x14, 0xf0, 0x7a,
+ 0xfc, 0x7b, 0x01, 0x79, 0x00, 0x90, 0x00, 0xde, 0x12, 0x0d, 0x22, 0x90, 0x00, 0xe2, 0x22, 0x90,
+ 0x00, 0xfd, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0x74, 0xf8, 0xf5, 0x9d, 0x74, 0x00, 0xf5, 0x9e, 0x22,
+ 0x90, 0xe2, 0xa4, 0xf0, 0xe4, 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x03, 0x50, 0xe0, 0x90, 0x04, 0x85,
+ 0xf0, 0x22, 0x90, 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0xa3, 0xe0, 0xf5, 0x1b, 0x22, 0xe4, 0xfc, 0xfd,
+ 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xad, 0xd3, 0x02, 0x0c, 0x30, 0xe5, 0x14, 0xb4, 0x05, 0x08, 0x90,
+ 0xe6, 0xa5, 0xe0, 0x54, 0x09, 0x70, 0xf8, 0x22, 0x12, 0x4d, 0x72, 0x90, 0x04, 0x95, 0xef, 0xf0,
+ 0xbf, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0xfe, 0x54, 0xc0, 0xff,
+ 0xbf, 0xc0, 0x03, 0x7f, 0x8f, 0x22, 0xee, 0x54, 0x3f, 0xff, 0x64, 0x3f, 0x60, 0x05, 0xef, 0x64,
+ 0x1c, 0x70, 0x30, 0xf1, 0x5a, 0x7b, 0x40, 0x12, 0x37, 0x2f, 0xf1, 0x27, 0x90, 0xe6, 0x7c, 0x74,
+ 0x03, 0xf0, 0xe4, 0xf0, 0x90, 0x04, 0x95, 0xe0, 0xb4, 0x01, 0x0c, 0xf1, 0xc9, 0x60, 0x08, 0x90,
+ 0xe6, 0x7c, 0x74, 0x80, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xe4, 0x90, 0xe6, 0x7c,
+ 0xf0, 0x80, 0x03, 0x7f, 0x85, 0x22, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x32, 0xe0, 0x54, 0x03, 0x22,
+ 0x90, 0x00, 0xdd, 0xe0, 0x54, 0xfd, 0xf0, 0x90, 0xe2, 0x42, 0x74, 0x25, 0xf0, 0x22, 0x90, 0x00,
+ 0xdb, 0xe0, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xd3, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22,
+ 0x90, 0x00, 0xba, 0xe0, 0xf4, 0xff, 0x90, 0x00, 0xb9, 0xe0, 0xfe, 0x5f, 0xfd, 0x75, 0x14, 0x05,
+ 0xee, 0x60, 0x13, 0x90, 0x00, 0xad, 0x74, 0x01, 0xf0, 0xed, 0x60, 0x05, 0x7f, 0x0a, 0x12, 0x2f,
+ 0xa8, 0x20, 0x27, 0x02, 0x11, 0x17, 0x22, 0x30, 0x20, 0x2f, 0x12, 0x37, 0x8c, 0x7f, 0x02, 0x12,
+ 0x36, 0xf2, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x90, 0xe6, 0x12, 0x74, 0xa2, 0xf0, 0x00, 0xe4, 0x90,
+ 0xe6, 0x18, 0xf0, 0x00, 0x90, 0xe6, 0x13, 0x74, 0x22, 0xf0, 0x00, 0x90, 0xe6, 0x19, 0x74, 0x20,
+ 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0xc2, 0x20, 0x22, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x12, 0x32, 0xb0, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0,
+ 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0,
+ 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0,
+ 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xe5, 0x14, 0xd3, 0x94, 0x04,
+ 0x40, 0x02, 0x11, 0xb8, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x00, 0xd0,
+ 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x37, 0x0e, 0x75,
+ 0x14, 0x04, 0x22, 0x8f, 0x3a, 0x74, 0xff, 0xf5, 0x3b, 0xf5, 0x3c, 0xe4, 0xf5, 0x3d, 0xe5, 0x3c,
+ 0x15, 0x3c, 0xae, 0x3b, 0x70, 0x02, 0x15, 0x3b, 0x4e, 0x60, 0x0d, 0x90, 0xe6, 0xa5, 0xe0, 0x55,
+ 0x3a, 0x60, 0x05, 0x12, 0x0e, 0x8d, 0x80, 0xe6, 0x90, 0xe6, 0xa5, 0xe0, 0x55, 0x3a, 0x60, 0x20,
+ 0x75, 0x3d, 0x99, 0xe4, 0x90, 0xe6, 0x1a, 0xf0, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00,
+ 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x31, 0x48, 0xe5, 0x14, 0xd3, 0x94, 0x04, 0x40, 0x02, 0x11, 0xb8,
+ 0xaf, 0x3d, 0x22, 0x91, 0xb5, 0x12, 0x47, 0x29, 0xe4, 0xf5, 0x39, 0x7f, 0x08, 0x11, 0xc3, 0xef,
+ 0x60, 0x03, 0x7f, 0x99, 0x22, 0x74, 0xf8, 0x91, 0xa4, 0xff, 0x91, 0xac, 0x0f, 0xbf, 0x40, 0xfa,
+ 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0xa3, 0x74, 0x40, 0xf0, 0x05, 0x39, 0xe5, 0x39, 0xc3, 0x94, 0x08,
+ 0x40, 0xd9, 0x12, 0x25, 0xac, 0x7f, 0x00, 0x22, 0x90, 0xe6, 0x1a, 0x74, 0x40, 0xf0, 0x22, 0xb1,
+ 0x72, 0x8f, 0x33, 0xe5, 0x33, 0xb4, 0x02, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x03, 0x12,
+ 0x46, 0x04, 0x7f, 0x84, 0x22, 0x20, 0x14, 0x10, 0x30, 0x1e, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75,
+ 0x34, 0x0d, 0x12, 0x46, 0x04, 0x7f, 0x38, 0x22, 0xe5, 0x33, 0x64, 0x01, 0x70, 0x24, 0x90, 0x00,
+ 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x3e, 0x28, 0x12, 0x3c, 0x72, 0x30, 0x14, 0x0e, 0x7f, 0x01,
+ 0x12, 0x1e, 0xef, 0x51, 0x3a, 0x12, 0x24, 0x6b, 0x8f, 0x32, 0x80, 0x06, 0x51, 0x3a, 0x51, 0x43,
+ 0x8f, 0x32, 0x31, 0x48, 0x20, 0x2a, 0x03, 0x12, 0x3d, 0xb9, 0x30, 0x14, 0x26, 0x90, 0x00, 0xef,
+ 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0x12, 0x3f, 0xd9, 0xed, 0xff,
+ 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00,
+ 0xef, 0x80, 0x24, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0,
+ 0x03, 0x12, 0x3f, 0xd9, 0xed, 0xff, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xd9, 0x30, 0x21, 0x21, 0x90, 0x00, 0xf3,
+ 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xeb, 0x12, 0x17, 0x4c, 0x50, 0x0e, 0x90, 0x00, 0xf7, 0x12, 0x0c,
+ 0xa1, 0x90, 0x00, 0xef, 0x12, 0x17, 0x4c, 0x40, 0x05, 0xd2, 0x15, 0x12, 0x28, 0x5a, 0x30, 0x0a,
+ 0x0e, 0x90, 0x04, 0x76, 0xe0, 0xb4, 0x12, 0x07, 0x91, 0xec, 0xc2, 0x15, 0x12, 0x28, 0x5a, 0x30,
+ 0x23, 0x03, 0x12, 0x1f, 0x2c, 0xc2, 0x22, 0xaf, 0x32, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31,
+ 0x7f, 0x01, 0x22, 0x91, 0xf5, 0x75, 0x39, 0x64, 0xe4, 0xf5, 0x3a, 0xf5, 0x19, 0xe5, 0x35, 0x60,
+ 0x02, 0xb1, 0x5a, 0x12, 0x47, 0xc9, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x70, 0x0b, 0x12,
+ 0x14, 0xc2, 0x74, 0x0d, 0xf0, 0x75, 0x19, 0x38, 0x61, 0xf8, 0x91, 0x1a, 0x91, 0xbe, 0xef, 0x60,
+ 0x05, 0x75, 0x19, 0x0c, 0x61, 0xf8, 0x91, 0x1a, 0x12, 0x3f, 0xdf, 0xb1, 0x08, 0x4e, 0x70, 0x02,
+ 0x61, 0xf8, 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x35, 0x70, 0x02, 0x61, 0x53, 0x30, 0x27, 0x02,
+ 0x61, 0x53, 0x91, 0x1a, 0x12, 0x45, 0x9a, 0xe4, 0x78, 0x18, 0xf2, 0x78, 0x15, 0x74, 0x22, 0xf2,
+ 0xe4, 0x78, 0x1b, 0xf2, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x49, 0x74, 0x88, 0xf2, 0xf2, 0x12,
+ 0x27, 0xe1, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x64, 0x12, 0x1e, 0x6b, 0x80, 0x6e, 0x90, 0x04, 0x2a,
+ 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x69, 0xe5, 0x19, 0x70, 0x65, 0x12, 0x25, 0xac, 0x91, 0xb5,
+ 0x91, 0xa4, 0xfd, 0x90, 0xe6, 0xa3, 0xe0, 0x30, 0xe2, 0x03, 0x30, 0x22, 0xf6, 0x90, 0xe6, 0x91,
+ 0xe0, 0xc3, 0x94, 0x40, 0x50, 0x03, 0x30, 0x22, 0xf4, 0x20, 0x22, 0x1f, 0x7a, 0xf0, 0x79, 0x00,
+ 0x74, 0xf0, 0x12, 0x47, 0x29, 0x7f, 0x40, 0xae, 0x07, 0x1f, 0xee, 0x60, 0x04, 0x91, 0xac, 0x80,
+ 0xf6, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0x0d, 0xbd, 0x08, 0xc8, 0x90, 0xe6, 0x9c, 0x12, 0x23,
+ 0xd8, 0x8f, 0x3a, 0x12, 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0xfb, 0x7d, 0x26, 0x7f, 0x34,
+ 0x12, 0x1e, 0x6b, 0x91, 0xfe, 0xe5, 0x3a, 0x60, 0x02, 0xf5, 0x19, 0x12, 0x20, 0x07, 0x80, 0x8d,
+ 0x12, 0x27, 0x86, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x48, 0x74, 0x88, 0xf2, 0xf2, 0x12, 0x1f,
+ 0xb9, 0xe5, 0x19, 0x60, 0x02, 0x61, 0xe8, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0x61, 0xe8, 0x90, 0x00, 0xe1, 0xb1, 0x29, 0x20, 0x2a, 0x2a, 0x91, 0x1a, 0x12, 0x45, 0x9a,
+ 0xe4, 0xfb, 0x7d, 0x26, 0xaf, 0x39, 0x12, 0x20, 0x5d, 0xef, 0x70, 0x29, 0x91, 0x21, 0x70, 0x0a,
+ 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0, 0x60, 0x1b, 0x12, 0x14, 0xc2, 0x74, 0x01, 0xf0,
+ 0x75, 0x19, 0x37, 0x80, 0x63, 0x12, 0x1f, 0xf1, 0x90, 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0xa3, 0x12,
+ 0x1f, 0xfb, 0xef, 0x70, 0x21, 0x90, 0x04, 0x2a, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x7b, 0x00, 0x7a,
+ 0x02, 0xaf, 0x35, 0x91, 0x28, 0x12, 0x23, 0xde, 0xe5, 0x19, 0x70, 0x0a, 0x90, 0x04, 0xb6, 0x12,
+ 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x35, 0x60, 0x10, 0xe5, 0x19, 0x70, 0x0c, 0x90, 0x04,
+ 0x2a, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x80, 0x60, 0x1c, 0x12, 0x1f, 0xb9, 0xef, 0x70, 0x18,
+ 0x91, 0x21, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0, 0x60, 0x0a, 0x12, 0x14,
+ 0xbf, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x2a, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0xa3, 0x74, 0x20,
+ 0xf0, 0xe5, 0x19, 0x60, 0x03, 0x75, 0x19, 0x37, 0xb1, 0x1e, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34,
+ 0xf0, 0xe5, 0x35, 0x60, 0x10, 0x20, 0x22, 0x0d, 0xb1, 0x13, 0x60, 0x03, 0x12, 0x46, 0x1b, 0x85,
+ 0x19, 0x5b, 0x12, 0x45, 0x15, 0xb1, 0x48, 0xaf, 0x19, 0x22, 0xab, 0x36, 0xaa, 0x37, 0xa9, 0x38,
+ 0x22, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0x03, 0x22, 0x7e, 0x32, 0xef, 0x60, 0x31, 0x12, 0x37, 0x8c,
+ 0x30, 0x27, 0x02, 0x7e, 0x0a, 0xaf, 0x06, 0x1e, 0xef, 0x60, 0x08, 0x90, 0x00, 0x7a, 0xe0, 0xf5,
+ 0x3b, 0x80, 0xf2, 0xe5, 0xaa, 0x20, 0xe0, 0x09, 0x90, 0xe6, 0x49, 0x74, 0x02, 0xf0, 0x00, 0x80,
+ 0xf2, 0x90, 0xe6, 0x18, 0x74, 0x30, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0xd3, 0xed,
+ 0x94, 0x01, 0xec, 0x94, 0x00, 0x40, 0x1c, 0x90, 0xe6, 0xa4, 0xe0, 0x20, 0xe3, 0x04, 0x30, 0x22,
+ 0xf6, 0x22, 0x91, 0x9d, 0x12, 0x1e, 0xe2, 0x91, 0x9d, 0x12, 0x1e, 0xe2, 0x90, 0xe6, 0x19, 0x74,
+ 0x30, 0xf0, 0x22, 0x90, 0xe6, 0xa4, 0xe0, 0x30, 0xe2, 0x04, 0x30, 0x22, 0xf6, 0x22, 0x90, 0xe6,
+ 0x94, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xc3, 0x9b, 0xee, 0x9a, 0x40, 0xf1, 0x90, 0xe6, 0x49,
+ 0x74, 0x04, 0xf0, 0x22, 0xf5, 0x9a, 0x74, 0x00, 0xf5, 0x9b, 0xe4, 0x22, 0x90, 0xe6, 0x7c, 0xe0,
+ 0x90, 0xe6, 0x7b, 0xf0, 0x22, 0x7a, 0xfc, 0x79, 0x00, 0x7e, 0xfc, 0x74, 0xfc, 0x22, 0x12, 0x3f,
+ 0xdf, 0xed, 0xff, 0xe4, 0xfc, 0xfd, 0x12, 0x0c, 0xb9, 0x12, 0x0b, 0xc6, 0x90, 0x04, 0x2c, 0x12,
+ 0x0c, 0xd9, 0x12, 0x26, 0x5b, 0xb1, 0x38, 0xfc, 0x90, 0x04, 0x2c, 0x12, 0x47, 0x53, 0x40, 0x09,
+ 0x12, 0x14, 0xc2, 0x74, 0x08, 0xf0, 0x7f, 0x0c, 0x22, 0x7f, 0x00, 0x22, 0xe4, 0x90, 0x04, 0x80,
+ 0xf0, 0x53, 0x21, 0xfb, 0x22, 0x8f, 0x35, 0x8b, 0x36, 0x8a, 0x37, 0x89, 0x38, 0x22, 0x90, 0x04,
+ 0x2a, 0x74, 0xff, 0xf5, 0xf0, 0x02, 0x0b, 0xb0, 0x90, 0x04, 0x2a, 0xed, 0xff, 0xee, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x22, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1, 0xec, 0x4d, 0x4e, 0x4f, 0x22, 0x90, 0xe2,
+ 0x31, 0x74, 0x08, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x22, 0xe0, 0x54, 0x30, 0xff, 0x90, 0x04, 0x2a,
+ 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x02, 0x27, 0xe7, 0x12, 0x0c, 0xa1, 0xef, 0x24, 0x01, 0xff, 0xe4,
+ 0x3e, 0xfe, 0xe4, 0x3d, 0xfd, 0xe4, 0x3c, 0x22, 0xe4, 0x90, 0x00, 0xfc, 0xf0, 0xc2, 0xab, 0xc2,
+ 0x8e, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x30, 0xf5, 0x89, 0x22, 0x90, 0x00, 0xfc, 0x74, 0x04, 0xf0,
+ 0xe4, 0xf5, 0x8d, 0xf5, 0x8b, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x10, 0xf5, 0x89, 0xd2, 0x8e, 0xd2,
+ 0xab, 0x22, 0x90, 0x00, 0xc7, 0xe0, 0xfe, 0xa3, 0xe0, 0x5e, 0xbf, 0x01, 0x0e, 0x54, 0x1e, 0x60,
+ 0x0a, 0x90, 0x00, 0xba, 0xe0, 0x30, 0xe1, 0x03, 0x7f, 0x01, 0x22, 0x7f, 0x02, 0x22, 0x8d, 0x2e,
+ 0xe4, 0xfd, 0xb1, 0x72, 0xac, 0x07, 0xbc, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x12, 0x47, 0x5a, 0x12,
+ 0x47, 0x27, 0xe5, 0x2e, 0xb4, 0x23, 0x0c, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xf0, 0xf0, 0x74, 0x08,
+ 0xf0, 0x7d, 0x02, 0xec, 0x70, 0x2a, 0x90, 0x00, 0xbd, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xbe, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xc0, 0xd1, 0x13, 0x90, 0x00, 0xbb, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbc, 0x80, 0x2b,
+ 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x12, 0x26, 0x5f, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0xd1, 0x36,
+ 0xe0, 0x90, 0xe6, 0x7c, 0xd1, 0x44, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0xd1, 0x28, 0xd1, 0x13,
+ 0x90, 0x00, 0xc9, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xca, 0xe0, 0x90, 0xe6, 0x7c, 0xf0,
+ 0x7f, 0x00, 0x22, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xed, 0xf0, 0xe4, 0xf0, 0x22, 0xb1, 0x72, 0xbf,
+ 0x02, 0x03, 0x7f, 0x84, 0x22, 0x7f, 0x00, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xce, 0xf5, 0x82,
+ 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcc, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0x22, 0xf0, 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcd,
+ 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0xac, 0x07, 0xb1, 0x72, 0xbf, 0x02, 0x03, 0x7f,
+ 0x84, 0x22, 0xec, 0x04, 0xff, 0xed, 0x60, 0x05, 0xef, 0x42, 0x5c, 0x80, 0x04, 0xef, 0xf4, 0x52,
+ 0x5c, 0x7f, 0x00, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0,
+ 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0xe6, 0x80,
+ 0xe0, 0x30, 0xe7, 0x23, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0xcf, 0xd1, 0xf8, 0x90, 0x00,
+ 0x68, 0x12, 0x18, 0x7b, 0xf0, 0x90, 0x00, 0xa9, 0x74, 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x7d, 0x01,
+ 0x7f, 0x06, 0x12, 0x37, 0x0e, 0xd2, 0x27, 0x90, 0x00, 0x6c, 0x12, 0x3a, 0x7c, 0x12, 0x36, 0xbd,
+ 0x90, 0x00, 0x6e, 0xe0, 0xfe, 0xa3, 0xe0, 0xaa, 0x06, 0xf9, 0x90, 0x00, 0x01, 0x74, 0x07, 0x12,
+ 0x0b, 0x7c, 0x90, 0x00, 0xa9, 0xe0, 0x78, 0x24, 0xf2, 0xa3, 0xe0, 0x78, 0x25, 0xf2, 0x12, 0x37,
+ 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0,
+ 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x00, 0x6c, 0xf0, 0xa3, 0xef, 0xf0, 0x22,
+ 0x12, 0x37, 0xf3, 0xd2, 0x28, 0x32, 0x12, 0x37, 0xf3, 0x32, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x78, 0x8b, 0xe2, 0xff, 0xc3, 0x90, 0x00, 0xb2, 0xe0,
+ 0x9f, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x94, 0x00, 0xf0, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x05,
+ 0x12, 0x37, 0xd8, 0xd2, 0x26, 0x74, 0x43, 0x12, 0x3a, 0x74, 0x74, 0x0c, 0xf0, 0x90, 0x04, 0x85,
+ 0x74, 0x40, 0xf0, 0x78, 0x8b, 0xe2, 0x90, 0x04, 0x86, 0xf0, 0x7a, 0xe7, 0x79, 0x40, 0x12, 0x2d,
+ 0x4d, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02,
+ 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0,
+ 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01,
+ 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x04, 0x83, 0x74,
+ 0x43, 0xf0, 0x74, 0x0c, 0x12, 0x3f, 0xf6, 0x74, 0x60, 0xf0, 0x78, 0x8d, 0xe2, 0x90, 0x04, 0x86,
+ 0xf0, 0x7a, 0xe7, 0x79, 0x80, 0x12, 0x2d, 0x4d, 0x12, 0x37, 0xd8, 0x78, 0x8d, 0xe4, 0xf2, 0x53,
+ 0x91, 0xef, 0xf5, 0xa1, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02,
+ 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0,
+ 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x06, 0xc0, 0x07,
+ 0xe4, 0x53, 0x91, 0xef, 0xf5, 0xa1, 0x20, 0x00, 0x65, 0x90, 0xe6, 0xa3, 0xe0, 0x20, 0xe2, 0x5e,
+ 0x90, 0xf0, 0x00, 0xe0, 0xb4, 0x55, 0x17, 0xa3, 0xe0, 0xb4, 0x53, 0x12, 0xa3, 0xe0, 0xb4, 0x42,
+ 0x0d, 0xa3, 0xe0, 0xb4, 0x43, 0x08, 0x90, 0xe6, 0x91, 0xe0, 0x64, 0x1f, 0x60, 0x15, 0x90, 0x00,
+ 0xab, 0x74, 0x01, 0xf0, 0x78, 0x49, 0x74, 0x82, 0xf2, 0x78, 0xa3, 0x74, 0x01, 0xf2, 0x78, 0xa5,
+ 0xf2, 0x80, 0x2b, 0x7f, 0x00, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf0, 0xf5, 0x83, 0xe0,
+ 0xfe, 0x74, 0x7a, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xee, 0xf0, 0x0f, 0xbf, 0x1f,
+ 0xe4, 0x90, 0xf0, 0x00, 0xe4, 0xf0, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0xd2, 0x00, 0xd0, 0x07,
+ 0xd0, 0x06, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x32, 0x8e, 0x35,
+ 0x8f, 0x36, 0xe5, 0x36, 0x25, 0xe0, 0xf5, 0x36, 0xe5, 0x35, 0x33, 0xf5, 0x35, 0xe5, 0x36, 0x15,
+ 0x36, 0xae, 0x35, 0x70, 0x02, 0x15, 0x35, 0x4e, 0x60, 0x05, 0x12, 0x0e, 0x7c, 0x80, 0xee, 0x22,
+ 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0x90, 0x04, 0xc4, 0xe0, 0x60, 0x29, 0x43, 0xb4, 0x40, 0x90, 0x00,
+ 0xe6, 0xe0, 0x60, 0x0e, 0x43, 0xa0, 0x40, 0x7f, 0x96, 0x7e, 0x00, 0x11, 0x6e, 0x53, 0xa0, 0xbf,
+ 0x80, 0x0c, 0x53, 0xa0, 0xbf, 0x7f, 0x96, 0x7e, 0x00, 0x11, 0x6e, 0x43, 0xa0, 0x40, 0x7f, 0x96,
+ 0x7e, 0x00, 0x11, 0x6e, 0x22, 0x78, 0x80, 0xe2, 0x44, 0x0a, 0xf2, 0x7f, 0x64, 0x7e, 0x00, 0x11,
+ 0x6e, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x90, 0xe3, 0x5f, 0xf0, 0x78, 0x5f, 0xf2, 0x53, 0x91, 0xef,
+ 0x22, 0x11, 0xc5, 0x78, 0x80, 0xe2, 0x44, 0x04, 0xf2, 0xe2, 0x54, 0xf7, 0xf2, 0x22, 0x7b, 0x09,
+ 0xef, 0x70, 0x02, 0xc3, 0x22, 0xbf, 0x01, 0x02, 0x7b, 0x0b, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1,
+ 0xa8, 0x03, 0x12, 0x0c, 0x41, 0x90, 0x00, 0x90, 0xe0, 0x6e, 0x70, 0x03, 0xa3, 0xe0, 0x6f, 0xc3,
+ 0x60, 0x01, 0xd3, 0x22, 0x7e, 0x01, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1e, 0x90, 0x00, 0xdc,
+ 0xe0, 0x60, 0x3c, 0xef, 0xd3, 0x94, 0x01, 0x40, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0xff,
+ 0x22, 0xef, 0x60, 0x10, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x17, 0x20, 0x1c, 0x02, 0x80, 0x12,
+ 0xd2, 0x1e, 0x80, 0x18, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x04, 0xe4, 0xfe, 0x80, 0x0d, 0x20,
+ 0x1c, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x1e, 0xaf, 0x06, 0x22, 0xef,
+ 0x60, 0x03, 0x7f, 0x01, 0x22, 0x90, 0x00, 0xb9, 0xe0, 0x7f, 0x01, 0x30, 0xe0, 0x02, 0x7f, 0x00,
+ 0x22, 0x8b, 0x54, 0x8a, 0x55, 0x89, 0x56, 0x12, 0x1d, 0x5b, 0x90, 0x04, 0x73, 0xe0, 0x8d, 0x82,
+ 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x12, 0x2e, 0x83, 0xef, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xeb,
+ 0xf0, 0xa3, 0xe5, 0x29, 0xf0, 0xa3, 0xe5, 0x2a, 0xf0, 0xa3, 0xe5, 0x2b, 0xf0, 0x74, 0xc0, 0x12,
+ 0x2f, 0xfc, 0x74, 0x7f, 0xf0, 0x7f, 0x01, 0x02, 0x2d, 0xf7, 0x75, 0x92, 0xe6, 0x90, 0xe6, 0x0d,
+ 0x74, 0x01, 0xf0, 0xa3, 0x74, 0x0a, 0xf0, 0x90, 0xe6, 0x00, 0x74, 0x14, 0xf0, 0xc2, 0x88, 0x43,
+ 0xb8, 0x04, 0xe4, 0xf5, 0x8e, 0x78, 0x82, 0x74, 0x05, 0xf2, 0x75, 0xaf, 0x07, 0x78, 0x04, 0x74,
+ 0x02, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x12, 0x74, 0xa2, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x18,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x04, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x13, 0x74, 0x22,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x19, 0x74, 0x20, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x06,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x14, 0x74, 0xe2, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1a, 0x74, 0x40,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x15, 0x74, 0x62,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x04, 0xf2,
+ 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04, 0xf0, 0x90, 0xe2, 0xa6, 0xf0, 0xa3, 0xf0, 0x00, 0x00, 0x00,
+ 0x78, 0x0b, 0x74, 0x03, 0xf2, 0x00, 0x00, 0x00, 0x90, 0xe2, 0x1f, 0x74, 0x20, 0xf0, 0x90, 0xe4,
+ 0xdf, 0xf0, 0x75, 0xe8, 0x03, 0xd2, 0xdd, 0xc2, 0x1c, 0xd2, 0x1d, 0x22, 0xc0, 0xe0, 0xc0, 0x83,
+ 0xc0, 0x82, 0x90, 0xe2, 0x43, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x06, 0x90,
+ 0xe2, 0x41, 0x74, 0x01, 0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x07, 0xc2, 0x8b, 0x90, 0x00, 0xe8, 0xe0, 0xff,
+ 0x90, 0xe2, 0x31, 0xe0, 0x5f, 0x60, 0x05, 0x74, 0xff, 0xf0, 0xd2, 0x05, 0xd0, 0x07, 0xd0, 0xd0,
+ 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x74, 0x30, 0x51, 0xe2, 0x74, 0x03, 0x51, 0xd8, 0x74,
+ 0x78, 0xf0, 0x90, 0x04, 0x3f, 0xe0, 0x90, 0xe6, 0x0d, 0xf0, 0x12, 0x0e, 0x97, 0x90, 0x04, 0x36,
+ 0xe0, 0x90, 0xe6, 0x0e, 0xf0, 0x12, 0x0e, 0x97, 0x90, 0x04, 0x40, 0xe0, 0xf5, 0x8e, 0x22, 0x51,
+ 0xe0, 0x04, 0x51, 0xd8, 0x04, 0xf0, 0x80, 0xda, 0xf0, 0xa3, 0x14, 0xf0, 0x90, 0x04, 0x36, 0x22,
+ 0x74, 0x02, 0x90, 0x00, 0xe4, 0xf0, 0x90, 0x04, 0x3f, 0x22, 0x51, 0xe0, 0x14, 0xf0, 0xa3, 0x04,
+ 0xf0, 0x90, 0x04, 0x30, 0xe0, 0x90, 0x04, 0x36, 0xf0, 0x80, 0xb7, 0x90, 0x00, 0xe4, 0x74, 0x01,
+ 0xf0, 0x90, 0x04, 0x3f, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x04, 0x31, 0xe0, 0x90, 0x04, 0x36, 0xf0,
+ 0x80, 0xa0, 0xe4, 0x90, 0x04, 0x2a, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x33, 0xf0, 0xa3, 0xf0, 0x12,
+ 0x26, 0x5b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x04, 0x32, 0xf0, 0x90, 0x04,
+ 0x39, 0xf0, 0xc2, 0x2b, 0x90, 0x04, 0x37, 0xf0, 0xc2, 0x2a, 0xa3, 0xf0, 0xc2, 0x29, 0xc2, 0x2a,
+ 0x90, 0x04, 0x3a, 0xf0, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0xff, 0xff, 0x41, 0xa7,
+ 0x75, 0x31, 0x01, 0x12, 0x25, 0xac, 0x71, 0xbf, 0xf0, 0x71, 0xda, 0xa3, 0x74, 0x09, 0xf0, 0x90,
+ 0xfc, 0x00, 0x74, 0x55, 0xf0, 0xa3, 0x74, 0xaa, 0x12, 0x2f, 0x81, 0xa3, 0xf0, 0x90, 0xe6, 0x9c,
+ 0xf0, 0x74, 0x08, 0x71, 0xca, 0xb4, 0xaa, 0x0a, 0xa3, 0xe0, 0xb4, 0x55, 0x05, 0x75, 0x31, 0x02,
+ 0x80, 0x2a, 0x90, 0xe2, 0x1f, 0x74, 0x05, 0xf0, 0x12, 0x25, 0xac, 0x71, 0xbf, 0xf0, 0x90, 0xfc,
+ 0x00, 0x74, 0x5a, 0xf0, 0xe4, 0x12, 0x2f, 0x87, 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x04, 0x71, 0xca,
+ 0x64, 0xa5, 0x60, 0x08, 0x90, 0xe2, 0x1f, 0x74, 0x01, 0xf0, 0x80, 0x0c, 0x75, 0x1a, 0x03, 0x75,
+ 0x1b, 0xb7, 0x85, 0x31, 0x1c, 0x12, 0x20, 0x55, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0, 0x22, 0x90,
+ 0xe6, 0x15, 0x74, 0x22, 0xf0, 0xe4, 0x90, 0xe6, 0x1b, 0x22, 0xa3, 0xf0, 0xff, 0x12, 0x27, 0x96,
+ 0x90, 0xfc, 0x00, 0xe0, 0x22, 0xe4, 0xff, 0x12, 0x27, 0x84, 0x90, 0xe2, 0x1e, 0x74, 0x40, 0xf0,
+ 0x22, 0xe5, 0x19, 0x70, 0x12, 0x12, 0x1f, 0xf1, 0x75, 0x1c, 0x02, 0xe4, 0xfb, 0x7d, 0x26, 0x7f,
+ 0x40, 0x12, 0x20, 0x5d, 0x12, 0x27, 0xcb, 0x22, 0x12, 0x2e, 0xfe, 0x60, 0x03, 0xed, 0x60, 0x07,
+ 0x7d, 0x0a, 0x7f, 0x02, 0x02, 0x2a, 0xeb, 0xeb, 0x14, 0x60, 0x12, 0x14, 0x60, 0x17, 0x24, 0x02,
+ 0x70, 0x1c, 0x75, 0x2b, 0x04, 0x75, 0x2c, 0x45, 0x75, 0x2d, 0x05, 0x80, 0x11, 0x75, 0x2b, 0x04,
+ 0x75, 0x2c, 0x4a, 0x80, 0x06, 0x75, 0x2b, 0x04, 0x75, 0x2c, 0x5b, 0x75, 0x2d, 0x11, 0x90, 0x04,
+ 0x83, 0x74, 0x02, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x15, 0xf0, 0xe4, 0x90, 0x04, 0x85, 0xf0, 0x90,
+ 0x04, 0x86, 0xe5, 0x2d, 0xf0, 0xaa, 0x2b, 0xa9, 0x2c, 0x7b, 0x01, 0xff, 0x02, 0x2d, 0x51, 0xad,
+ 0x07, 0x12, 0x47, 0x09, 0x74, 0x38, 0xf0, 0x12, 0x17, 0xb6, 0x90, 0x00, 0xdd, 0xe0, 0x54, 0xfd,
+ 0xf0, 0xed, 0x60, 0x09, 0xd2, 0x1f, 0x90, 0xe2, 0x42, 0x74, 0x29, 0xf0, 0x22, 0xc2, 0x1f, 0x90,
+ 0xe2, 0x42, 0x74, 0x11, 0xf0, 0x22, 0x7f, 0x01, 0x91, 0x4f, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0,
+ 0x03, 0x12, 0x3e, 0x28, 0x22, 0x90, 0x00, 0xdc, 0xe0, 0x70, 0x03, 0x7f, 0x0b, 0x22, 0x91, 0x76,
+ 0xe4, 0xff, 0x91, 0x97, 0x7f, 0x00, 0x22, 0x8f, 0x30, 0xe4, 0x90, 0xe6, 0x19, 0xf0, 0x00, 0x00,
+ 0x00, 0x90, 0xe6, 0x13, 0x74, 0x22, 0xf0, 0xe4, 0x90, 0xe6, 0x19, 0xf0, 0x90, 0xe6, 0x49, 0x74,
+ 0x84, 0xf0, 0xf0, 0x90, 0xe6, 0x04, 0x74, 0x04, 0xf0, 0x7e, 0xf4, 0x7f, 0x00, 0x7b, 0x00, 0x7a,
+ 0x02, 0x7d, 0xff, 0x12, 0x37, 0x37, 0xe5, 0x30, 0x60, 0x1e, 0x90, 0xf4, 0x00, 0x12, 0x0c, 0xe5,
+ 0x43, 0x59, 0x57, 0x42, 0x7e, 0xf4, 0x7f, 0x04, 0x7c, 0x00, 0x7d, 0xcb, 0xb1, 0xc3, 0x90, 0xf4,
+ 0x14, 0x12, 0x0c, 0xe5, 0x43, 0x59, 0x57, 0x42, 0x12, 0x3c, 0x72, 0x12, 0x1f, 0xf1, 0x7d, 0x01,
+ 0x7c, 0x00, 0x7f, 0x10, 0x12, 0x27, 0xe7, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x60, 0x12, 0x20, 0x5d,
+ 0x90, 0xe6, 0x94, 0x12, 0x23, 0xd8, 0xef, 0x60, 0x03, 0x7f, 0x37, 0x22, 0x12, 0x1f, 0xf1, 0x90,
+ 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0x90, 0x04, 0x34, 0x12, 0x1f, 0xfb, 0xd2, 0x07, 0x12, 0x3d, 0xb9,
+ 0x7f, 0x00, 0x22, 0x8f, 0x2b, 0x12, 0x0c, 0x67, 0x8f, 0x2f, 0x8e, 0x2e, 0x8d, 0x2d, 0x8c, 0x2c,
+ 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x03, 0x7f, 0x4c, 0x22, 0x91, 0x76, 0xe5, 0x2b, 0x64, 0x01, 0x70,
+ 0x76, 0x90, 0x00, 0xcb, 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x9f, 0x12, 0x0c, 0xd9, 0x90, 0x04, 0x9f,
+ 0x12, 0x0c, 0xa1, 0xab, 0x2f, 0xaa, 0x2e, 0xa9, 0x2d, 0xa8, 0x2c, 0xd3, 0x12, 0x0c, 0x30, 0x40,
+ 0x03, 0x7f, 0x0c, 0x22, 0x90, 0x00, 0xd3, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x01, 0xe5, 0x2f,
+ 0x24, 0xff, 0xff, 0xe5, 0x2e, 0x34, 0xff, 0xfe, 0xe5, 0x2d, 0x34, 0xff, 0xfd, 0xe5, 0x2c, 0x34,
+ 0xff, 0x90, 0x00, 0xcb, 0xb1, 0xba, 0xff, 0xe4, 0x35, 0x2e, 0xfe, 0xe4, 0x35, 0x2d, 0xfd, 0xe4,
+ 0x35, 0x2c, 0x90, 0x00, 0xd7, 0xb1, 0xba, 0xfb, 0xe4, 0x35, 0x2e, 0xfa, 0xe4, 0x35, 0x2d, 0xf9,
+ 0xe4, 0x35, 0x2c, 0xf8, 0x90, 0x04, 0x9f, 0x12, 0x0c, 0xa1, 0x12, 0x0b, 0xd3, 0x90, 0x00, 0xcf,
+ 0x12, 0x0c, 0xd9, 0x7f, 0x01, 0x81, 0x97, 0x7f, 0x2b, 0x22, 0xfc, 0x12, 0x0c, 0xd9, 0xe5, 0x2f,
+ 0x24, 0x01, 0x22, 0x7b, 0x10, 0x7a, 0x00, 0x02, 0x19, 0x58, 0xed, 0xd3, 0x94, 0x01, 0x50, 0x0c,
+ 0xed, 0x60, 0x0c, 0xef, 0x60, 0x06, 0x90, 0x00, 0xdc, 0xe0, 0x70, 0x03, 0x7f, 0x01, 0x22, 0x7f,
+ 0x00, 0x22, 0xae, 0x07, 0xee, 0xc4, 0x54, 0x0f, 0xff, 0x74, 0x01, 0xa8, 0x07, 0x08, 0x80, 0x02,
+ 0xc3, 0x33, 0xd8, 0xfc, 0xfc, 0xe4, 0xfb, 0x12, 0x2e, 0xfe, 0x70, 0x04, 0x7b, 0x09, 0x80, 0x1b,
+ 0xee, 0x54, 0x0f, 0x60, 0x04, 0x7b, 0x0a, 0x80, 0x12, 0xb1, 0xca, 0xef, 0x60, 0x04, 0x7b, 0x0b,
+ 0x80, 0x09, 0x90, 0x00, 0xba, 0xe0, 0x5c, 0x60, 0x02, 0x7b, 0x13, 0xaf, 0x03, 0x22, 0xc0, 0xe0,
+ 0xc0, 0x83, 0xc0, 0x82, 0x30, 0x28, 0x0a, 0xc2, 0x28, 0x90, 0x00, 0xfc, 0x74, 0x04, 0xf0, 0x80,
+ 0x0d, 0x90, 0x00, 0xfc, 0xe0, 0x60, 0x07, 0x14, 0xf0, 0xe0, 0x70, 0x02, 0xd2, 0x22, 0xd0, 0x82,
+ 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2,
+ 0x69, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2,
+ 0x6b, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x22, 0x12, 0x0c, 0xa1, 0xef, 0x24,
+ 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed, 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0x22, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0xac, 0x06, 0x8c, 0x46, 0xf5, 0x47, 0x85, 0x47, 0x82, 0x85, 0x46, 0x83, 0xa3,
+ 0xa3, 0xe0, 0x78, 0x8b, 0xf2, 0xee, 0x78, 0xb3, 0xf2, 0x22, 0x90, 0xe6, 0x15, 0x74, 0x62, 0xf0,
+ 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xf0, 0x22, 0x90, 0x03, 0x40, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed,
+ 0x8e, 0x27, 0xf5, 0x28, 0x85, 0x28, 0x82, 0x85, 0x27, 0x83, 0x22, 0x90, 0xe2, 0xa4, 0xf0, 0xe4,
+ 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x33, 0x33, 0x54, 0xc0, 0xff, 0x22, 0x74,
+ 0xc3, 0x90, 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0x78, 0x83, 0x74, 0x02, 0xf2, 0x74, 0x22,
+ 0xf2, 0x74, 0x16, 0xf2, 0x74, 0x36, 0xf2, 0x22, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x84, 0x74,
+ 0x12, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xf0, 0x02, 0x1e, 0xe2, 0x85, 0x2d, 0x82, 0x85, 0x2c, 0x83,
+ 0xe0, 0xf2, 0x05, 0x2d, 0x22, 0x8d, 0x82, 0x8c, 0x83, 0xa3, 0xa3, 0xa3, 0xe0, 0xfd, 0x22, 0x90,
+ 0x03, 0x51, 0xe0, 0xfb, 0xad, 0x28, 0xaf, 0x27, 0x22, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x22,
+ 0x90, 0xe2, 0x0b, 0xe0, 0x54, 0x78, 0x13, 0x13, 0x13, 0x22, 0x74, 0x74, 0x25, 0x51, 0xf5, 0x82,
+ 0xe4, 0x34, 0x04, 0x22, 0x85, 0xe8, 0x5a, 0xe4, 0xf5, 0xe8, 0x02, 0x0e, 0xa1, 0x78, 0x34, 0x7c,
+ 0x00, 0x7a, 0x00, 0x79, 0x0c, 0x22, 0x90, 0xe2, 0x33, 0xf0, 0x12, 0x1e, 0xe2, 0xe4, 0x22, 0xc2,
+ 0xe8, 0x90, 0xe6, 0xb5, 0x74, 0x01, 0xf0, 0x22, 0x90, 0xe2, 0x34, 0xf0, 0x02, 0x1e, 0xe2, 0x90,
+ 0x04, 0xb0, 0xe0, 0xfd, 0x7c, 0x00, 0x22, 0xe4, 0x78, 0x5c, 0xf2, 0x78, 0x5e, 0xf2, 0x22, 0x34,
+ 0x01, 0xfe, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x00
+ }
+} ;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastfw_sd_mmc_rel_silicon_Ast121_68.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1408 @@
+#define CYANFW_SIZE 22392
+union {
+ uint8_t fw_image[CYANFW_SIZE] ;
+ uint16_t dummy_for_word_alignment ;
+} CyAnFirmware = {
+ {
+ 0x02, 0x10, 0xae, 0x02, 0x52, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x52, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x56, 0x1e, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x19, 0x99, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xe7, 0x09, 0xf6, 0x08, 0xdf, 0xfa, 0x80, 0x46, 0xe7, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x3e,
+ 0x88, 0x82, 0x8c, 0x83, 0xe7, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x32, 0xe3, 0x09, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x78, 0xe3, 0x09, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x70, 0x88, 0x82, 0x8c, 0x83,
+ 0xe3, 0x09, 0xf0, 0xa3, 0xdf, 0xfa, 0x80, 0x64, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf6, 0x08,
+ 0xdf, 0xfa, 0x80, 0x58, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0xa3, 0xf2, 0x08, 0xdf, 0xfa, 0x80, 0x4c,
+ 0x80, 0xd2, 0x80, 0xfa, 0x80, 0xc6, 0x80, 0xd4, 0x80, 0x69, 0x80, 0xf2, 0x80, 0x33, 0x80, 0x10,
+ 0x80, 0xa6, 0x80, 0xea, 0x80, 0x9a, 0x80, 0xa8, 0x80, 0xda, 0x80, 0xe2, 0x80, 0xca, 0x80, 0x33,
+ 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83,
+ 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xe9, 0xde, 0xe7, 0x80,
+ 0x0d, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf6, 0x08, 0xdf, 0xf9, 0xec, 0xfa, 0xa9, 0xf0,
+ 0xed, 0xfb, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xec, 0xfa, 0xe0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc,
+ 0xc5, 0x83, 0xcc, 0xf0, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xcc, 0xc5, 0x83, 0xcc, 0xdf, 0xea, 0xde,
+ 0xe8, 0x80, 0xdb, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0xa3, 0xf2, 0x08, 0xdf, 0xf9, 0x80, 0xcc,
+ 0x88, 0xf0, 0xef, 0x60, 0x01, 0x0e, 0x4e, 0x60, 0xc3, 0x88, 0xf0, 0xed, 0x24, 0x02, 0xb4, 0x04,
+ 0x00, 0x50, 0xb9, 0xf5, 0x82, 0xeb, 0x24, 0x02, 0xb4, 0x04, 0x00, 0x50, 0xaf, 0x23, 0x23, 0x45,
+ 0x82, 0x23, 0x90, 0x0a, 0x90, 0x73, 0xbb, 0x01, 0x06, 0x89, 0x82, 0x8a, 0x83, 0xe0, 0x22, 0x50,
+ 0x02, 0xe7, 0x22, 0xbb, 0xfe, 0x02, 0xe3, 0x22, 0x89, 0x82, 0x8a, 0x83, 0xe4, 0x93, 0x22, 0xbb,
+ 0x01, 0x0c, 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe0, 0x22, 0x50, 0x06,
+ 0xe9, 0x25, 0x82, 0xf8, 0xe6, 0x22, 0xbb, 0xfe, 0x06, 0xe9, 0x25, 0x82, 0xf8, 0xe2, 0x22, 0xe5,
+ 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe4, 0x93, 0x22, 0xf8, 0xbb, 0x01, 0x0d,
+ 0xe5, 0x82, 0x29, 0xf5, 0x82, 0xe5, 0x83, 0x3a, 0xf5, 0x83, 0xe8, 0xf0, 0x22, 0x50, 0x06, 0xe9,
+ 0x25, 0x82, 0xc8, 0xf6, 0x22, 0xbb, 0xfe, 0x05, 0xe9, 0x25, 0x82, 0xc8, 0xf2, 0x22, 0xef, 0x8d,
+ 0xf0, 0xa4, 0xa8, 0xf0, 0xcf, 0x8c, 0xf0, 0xa4, 0x28, 0xce, 0x8d, 0xf0, 0xa4, 0x2e, 0xfe, 0x22,
+ 0xc5, 0xf0, 0xf8, 0xa3, 0xe0, 0x28, 0xf0, 0xc5, 0xf0, 0xf8, 0xe5, 0x82, 0x15, 0x82, 0x70, 0x02,
+ 0x15, 0x83, 0xe0, 0x38, 0xf0, 0x22, 0xef, 0x2b, 0xff, 0xee, 0x3a, 0xfe, 0xed, 0x39, 0xfd, 0xec,
+ 0x38, 0xfc, 0x22, 0xc3, 0xef, 0x9b, 0xff, 0xee, 0x9a, 0xfe, 0xed, 0x99, 0xfd, 0xec, 0x98, 0xfc,
+ 0x22, 0xe8, 0x8f, 0xf0, 0xa4, 0xcc, 0x8b, 0xf0, 0xa4, 0x2c, 0xfc, 0xe9, 0x8e, 0xf0, 0xa4, 0x2c,
+ 0xfc, 0x8a, 0xf0, 0xed, 0xa4, 0x2c, 0xfc, 0xea, 0x8e, 0xf0, 0xa4, 0xcd, 0xa8, 0xf0, 0x8b, 0xf0,
+ 0xa4, 0x2d, 0xcc, 0x38, 0x25, 0xf0, 0xfd, 0xe9, 0x8f, 0xf0, 0xa4, 0x2c, 0xcd, 0x35, 0xf0, 0xfc,
+ 0xeb, 0x8e, 0xf0, 0xa4, 0xfe, 0xa9, 0xf0, 0xeb, 0x8f, 0xf0, 0xa4, 0xcf, 0xc5, 0xf0, 0x2e, 0xcd,
+ 0x39, 0xfe, 0xe4, 0x3c, 0xfc, 0xea, 0xa4, 0x2d, 0xce, 0x35, 0xf0, 0xfd, 0xe4, 0x3c, 0xfc, 0x22,
+ 0xeb, 0x9f, 0xf5, 0xf0, 0xea, 0x9e, 0x42, 0xf0, 0xe9, 0x9d, 0x42, 0xf0, 0xe8, 0x9c, 0x45, 0xf0,
+ 0x22, 0xe8, 0x60, 0x0f, 0xec, 0xc3, 0x13, 0xfc, 0xed, 0x13, 0xfd, 0xee, 0x13, 0xfe, 0xef, 0x13,
+ 0xff, 0xd8, 0xf1, 0x22, 0xe8, 0x60, 0x0f, 0xef, 0xc3, 0x33, 0xff, 0xee, 0x33, 0xfe, 0xed, 0x33,
+ 0xfd, 0xec, 0x33, 0xfc, 0xd8, 0xf1, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xa1, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x51, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x5d,
+ 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x69, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0c,
+ 0xd9, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xa3, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0xaf,
+ 0x22, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xa3, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x22, 0xe0, 0xf8, 0xa3,
+ 0xe0, 0xf9, 0xa3, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x22, 0xbb, 0x01, 0x07, 0x89, 0x82, 0x8a, 0x83,
+ 0x02, 0x0c, 0xad, 0x50, 0x05, 0xe9, 0xf8, 0x02, 0x0d, 0x79, 0xbb, 0xfe, 0x05, 0xe9, 0xf8, 0x02,
+ 0x0d, 0x86, 0x89, 0x82, 0x8a, 0x83, 0x02, 0x0d, 0x93, 0xec, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0xa8, 0x82, 0x85, 0x83, 0xf0, 0xd0, 0x83, 0xd0, 0x82, 0x12, 0x0c,
+ 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0x12, 0x0c, 0xfc, 0xe4, 0x73, 0xe4, 0x93, 0xa3, 0xc5,
+ 0x83, 0xc5, 0xf0, 0xc5, 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0xf0, 0xa3, 0xc5, 0x83, 0xc5, 0xf0, 0xc5,
+ 0x83, 0xc8, 0xc5, 0x82, 0xc8, 0x22, 0xa4, 0x25, 0x82, 0xf5, 0x82, 0xe5, 0xf0, 0x35, 0x83, 0xf5,
+ 0x83, 0x22, 0xeb, 0xf0, 0xa3, 0xea, 0xf0, 0xa3, 0xe9, 0xf0, 0x22, 0xd0, 0x83, 0xd0, 0x82, 0xf8,
+ 0xe4, 0x93, 0x70, 0x12, 0x74, 0x01, 0x93, 0x70, 0x0d, 0xa3, 0xa3, 0x93, 0xf8, 0x74, 0x01, 0x93,
+ 0xf5, 0x82, 0x88, 0x83, 0xe4, 0x73, 0x74, 0x02, 0x93, 0x68, 0x60, 0xef, 0xa3, 0xa3, 0xa3, 0x80,
+ 0xdf, 0xe6, 0xfc, 0x08, 0xe6, 0xfd, 0x08, 0xe6, 0xfe, 0x08, 0xe6, 0xff, 0x22, 0xe2, 0xfc, 0x08,
+ 0xe2, 0xfd, 0x08, 0xe2, 0xfe, 0x08, 0xe2, 0xff, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0xfd,
+ 0x74, 0x02, 0x93, 0xfe, 0x74, 0x03, 0x93, 0xff, 0x22, 0xe6, 0xfb, 0x08, 0xe6, 0xf9, 0x08, 0xe6,
+ 0xfa, 0x08, 0xe6, 0xcb, 0xf8, 0x22, 0xe2, 0xfb, 0x08, 0xe2, 0xf9, 0x08, 0xe2, 0xfa, 0x08, 0xe2,
+ 0xcb, 0xf8, 0x22, 0xe4, 0x93, 0xf8, 0x74, 0x01, 0x93, 0xf9, 0x74, 0x02, 0x93, 0xfa, 0x74, 0x03,
+ 0x93, 0xfb, 0x22, 0xec, 0xf6, 0x08, 0xed, 0xf6, 0x08, 0xee, 0xf6, 0x08, 0xef, 0xf6, 0x22, 0xec,
+ 0xf2, 0x08, 0xed, 0xf2, 0x08, 0xee, 0xf2, 0x08, 0xef, 0xf2, 0x22, 0xc1, 0x26, 0x41, 0x00, 0x60,
+ 0x00, 0x41, 0x00, 0x61, 0x00, 0x42, 0x00, 0xa9, 0x00, 0x40, 0x41, 0x00, 0xab, 0x00, 0x41, 0x00,
+ 0xac, 0x7c, 0x01, 0x14, 0x00, 0x41, 0x00, 0xae, 0x00, 0xc1, 0x24, 0x02, 0x15, 0x00, 0x00, 0x41,
+ 0x00, 0xaf, 0x00, 0x42, 0x00, 0xb1, 0x00, 0x00, 0xc1, 0x25, 0x02, 0x17, 0x00, 0xb3, 0x41, 0x00,
+ 0xb0, 0x00, 0xc1, 0x27, 0x41, 0x00, 0xad, 0x00, 0x44, 0x04, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x04, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+ 0x04, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x04, 0x87, 0x03, 0x90, 0x4a, 0x04, 0x89, 0x03,
+ 0x40, 0x03, 0x48, 0x03, 0x50, 0x03, 0x90, 0x00, 0x00, 0x48, 0x04, 0x6c, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x83, 0x00, 0x41, 0x04, 0x84, 0x00, 0x41, 0x04, 0x85, 0x00,
+ 0x41, 0x04, 0x86, 0x00, 0x02, 0x20, 0x00, 0x00, 0x41, 0x00, 0xfd, 0x00, 0xc1, 0x2e, 0x41, 0x04,
+ 0x30, 0x16, 0x41, 0x04, 0x31, 0x07, 0x01, 0x08, 0x01, 0x01, 0x09, 0x02, 0x02, 0x0a, 0x00, 0xc5,
+ 0x41, 0x04, 0xbf, 0x00, 0x41, 0x04, 0xc0, 0x00, 0x41, 0x04, 0xc1, 0x00, 0x41, 0x04, 0xc4, 0x01,
+ 0x42, 0x00, 0xb7, 0x00, 0x00, 0x41, 0x00, 0xfb, 0x00, 0xc1, 0x21, 0x00, 0x74, 0x00, 0xf5, 0x86,
+ 0x90, 0xfd, 0xa5, 0x7c, 0x05, 0xa3, 0xe5, 0x82, 0x45, 0x83, 0x70, 0xf9, 0x22, 0x74, 0x00, 0xf5,
+ 0x86, 0x90, 0xff, 0xe1, 0x02, 0x0e, 0x85, 0x74, 0x00, 0xf5, 0x86, 0x90, 0xff, 0x41, 0x02, 0x0e,
+ 0x85, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x5d, 0xa8, 0x5d, 0xe5, 0x9a, 0xf6, 0x15, 0x5d, 0xa8, 0x5d,
+ 0xe5, 0x9b, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0x15, 0x5d, 0xa8, 0x5d,
+ 0xe5, 0x9d, 0xf6, 0x15, 0x5d, 0xa8, 0x5d, 0xe5, 0x9e, 0xf6, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0,
+ 0x00, 0xc0, 0xe0, 0xa8, 0x5d, 0xe6, 0xf5, 0x9b, 0x05, 0x5d, 0xa8, 0x5d, 0xe6, 0xf5, 0x9a, 0x05,
+ 0x5d, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc0, 0x00, 0xc0, 0xe0, 0xa8, 0x5d, 0xe6, 0xf5, 0x9e, 0x05,
+ 0x5d, 0xa8, 0x5d, 0xe6, 0xf5, 0x9d, 0x05, 0x5d, 0xd0, 0xe0, 0xd0, 0x00, 0x22, 0xc2, 0xdc, 0x32,
+ 0x02, 0x48, 0x4a, 0x00, 0x02, 0x4f, 0x00, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x48, 0x88, 0x00,
+ 0x02, 0x31, 0x4c, 0x00, 0x02, 0x4e, 0x74, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x4f, 0x06, 0x00, 0x02, 0x4f, 0x0a, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x4f, 0x7f, 0x00,
+ 0x02, 0x4f, 0xdf, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00, 0x02, 0x37, 0xfa, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00,
+ 0x02, 0x50, 0x6d, 0x00, 0x02, 0x50, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x08, 0x03, 0x05, 0x24,
+ 0x00, 0x02, 0x3a, 0x00, 0x03, 0x03, 0x00, 0x03, 0x11, 0x0c, 0x03, 0x12, 0x00, 0x05, 0x20, 0x00,
+ 0x05, 0x21, 0x00, 0x05, 0x26, 0x00, 0x06, 0x28, 0x00, 0x05, 0x04, 0x02, 0x02, 0x53, 0x02, 0x07,
+ 0x27, 0x00, 0x05, 0x39, 0x00, 0xff, 0xff, 0xff, 0xe3, 0x18, 0xe3, 0x19, 0xe3, 0x1a, 0xe3, 0x1b,
+ 0xe3, 0x12, 0xe3, 0x13, 0xe3, 0x14, 0xe3, 0x15, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0x22,
+ 0x00, 0x00, 0x12, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0xb4, 0x04, 0x17, 0x47, 0x02, 0x00,
+ 0x02, 0x03, 0x01, 0x01, 0x00, 0x00, 0x0a, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00,
+ 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00, 0x00, 0x02,
+ 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x00, 0x02, 0x00, 0x07, 0x05, 0x86, 0x02, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x09, 0x02, 0x20, 0x00, 0x01, 0x01, 0x00, 0x80, 0x32, 0x09, 0x04, 0x00,
+ 0x00, 0x02, 0x08, 0x06, 0x50, 0x00, 0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00, 0x07, 0x05, 0x86,
+ 0x02, 0x40, 0x00, 0x00, 0x04, 0x03, 0x09, 0x04, 0x1a, 0x03, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00,
+ 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x30, 0x00,
+ 0x31, 0x00, 0x10, 0x03, 0x43, 0x00, 0x79, 0x00, 0x70, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00,
+ 0x73, 0x00, 0x18, 0x03, 0x57, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x42, 0x00,
+ 0x72, 0x00, 0x69, 0x00, 0x64, 0x00, 0x67, 0x00, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x7f,
+ 0xe4, 0xf6, 0xd8, 0xfd, 0x75, 0x92, 0xe6, 0x75, 0x81, 0x5d, 0x02, 0x10, 0xf8, 0x02, 0x40, 0x27,
+ 0xe4, 0x93, 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0x40, 0x03, 0xf6, 0x80, 0x01, 0xf2, 0x08, 0xdf, 0xf4,
+ 0x80, 0x29, 0xe4, 0x93, 0xa3, 0xf8, 0x54, 0x07, 0x24, 0x0c, 0xc8, 0xc3, 0x33, 0xc4, 0x54, 0x0f,
+ 0x44, 0x20, 0xc8, 0x83, 0x40, 0x04, 0xf4, 0x56, 0x80, 0x01, 0x46, 0xf6, 0xdf, 0xe4, 0x80, 0x0b,
+ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x90, 0x0d, 0xbb, 0xe4, 0x7e, 0x01, 0x93, 0x60,
+ 0xbc, 0xa3, 0xff, 0x54, 0x3f, 0x30, 0xe5, 0x09, 0x54, 0x1f, 0xfe, 0xe4, 0x93, 0xa3, 0x60, 0x01,
+ 0x0e, 0xcf, 0x54, 0xc0, 0x25, 0xe0, 0x60, 0xa8, 0x40, 0xb8, 0xe4, 0x93, 0xa3, 0xfa, 0xe4, 0x93,
+ 0xa3, 0xf8, 0xe4, 0x93, 0xa3, 0xc8, 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xf0, 0xa3, 0xc8,
+ 0xc5, 0x82, 0xc8, 0xca, 0xc5, 0x83, 0xca, 0xdf, 0xe9, 0xde, 0xe7, 0x80, 0xbe, 0x00, 0x00, 0x00,
+ 0x24, 0x00, 0x80, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x43, 0x79, 0x70, 0x72, 0x65, 0x73, 0x73,
+ 0x00, 0x41, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x53, 0x44, 0x20, 0x43, 0x61, 0x72, 0x64,
+ 0x00, 0x30, 0x30, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0x4a, 0x00, 0x00, 0xe3,
+ 0x4b, 0x00, 0x00, 0xe3, 0x4c, 0x00, 0x00, 0xe3, 0x4d, 0xe3, 0x4e, 0xe3, 0x4f, 0xe3, 0x38, 0xe3,
+ 0x39, 0xe3, 0x3a, 0xe3, 0x3b, 0xe4, 0xf5, 0x34, 0xef, 0x70, 0x12, 0xe5, 0x14, 0xc3, 0x94, 0x04,
+ 0x40, 0x54, 0x12, 0x50, 0xc5, 0x75, 0x14, 0x03, 0x12, 0x57, 0x67, 0x80, 0x49, 0xe5, 0x14, 0x24,
+ 0xfd, 0x60, 0x0c, 0x24, 0xfe, 0x60, 0x03, 0x04, 0x70, 0x39, 0x75, 0x34, 0x10, 0x80, 0x37, 0x90,
+ 0xe2, 0xa6, 0x74, 0x30, 0xf0, 0x74, 0x10, 0x12, 0x56, 0xbb, 0xf0, 0x78, 0x5d, 0x74, 0xff, 0xf2,
+ 0x53, 0x91, 0xef, 0x78, 0x5c, 0x74, 0x3b, 0xf2, 0x12, 0x50, 0xe1, 0x75, 0x14, 0x04, 0x90, 0x00,
+ 0xb9, 0xe0, 0x60, 0x03, 0x12, 0x41, 0xe3, 0x7f, 0x02, 0x12, 0x36, 0xf2, 0x78, 0x5e, 0x74, 0x1b,
+ 0xf2, 0x80, 0x03, 0x75, 0x34, 0x1b, 0xaf, 0x34, 0x22, 0xe4, 0xf5, 0x30, 0x90, 0x04, 0x81, 0xf0,
+ 0x53, 0x21, 0xf7, 0x90, 0x04, 0x77, 0xe0, 0x12, 0x0d, 0x2b, 0x12, 0x34, 0x00, 0x12, 0x39, 0x01,
+ 0x12, 0x3e, 0x02, 0x12, 0x4d, 0x04, 0x12, 0x81, 0x05, 0x12, 0x84, 0x06, 0x12, 0xaa, 0x07, 0x12,
+ 0xc5, 0x08, 0x12, 0xcc, 0x09, 0x13, 0x43, 0x0a, 0x12, 0xb1, 0x0d, 0x12, 0xbd, 0x0e, 0x14, 0x5d,
+ 0x13, 0x12, 0xdc, 0x14, 0x12, 0xef, 0x15, 0x14, 0x85, 0x17, 0x13, 0xf5, 0xa7, 0x13, 0xfc, 0xa8,
+ 0x00, 0x00, 0x14, 0xa9, 0x12, 0x3f, 0xfe, 0x61, 0x3f, 0x12, 0x30, 0xff, 0x61, 0x3f, 0x91, 0xb1,
+ 0xff, 0x31, 0x85, 0x91, 0xaf, 0x60, 0x02, 0x41, 0xeb, 0xf5, 0x5c, 0x41, 0xeb, 0x12, 0x0f, 0xf8,
+ 0xff, 0x24, 0x07, 0xf1, 0xa6, 0xe0, 0x90, 0x00, 0xb6, 0xf0, 0x8f, 0x82, 0x8e, 0x83, 0xe0, 0x90,
+ 0x04, 0xc2, 0xf0, 0x12, 0x3b, 0x02, 0xa3, 0xe0, 0xff, 0x90, 0x04, 0xc3, 0xf0, 0x12, 0x57, 0x05,
+ 0xf1, 0xd7, 0xe0, 0x24, 0x05, 0xf5, 0x82, 0xe4, 0x3a, 0xf5, 0x83, 0xe0, 0xfb, 0xf1, 0xf7, 0x80,
+ 0x47, 0x02, 0x28, 0x02, 0xf1, 0xc3, 0xa3, 0xa3, 0xa3, 0xe0, 0x60, 0x14, 0x8f, 0x82, 0x8e, 0x83,
+ 0xa3, 0xe0, 0xff, 0x12, 0x35, 0xed, 0x91, 0xaf, 0x54, 0x0f, 0x70, 0x0c, 0xc2, 0x25, 0x80, 0x08,
+ 0x91, 0xb1, 0xff, 0x12, 0x36, 0x3f, 0x8f, 0x30, 0x80, 0x41, 0x91, 0xb1, 0xff, 0x7d, 0x02, 0x80,
+ 0x11, 0x12, 0x3b, 0x02, 0xa3, 0xe0, 0xff, 0x12, 0x57, 0x05, 0x02, 0x30, 0x04, 0x91, 0xb1, 0xff,
+ 0x7d, 0x04, 0x02, 0x37, 0xfd, 0x12, 0x38, 0x64, 0x8f, 0x30, 0x80, 0x1f, 0x91, 0xb1, 0xff, 0x12,
+ 0x39, 0xde, 0x8f, 0x30, 0xe5, 0x30, 0x70, 0x02, 0x81, 0xae, 0x80, 0x64, 0x90, 0x00, 0xae, 0xe0,
+ 0xb4, 0x02, 0x05, 0x75, 0x30, 0x18, 0x80, 0x03, 0x12, 0x18, 0x87, 0xad, 0x30, 0x81, 0xa4, 0xf1,
+ 0xd7, 0xe0, 0xfb, 0xf5, 0x82, 0x8a, 0x83, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xf3, 0x12, 0x0c, 0xd9,
+ 0xeb, 0x24, 0x04, 0xf5, 0x82, 0xe4, 0x3a, 0xf5, 0x83, 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xf7, 0x12,
+ 0x0c, 0xd9, 0xe4, 0xff, 0xfe, 0xfd, 0xfc, 0x90, 0x00, 0xf7, 0xf1, 0x4c, 0x70, 0x0b, 0x90, 0x00,
+ 0xf3, 0xf1, 0x48, 0x70, 0x04, 0xc2, 0x21, 0x80, 0x02, 0xd2, 0x21, 0x90, 0x00, 0xeb, 0x12, 0x0c,
+ 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4,
+ 0xfd, 0x81, 0xa4, 0xe4, 0xf5, 0x31, 0xf5, 0x32, 0x75, 0x33, 0x02, 0x12, 0x39, 0xd6, 0xfd, 0xec,
+ 0xf5, 0x9d, 0xed, 0xf5, 0x9e, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe6, 0x10, 0xf0, 0xe4, 0x90, 0xe6,
+ 0x8d, 0xf0, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe6, 0x11, 0xf0, 0x00, 0x00, 0x00, 0xe4, 0xf5, 0x32,
+ 0x90, 0xe6, 0x7c, 0xe0, 0xf5, 0x31, 0xe5, 0x32, 0x25, 0xe0, 0x24, 0xf0, 0xf5, 0x82, 0xe4, 0x34,
+ 0x0f, 0x12, 0x36, 0xd0, 0xe5, 0x31, 0xf0, 0x00, 0x00, 0x00, 0x05, 0x33, 0x05, 0x33, 0x05, 0x32,
+ 0xe5, 0x32, 0xb4, 0x04, 0xdb, 0x12, 0x30, 0xc6, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4a, 0xf0,
+ 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4b, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3,
+ 0x4c, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4d, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0,
+ 0x90, 0xe3, 0x4e, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x4f, 0xf0, 0x00, 0x90, 0xe6,
+ 0x7c, 0xe0, 0x90, 0xe3, 0x38, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x39, 0xf0, 0x00,
+ 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x3a, 0xf0, 0x00, 0x90, 0xe6, 0x7c, 0xe0, 0x90, 0xe3, 0x3b,
+ 0xf0, 0xe4, 0xfd, 0x81, 0xa4, 0xe4, 0x90, 0x00, 0xfd, 0xf0, 0x80, 0x5c, 0x75, 0x31, 0x0f, 0x75,
+ 0x32, 0xe5, 0x90, 0x00, 0x86, 0xe0, 0x12, 0x45, 0x93, 0x24, 0xff, 0x92, 0x14, 0x91, 0xc2, 0x74,
+ 0x0f, 0xf0, 0xf1, 0xc3, 0xa3, 0xa3, 0xa3, 0xf1, 0xad, 0x05, 0x32, 0xe5, 0x32, 0x70, 0x02, 0x05,
+ 0x31, 0xef, 0xf1, 0xa4, 0xf1, 0xad, 0x05, 0x32, 0xe5, 0x32, 0x70, 0x02, 0x05, 0x31, 0x12, 0x0f,
+ 0xf8, 0xff, 0x24, 0x05, 0xf1, 0xa6, 0xf1, 0xad, 0xf1, 0xd0, 0xe0, 0x60, 0x0c, 0x30, 0x14, 0x06,
+ 0xc2, 0x1b, 0xf1, 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0xe4, 0x90, 0x00, 0xfd, 0xf0, 0x12, 0x0f,
+ 0xf8, 0xf5, 0x82, 0x8e, 0x83, 0xa3, 0xa3, 0xe0, 0xf5, 0x5b, 0x02, 0x45, 0x15, 0xe4, 0xf5, 0x31,
+ 0x90, 0x00, 0xb0, 0xe0, 0x30, 0xe1, 0x17, 0x90, 0xe6, 0x80, 0xe0, 0x44, 0x01, 0xf0, 0x7f, 0x0a,
+ 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x90, 0xe6, 0x80, 0xe0, 0x54, 0xfe, 0xf0, 0x80, 0x03, 0x75, 0x31,
+ 0x3e, 0xad, 0x31, 0x80, 0x1f, 0x75, 0x31, 0x0b, 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x14, 0xe4, 0xf5,
+ 0x31, 0xf1, 0xc3, 0xa3, 0xa3, 0xe0, 0x24, 0xff, 0x92, 0x1d, 0xf1, 0xd0, 0xa3, 0xe0, 0x24, 0xff,
+ 0x92, 0x1c, 0xad, 0x31, 0x7f, 0x03, 0x02, 0x2a, 0xeb, 0x7f, 0x03, 0x12, 0x2d, 0x18, 0x22, 0x8f,
+ 0x30, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0xf5, 0x82, 0x8e, 0x83, 0xa3, 0xe0, 0x22, 0x75,
+ 0x19, 0x8c, 0x90, 0x04, 0xbe, 0xe0, 0x24, 0xb3, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22,
+ 0x8f, 0x26, 0xa2, 0x11, 0xb3, 0x92, 0x12, 0x90, 0x00, 0x89, 0xe0, 0xf5, 0x27, 0xe4, 0x90, 0x04,
+ 0xb6, 0xf1, 0x48, 0xc3, 0x60, 0x01, 0xd3, 0x92, 0x13, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x03, 0xff,
+ 0xe5, 0x26, 0xd3, 0x9f, 0x40, 0x02, 0xe1, 0x2e, 0xaf, 0x26, 0x12, 0x51, 0x14, 0x8f, 0x29, 0x12,
+ 0x2e, 0xfe, 0xf5, 0x2a, 0x30, 0x2a, 0x24, 0x90, 0x04, 0xbe, 0xe0, 0xb5, 0x26, 0x1a, 0xe5, 0x27,
+ 0xb4, 0x2a, 0x15, 0x90, 0x00, 0x8b, 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x2c, 0xf1, 0x4c, 0x70, 0x08,
+ 0x90, 0x00, 0x91, 0xe0, 0x64, 0x80, 0x60, 0x03, 0x12, 0x1f, 0xb9, 0x90, 0x04, 0xbe, 0xe5, 0x26,
+ 0xf0, 0x91, 0xc6, 0xe0, 0xf5, 0x2b, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0xe4, 0xf0, 0xe5, 0x27,
+ 0x12, 0x0d, 0x2b, 0x15, 0xed, 0x00, 0x16, 0x1d, 0x03, 0x15, 0xb3, 0x12, 0x16, 0xdf, 0x15, 0x16,
+ 0xb2, 0x1a, 0x16, 0x73, 0x1b, 0x16, 0x9b, 0x1e, 0x15, 0xc2, 0x23, 0x15, 0xc2, 0x25, 0x15, 0x7a,
+ 0x28, 0x15, 0x8f, 0x2a, 0x16, 0x1a, 0x2f, 0x16, 0xdf, 0x35, 0x16, 0xdf, 0x55, 0x16, 0xdf, 0x5a,
+ 0x16, 0xdf, 0xa8, 0x16, 0xdf, 0xaa, 0x00, 0x00, 0x16, 0xf9, 0xaf, 0x2a, 0x12, 0x50, 0xee, 0x50,
+ 0x02, 0xe1, 0x2e, 0x30, 0x13, 0x05, 0x20, 0x11, 0x02, 0xe1, 0x2e, 0xd2, 0x14, 0x80, 0x13, 0xaf,
+ 0x2a, 0x12, 0x50, 0xee, 0x50, 0x02, 0xe1, 0x2e, 0x30, 0x13, 0x05, 0x30, 0x11, 0x02, 0xe1, 0x2e,
+ 0xc2, 0x14, 0x75, 0x2f, 0x01, 0x75, 0x30, 0x00, 0x75, 0x31, 0x8b, 0xaf, 0x29, 0x12, 0x49, 0x4f,
+ 0x8f, 0x28, 0x22, 0x20, 0x13, 0x02, 0xe1, 0x2e, 0xf1, 0xee, 0x12, 0x3a, 0x86, 0x8f, 0x28, 0x7f,
+ 0x00, 0x22, 0xe5, 0x27, 0x7f, 0x08, 0xb4, 0x23, 0x02, 0x7f, 0x0c, 0x8f, 0x2c, 0x20, 0x13, 0x02,
+ 0xe1, 0x2e, 0xad, 0x27, 0xaf, 0x29, 0x12, 0x4d, 0x8e, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x0a, 0x74,
+ 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xc1, 0xcb, 0xaf, 0x2c, 0xc1, 0x6f, 0x30, 0x13, 0x02,
+ 0xe1, 0x2e, 0xaf, 0x29, 0x12, 0x4e, 0x1d, 0x8f, 0x28, 0xe5, 0x2b, 0xb4, 0x0a, 0x0c, 0x74, 0xb3,
+ 0x25, 0x26, 0x91, 0xc8, 0xe5, 0x2b, 0xf0, 0x7f, 0x84, 0x22, 0xe5, 0x28, 0x60, 0x09, 0x74, 0xb3,
+ 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xe5, 0x2b, 0x75,
+ 0xf0, 0x03, 0xa4, 0x24, 0xb8, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0xaf, 0x82, 0xf5, 0x2c, 0x8f, 0x2d,
+ 0x20, 0x13, 0x02, 0xe1, 0x2e, 0x12, 0x47, 0x5a, 0x7b, 0x12, 0x12, 0x37, 0x2f, 0x7a, 0xf8, 0x79,
+ 0x00, 0x12, 0x47, 0x27, 0x78, 0x7c, 0x74, 0x70, 0xf2, 0xe4, 0xf2, 0x12, 0x56, 0xfa, 0xe5, 0x2d,
+ 0x70, 0x02, 0x05, 0x2c, 0x75, 0x9e, 0x07, 0x74, 0x0a, 0xf2, 0x75, 0x9e, 0x0c, 0x12, 0x56, 0xfa,
+ 0xe5, 0x2d, 0x70, 0x02, 0x05, 0x2c, 0xf5, 0x82, 0x85, 0x2c, 0x83, 0xe0, 0xf2, 0x7f, 0x12, 0x7e,
+ 0x00, 0x80, 0x66, 0xf1, 0xde, 0x12, 0x3b, 0xfe, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x1a, 0xb4, 0x9b,
+ 0x0b, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x0c, 0xf0, 0x80, 0x09, 0x74, 0xb3, 0x25, 0x26,
+ 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf, 0x28, 0x22, 0x7f, 0x00, 0x22, 0xf1, 0xde, 0x12, 0x4e, 0x58,
+ 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x09, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x03, 0xf0, 0xaf,
+ 0x28, 0x22, 0xf1, 0xee, 0x12, 0x47, 0x68, 0x8f, 0x28, 0xe5, 0x28, 0x60, 0x18, 0x7f, 0x02, 0xb4,
+ 0x8f, 0x02, 0x7f, 0x0e, 0x74, 0xb3, 0x25, 0x26, 0x91, 0xc8, 0xef, 0xf0, 0xa2, 0x12, 0x92, 0x1b,
+ 0xf1, 0x53, 0xaf, 0x28, 0x22, 0xaf, 0x9e, 0x7e, 0x00, 0x12, 0x3b, 0x53, 0x7f, 0x00, 0x22, 0x74,
+ 0xb3, 0x25, 0x26, 0x91, 0xc8, 0x74, 0x07, 0xf0, 0x30, 0x11, 0x08, 0xa2, 0x12, 0x92, 0x1b, 0xf1,
+ 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0x7f, 0x86, 0x22, 0x74, 0x43, 0x12, 0x56, 0xe8, 0xe5, 0x2a,
+ 0xb4, 0x01, 0x04, 0x7f, 0x00, 0x80, 0x05, 0x90, 0x04, 0x37, 0xe0, 0xff, 0x90, 0x04, 0x85, 0xef,
+ 0xf0, 0xe4, 0x90, 0x04, 0x86, 0xf0, 0x90, 0x00, 0x87, 0xf0, 0xa3, 0xe0, 0x24, 0x04, 0xff, 0x7b,
+ 0x01, 0x7a, 0x00, 0x79, 0x87, 0x12, 0x2d, 0x51, 0x12, 0x3b, 0xf6, 0x7f, 0x00, 0x22, 0x30, 0x11,
+ 0x08, 0xa2, 0x12, 0x92, 0x1b, 0xf1, 0x53, 0x80, 0x03, 0x12, 0x46, 0x1b, 0x74, 0xb3, 0x25, 0x26,
+ 0x91, 0xc8, 0x74, 0x09, 0xf0, 0x7f, 0x98, 0x22, 0xff, 0xfe, 0xfd, 0xfc, 0x12, 0x0c, 0xad, 0xc3,
+ 0x02, 0x0c, 0x30, 0x90, 0x00, 0xad, 0xe0, 0x60, 0x14, 0x12, 0x4d, 0x13, 0x60, 0x0f, 0x20, 0x1b,
+ 0x0a, 0xf1, 0xb6, 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0x00, 0xa3, 0xf0, 0xf1, 0xe6, 0x22, 0xe4, 0xfe,
+ 0x7d, 0x02, 0xef, 0x5d, 0x90, 0x00, 0xb9, 0xf0, 0x90, 0xe6, 0x12, 0x70, 0x0b, 0x74, 0x22, 0xf0,
+ 0x90, 0xe6, 0x14, 0x74, 0x62, 0xf0, 0x80, 0x09, 0x74, 0xa2, 0xf0, 0x90, 0xe6, 0x14, 0x74, 0xe2,
+ 0xf0, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe1, 0x01, 0x0e, 0x30, 0x1c, 0x04, 0x30, 0x1d, 0x01, 0x0e,
+ 0xee, 0x14, 0xff, 0x22, 0x24, 0x04, 0xf5, 0x82, 0xe4, 0x3e, 0xf5, 0x83, 0x22, 0xe0, 0x85, 0x32,
+ 0x82, 0x85, 0x31, 0x83, 0xf0, 0x22, 0xe5, 0x14, 0xb4, 0x05, 0x07, 0x90, 0xe6, 0xa5, 0xe0, 0x30,
+ 0xe2, 0xf9, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xf5, 0x82, 0x8e, 0x83, 0x22,
+ 0x8f, 0x82, 0x8e, 0x83, 0xa3, 0xa3, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfa, 0xa3, 0x22, 0x90, 0x00,
+ 0x8d, 0xe0, 0xfd, 0xaf, 0x29, 0x22, 0xf1, 0xb6, 0x78, 0xa5, 0x74, 0x01, 0xf2, 0x22, 0x7b, 0x01,
+ 0x7a, 0x00, 0x79, 0x8a, 0xaf, 0x29, 0x22, 0x8d, 0x34, 0xac, 0x03, 0xe4, 0xfe, 0xf1, 0x6e, 0xae,
+ 0x07, 0x90, 0x00, 0xb9, 0xe0, 0x90, 0x00, 0xac, 0x60, 0x1e, 0xe0, 0x44, 0x80, 0xff, 0xf0, 0xec,
+ 0x54, 0x1f, 0x25, 0xe0, 0x25, 0xe0, 0xfd, 0xef, 0x54, 0x83, 0x4d, 0xff, 0xf0, 0xee, 0x54, 0x03,
+ 0xfe, 0xef, 0x54, 0xfc, 0x4e, 0xf0, 0x80, 0x03, 0x74, 0x7c, 0xf0, 0x90, 0x00, 0x74, 0x11, 0x5e,
+ 0x89, 0x82, 0xf5, 0x83, 0xec, 0xf0, 0x90, 0x00, 0x76, 0x11, 0x5e, 0xf5, 0x83, 0x89, 0x82, 0xec,
+ 0xf0, 0xe5, 0x34, 0x70, 0x0b, 0x75, 0x14, 0x03, 0x90, 0x00, 0xae, 0x74, 0x02, 0xf0, 0x80, 0x0b,
+ 0x75, 0x14, 0x03, 0x90, 0x00, 0xae, 0x74, 0x01, 0x11, 0x68, 0xf0, 0x7f, 0x00, 0x22, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0x24, 0x02, 0xf9, 0xe4, 0x3e, 0x22, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xff, 0xa3, 0xe0,
+ 0x90, 0x00, 0x6c, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0x90,
+ 0x00, 0x6e, 0xcf, 0xf0, 0xa3, 0xef, 0x22, 0x90, 0x00, 0x66, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x22,
+ 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x44, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x64,
+ 0xf0, 0x90, 0x00, 0x74, 0x74, 0x10, 0xf0, 0xa3, 0x74, 0x2b, 0xf0, 0xa3, 0x74, 0x10, 0xf0, 0xa3,
+ 0x74, 0x4d, 0x11, 0x68, 0xf0, 0x74, 0x00, 0x24, 0x02, 0xff, 0xe4, 0x90, 0x00, 0x62, 0x12, 0x57,
+ 0x6f, 0x7c, 0x10, 0x7d, 0x02, 0x7b, 0x12, 0x7a, 0x00, 0x31, 0x58, 0x74, 0x00, 0x24, 0x22, 0xff,
+ 0xe4, 0x90, 0x00, 0x64, 0x12, 0x57, 0x6f, 0x7c, 0x10, 0x7d, 0x16, 0x7b, 0x0a, 0x7a, 0x00, 0x31,
+ 0x58, 0x7c, 0x01, 0x7d, 0x00, 0xed, 0x24, 0x42, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x72, 0xf0, 0xa3,
+ 0xce, 0xf0, 0xed, 0x24, 0xc2, 0xfe, 0xe4, 0x3c, 0x90, 0x00, 0x70, 0xf0, 0xa3, 0xce, 0xf0, 0x74,
+ 0x00, 0x24, 0x42, 0xfe, 0x74, 0x01, 0x34, 0x01, 0x90, 0x00, 0x78, 0xf0, 0xa3, 0xce, 0xf0, 0x90,
+ 0x00, 0x6a, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xac, 0x06, 0x90, 0x00, 0x99, 0xec, 0x31, 0x46, 0xfb,
+ 0x7a, 0x00, 0xed, 0x2b, 0x90, 0x00, 0x9b, 0x31, 0x3f, 0x2d, 0x90, 0x00, 0x9d, 0x31, 0x3f, 0x2d,
+ 0xfe, 0xea, 0x3c, 0x90, 0x00, 0x9f, 0xf0, 0xa3, 0xce, 0x12, 0x2f, 0x81, 0x02, 0x2f, 0x87, 0xff,
+ 0xea, 0x3c, 0xfe, 0xad, 0x07, 0xfc, 0xf0, 0xa3, 0xed, 0xf0, 0xf5, 0x82, 0x8e, 0x83, 0xe0, 0x22,
+ 0x7b, 0x11, 0x7c, 0xe2, 0x7d, 0x08, 0x7a, 0x00, 0x8e, 0x54, 0x8f, 0x55, 0x8c, 0x56, 0x8d, 0x57,
+ 0x8a, 0x58, 0x8b, 0x59, 0x12, 0x57, 0x34, 0x12, 0x0e, 0xb8, 0xe5, 0x54, 0xf5, 0x9a, 0xe5, 0x55,
+ 0xf5, 0x9b, 0xe5, 0x56, 0xf5, 0x9d, 0xe5, 0x57, 0xf5, 0x9e, 0xe5, 0x59, 0x15, 0x59, 0xae, 0x58,
+ 0x70, 0x02, 0x15, 0x58, 0x4e, 0x60, 0x08, 0x78, 0x7c, 0xe2, 0x78, 0x7b, 0xf2, 0x80, 0xeb, 0x12,
+ 0x0e, 0xe6, 0x12, 0x0e, 0xcf, 0x85, 0x5a, 0xe8, 0x22, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0,
+ 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04,
+ 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x75, 0x53, 0x00, 0x53, 0x91, 0xdf, 0xc2, 0x2c, 0xc2, 0x2d,
+ 0x90, 0xe2, 0x6f, 0xe0, 0x90, 0x04, 0x6e, 0xf0, 0x90, 0xe2, 0x6e, 0xe0, 0x90, 0x04, 0x6f, 0xf0,
+ 0x90, 0xe2, 0x71, 0xe0, 0x90, 0x04, 0x70, 0xf0, 0x90, 0xe2, 0x70, 0xe0, 0x90, 0x04, 0x71, 0xf0,
+ 0x90, 0xe2, 0x73, 0xe0, 0x90, 0x04, 0x72, 0xf0, 0x90, 0xe2, 0x72, 0xe0, 0x90, 0x04, 0x73, 0xf0,
+ 0x90, 0xe2, 0x6d, 0xe0, 0x90, 0x04, 0x6c, 0xf0, 0x90, 0xe2, 0x6c, 0xe0, 0x90, 0x04, 0x6d, 0xf0,
+ 0x90, 0x04, 0x6c, 0xe0, 0xff, 0x54, 0x0f, 0xf5, 0x51, 0xa3, 0xe0, 0xf5, 0x52, 0xef, 0x20, 0xe6,
+ 0x61, 0xe5, 0x52, 0x70, 0x5a, 0xaf, 0x51, 0x04, 0xa8, 0x07, 0x08, 0x80, 0x02, 0xc3, 0x33, 0xd8,
+ 0xfc, 0xff, 0x90, 0x00, 0xfd, 0xe0, 0xfe, 0x5f, 0x70, 0x02, 0x81, 0xdd, 0xee, 0x6f, 0xf0, 0xe5,
+ 0x51, 0x64, 0x03, 0x60, 0x02, 0x81, 0xdd, 0xe0, 0x30, 0xe2, 0x17, 0x90, 0x04, 0x6c, 0xe0, 0x30,
+ 0xe4, 0x10, 0x12, 0x3b, 0x0f, 0x75, 0x5b, 0x00, 0x12, 0x45, 0x15, 0x90, 0x00, 0xfd, 0xe0, 0x54,
+ 0xfb, 0xf0, 0x20, 0x26, 0x02, 0x81, 0xdd, 0x12, 0x57, 0x4f, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x8b,
+ 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0xb5, 0xf0, 0xd2, 0xe8, 0xc2, 0x26, 0x81, 0xdd, 0x43,
+ 0x52, 0x80, 0xb1, 0x0e, 0xe0, 0xfc, 0x70, 0x6c, 0x12, 0x57, 0x2a, 0xf5, 0x83, 0xe5, 0x52, 0xf0,
+ 0x90, 0x04, 0x6c, 0xe0, 0x30, 0xe7, 0x44, 0x91, 0xf8, 0xe0, 0xfd, 0xb1, 0x3d, 0xb1, 0x0e, 0xe0,
+ 0x24, 0x06, 0xf0, 0xb1, 0x0e, 0xb1, 0x1a, 0xef, 0xf0, 0xe5, 0x51, 0xb4, 0x03, 0x1d, 0xe5, 0x52,
+ 0xb4, 0x0c, 0x04, 0xd2, 0x2d, 0x80, 0x16, 0xe5, 0x52, 0xb4, 0x0f, 0x0b, 0xc2, 0x25, 0x90, 0xe6,
+ 0xa0, 0xe0, 0x44, 0x80, 0xf0, 0x81, 0xce, 0xd2, 0x2c, 0x80, 0x02, 0xd2, 0x2c, 0xe5, 0x51, 0x70,
+ 0x73, 0xe5, 0x52, 0x64, 0x11, 0x70, 0x6d, 0xd2, 0x22, 0x80, 0x69, 0x90, 0x04, 0x6f, 0xe0, 0x25,
+ 0xe0, 0xb1, 0x1b, 0xef, 0xf0, 0x91, 0xf8, 0xe0, 0xfd, 0x12, 0x51, 0x71, 0xb1, 0x0e, 0xe0, 0x24,
+ 0x04, 0xf0, 0x80, 0x50, 0x12, 0x57, 0x2a, 0xf5, 0x83, 0xe0, 0x65, 0x52, 0x60, 0x02, 0x80, 0x2a,
+ 0xe5, 0x51, 0x25, 0xe0, 0x24, 0x89, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x12, 0x3a, 0x7c,
+ 0xad, 0x04, 0xb1, 0x3d, 0xb1, 0x0e, 0xe0, 0x24, 0x06, 0xf0, 0x90, 0x04, 0x6c, 0xe0, 0x30, 0xe7,
+ 0x23, 0xb1, 0x0e, 0xb1, 0x1a, 0xe0, 0xd3, 0x9f, 0x40, 0x0a, 0xb1, 0x1c, 0xe4, 0xf0, 0xb1, 0x0e,
+ 0xe4, 0xf0, 0x80, 0x10, 0xe5, 0x51, 0xb4, 0x03, 0x09, 0xe5, 0x52, 0xb4, 0x0c, 0x04, 0xd2, 0x2d,
+ 0x80, 0x02, 0xd2, 0x2c, 0x30, 0x2c, 0x41, 0xe5, 0x52, 0x64, 0xa7, 0x70, 0x26, 0x12, 0x47, 0x5a,
+ 0x7e, 0xf8, 0x7f, 0x00, 0x12, 0x17, 0xd7, 0xe0, 0xfb, 0x24, 0x02, 0xfd, 0xe4, 0x3a, 0xfc, 0x8b,
+ 0x82, 0x8a, 0x83, 0xa3, 0xe0, 0xfb, 0x7a, 0x00, 0x31, 0x58, 0x12, 0x14, 0xb1, 0xff, 0x7e, 0x00,
+ 0x12, 0x3b, 0x53, 0x74, 0x01, 0x7e, 0x00, 0xa8, 0x51, 0x08, 0x80, 0x05, 0xc3, 0x33, 0xce, 0x33,
+ 0xce, 0xd8, 0xf9, 0x42, 0x21, 0xee, 0x42, 0x20, 0x20, 0x2d, 0x02, 0x81, 0xdd, 0x12, 0x17, 0xc3,
+ 0xe0, 0xc4, 0x13, 0x54, 0x01, 0xfd, 0x90, 0x04, 0xaf, 0xf0, 0x8f, 0x82, 0x8e, 0x83, 0xa3, 0xe0,
+ 0x90, 0x04, 0xb0, 0xf0, 0xed, 0x60, 0x22, 0x90, 0xe6, 0xa2, 0xe0, 0x30, 0xe1, 0x05, 0x75, 0x53,
+ 0x04, 0x81, 0xce, 0x7e, 0xe7, 0x7f, 0xc0, 0xb1, 0x2f, 0xfc, 0x90, 0x04, 0xb0, 0xe0, 0xfb, 0x7a,
+ 0x00, 0xb1, 0x28, 0x90, 0xe6, 0x8f, 0xf0, 0x81, 0xce, 0x90, 0xe6, 0xbf, 0xe0, 0xfe, 0x90, 0xe6,
+ 0xbe, 0xe0, 0xfd, 0x90, 0x04, 0xab, 0x12, 0x4d, 0x0b, 0x12, 0x0f, 0xf8, 0xf5, 0x82, 0x8e, 0x83,
+ 0xe0, 0x30, 0xe4, 0x1f, 0x75, 0x1e, 0x00, 0x75, 0x1f, 0x00, 0x30, 0x24, 0x16, 0x90, 0x04, 0x87,
+ 0xa3, 0xe0, 0xff, 0x12, 0x17, 0xa4, 0xe0, 0x24, 0x17, 0xf0, 0xef, 0x24, 0x06, 0x12, 0x17, 0xa6,
+ 0xe0, 0x04, 0xf0, 0x90, 0x04, 0xab, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xd3, 0x95, 0x1f, 0xee, 0x95,
+ 0x1e, 0x50, 0x02, 0x81, 0x96, 0xef, 0x95, 0x1f, 0xff, 0xee, 0x95, 0x1e, 0xfe, 0xa3, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x12, 0x57, 0x5f, 0xd3, 0xef, 0x9d, 0xee, 0x9c, 0x40, 0x08, 0x90, 0x04, 0xad, 0xec,
+ 0xf0, 0xa3, 0xed, 0xf0, 0x12, 0x17, 0xc3, 0xe0, 0x30, 0xe3, 0x21, 0x30, 0x24, 0x68, 0x12, 0x57,
+ 0x5f, 0xef, 0x2d, 0xff, 0xec, 0x3e, 0xcf, 0x24, 0x02, 0xcf, 0x34, 0x00, 0xfe, 0x7b, 0x17, 0x7a,
+ 0x00, 0xad, 0x16, 0xac, 0x15, 0xb1, 0x28, 0x24, 0x17, 0xf0, 0x80, 0x4a, 0x12, 0x57, 0x4f, 0x90,
+ 0x04, 0xad, 0xe0, 0xfa, 0xa3, 0xe0, 0xfb, 0x4a, 0x60, 0x09, 0x7e, 0xe7, 0x7f, 0x40, 0xb1, 0x2f,
+ 0xfc, 0x31, 0x58, 0x90, 0xe6, 0x8a, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0x04, 0xae, 0xe0, 0x90,
+ 0xe6, 0x8b, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0xa0, 0xe0, 0x20, 0xe1, 0xf9, 0x90, 0x04, 0xad,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0x25, 0x1f, 0xf5, 0x1f, 0xee, 0x35, 0x1e, 0xf5, 0x1e, 0x90, 0xe6, 0xb5,
+ 0xe4, 0xf0, 0xd2, 0xe8, 0x80, 0x38, 0xd3, 0x90, 0x04, 0xac, 0xe0, 0x95, 0x1f, 0x90, 0x04, 0xab,
+ 0xe0, 0x95, 0x1e, 0x40, 0x29, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x8a, 0xe4, 0xf0, 0x00, 0x00, 0x00,
+ 0x90, 0x04, 0xb0, 0xe0, 0x90, 0xe6, 0x8b, 0xf0, 0x00, 0x00, 0x00, 0xb1, 0x2f, 0xfc, 0x90, 0xe6,
+ 0xb3, 0xf0, 0xaf, 0x05, 0xef, 0xa3, 0xf0, 0x90, 0xe6, 0xa0, 0xe0, 0x20, 0xe1, 0xf9, 0xb1, 0x1c,
+ 0xe4, 0xf0, 0xb1, 0x0e, 0xe4, 0xf0, 0xad, 0x53, 0xaf, 0x51, 0x12, 0x2a, 0xeb, 0xd0, 0x07, 0xd0,
+ 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0,
+ 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xe5, 0x51, 0x25, 0xe0, 0x24, 0x89, 0xf5, 0x82,
+ 0xe4, 0x34, 0x04, 0xf5, 0x83, 0xe0, 0xfe, 0xa3, 0xe0, 0xaa, 0x06, 0xf9, 0x7b, 0x01, 0x74, 0x7e,
+ 0x25, 0x51, 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0xe0, 0xff, 0x74, 0x79, 0x25, 0x51,
+ 0xf5, 0x82, 0xe4, 0x34, 0x04, 0xf5, 0x83, 0x22, 0x31, 0x58, 0x90, 0x04, 0xb0, 0xe0, 0x22, 0x90,
+ 0x04, 0x88, 0xe0, 0x24, 0x02, 0xfd, 0x90, 0x04, 0x87, 0xe0, 0x34, 0x00, 0x22, 0x8b, 0x54, 0x8a,
+ 0x55, 0x89, 0x56, 0x90, 0x04, 0x6e, 0xb1, 0x7c, 0x90, 0x04, 0x6f, 0xb1, 0x7c, 0xb1, 0x5b, 0x90,
+ 0x04, 0x73, 0xe0, 0x8d, 0x82, 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x90, 0x04, 0x70, 0xe0, 0xae,
+ 0x05, 0x0d, 0x8e, 0x82, 0x75, 0x83, 0x00, 0x12, 0x0b, 0x7c, 0x90, 0x04, 0x71, 0xe0, 0xae, 0x05,
+ 0x0d, 0x8e, 0x82, 0x75, 0x83, 0x00, 0x12, 0x0b, 0x7c, 0x90, 0x04, 0x72, 0xe0, 0xae, 0x05, 0x0d,
+ 0x8e, 0x82, 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x8f, 0x32, 0xe4, 0xf5, 0x33, 0x75, 0x34, 0x3f,
+ 0xf5, 0x19, 0x12, 0x53, 0xda, 0xf1, 0xf1, 0xe5, 0x32, 0xb4, 0x02, 0x0e, 0x30, 0x2b, 0x03, 0x75,
+ 0x1a, 0x40, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xa4, 0x80, 0x09, 0x75, 0x1a, 0x40, 0xe4, 0xfb, 0x7d,
+ 0x26, 0x7f, 0x04, 0xd1, 0x6b, 0x12, 0x20, 0x07, 0xef, 0x60, 0x02, 0xc1, 0x6a, 0xe5, 0x32, 0xb4,
+ 0x02, 0x09, 0x90, 0xe2, 0x0a, 0xe0, 0x20, 0xe5, 0x0e, 0x80, 0x08, 0x90, 0xe2, 0x0a, 0xe0, 0x64,
+ 0xfe, 0x60, 0x04, 0x75, 0x19, 0x88, 0x22, 0xe5, 0x33, 0x70, 0x55, 0xe5, 0x34, 0x60, 0x51, 0xe5,
+ 0x32, 0x64, 0x02, 0x70, 0x20, 0xf5, 0x1a, 0xf5, 0x1b, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x12, 0x20,
+ 0x5d, 0xef, 0x70, 0x76, 0x30, 0x2b, 0x03, 0x75, 0x1a, 0x40, 0x75, 0x1b, 0x3c, 0xe4, 0xfb, 0x7d,
+ 0x26, 0x7f, 0xa4, 0x80, 0x0f, 0x75, 0x1a, 0x40, 0x75, 0x1b, 0xff, 0x75, 0x1c, 0x80, 0xe4, 0xfb,
+ 0x7d, 0x26, 0x7f, 0x04, 0xd1, 0x6b, 0x12, 0x20, 0x07, 0xef, 0x70, 0x4e, 0x90, 0xe2, 0x08, 0xe0,
+ 0x54, 0x02, 0xf5, 0x33, 0x70, 0xb1, 0x7f, 0x64, 0xfe, 0x12, 0x50, 0x6e, 0x15, 0x34, 0x80, 0xa7,
+ 0xe5, 0x33, 0x70, 0x04, 0x75, 0x19, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x45, 0x7b, 0x05, 0x31, 0x52,
+ 0x90, 0xe2, 0x08, 0xe0, 0x30, 0xe0, 0x06, 0x90, 0x04, 0x39, 0x74, 0x01, 0xf0, 0x90, 0xe2, 0x1e,
+ 0x74, 0x14, 0xf0, 0x12, 0x0e, 0x97, 0xf1, 0xf1, 0xe4, 0xfb, 0x7d, 0x7e, 0x7f, 0x08, 0x12, 0x20,
+ 0x5d, 0xef, 0x70, 0x06, 0x7e, 0x04, 0x7f, 0x4a, 0x31, 0x50, 0x22, 0xae, 0x07, 0xf1, 0xe2, 0x90,
+ 0xe2, 0x1a, 0xed, 0xf0, 0xd1, 0xe2, 0xe5, 0x1a, 0x54, 0xc0, 0xff, 0xc4, 0x13, 0x13, 0x54, 0x03,
+ 0x4e, 0x90, 0xe2, 0x00, 0xf0, 0xd1, 0xe2, 0xe5, 0x1a, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x1b,
+ 0x90, 0xe2, 0x01, 0xf1, 0xa0, 0xe5, 0x1b, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0x1c, 0xc4, 0x13,
+ 0x13, 0x54, 0x03, 0x4f, 0x90, 0xe2, 0x02, 0xf0, 0xd1, 0xe2, 0xe5, 0x1c, 0x25, 0xe0, 0x25, 0xe0,
+ 0xff, 0xe5, 0x1d, 0x90, 0xe2, 0x03, 0xf1, 0xa0, 0xe5, 0x1d, 0x25, 0xe0, 0x25, 0xe0, 0x90, 0xe2,
+ 0x04, 0xd1, 0xd1, 0xeb, 0x44, 0x01, 0x90, 0xe2, 0x21, 0xf0, 0x80, 0x16, 0x90, 0xe2, 0x00, 0x74,
+ 0x30, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x22, 0x74, 0xff, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x31, 0x74,
+ 0xff, 0xf0, 0x90, 0x00, 0xe4, 0xe0, 0xff, 0xef, 0x60, 0x04, 0x00, 0x1f, 0x80, 0xf9, 0x22, 0xc2,
+ 0x23, 0xef, 0x60, 0x1f, 0x12, 0x37, 0x8c, 0xf1, 0xa9, 0x30, 0x27, 0x0d, 0xe4, 0x90, 0xe6, 0x1b,
+ 0xf0, 0xd2, 0x23, 0x74, 0xe0, 0xf1, 0xdc, 0xf1, 0x5c, 0xf1, 0x5c, 0x90, 0xe6, 0x1a, 0x74, 0x48,
+ 0xf0, 0xe1, 0xe9, 0xe4, 0x90, 0xe6, 0x1b, 0x12, 0x25, 0xa8, 0xd1, 0xe2, 0x74, 0x88, 0xf1, 0x66,
+ 0x12, 0x27, 0xf3, 0xd1, 0xe2, 0x90, 0xe6, 0x1b, 0x74, 0x48, 0xf0, 0x22, 0x12, 0x17, 0xb6, 0x12,
+ 0x37, 0x8c, 0xf1, 0xa9, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x00,
+ 0xf0, 0xd1, 0xe2, 0x74, 0xe2, 0xf1, 0xdc, 0x12, 0x49, 0x48, 0xd1, 0xe2, 0x90, 0xe6, 0x15, 0x74,
+ 0x62, 0xf0, 0xd1, 0xe2, 0x12, 0x56, 0xa0, 0xf1, 0xe9, 0xc2, 0x23, 0x22, 0x90, 0xe6, 0x48, 0x74,
+ 0x86, 0xf0, 0xd1, 0xe2, 0x74, 0x86, 0x90, 0xe6, 0x48, 0xf0, 0xc1, 0xe2, 0x74, 0x02, 0x12, 0x56,
+ 0xf3, 0x90, 0xe2, 0x19, 0x74, 0xa5, 0xf0, 0xd1, 0xe2, 0xf1, 0xe2, 0x90, 0xe2, 0x1e, 0x74, 0x14,
+ 0xf0, 0xd1, 0xe2, 0xe4, 0x90, 0xe2, 0x32, 0xf0, 0xd1, 0xe2, 0xe4, 0x12, 0x57, 0x46, 0x12, 0x57,
+ 0x58, 0x90, 0xe2, 0x2e, 0x74, 0x03, 0xf0, 0xd1, 0xe2, 0x90, 0xe2, 0x29, 0x74, 0xff, 0xf0, 0x22,
+ 0xc4, 0x13, 0x13, 0x54, 0x03, 0x4f, 0xf0, 0xc1, 0xe2, 0xd1, 0xe2, 0xe4, 0x90, 0xe6, 0x1a, 0xf0,
+ 0xd1, 0xe2, 0x90, 0xe6, 0x04, 0x74, 0x06, 0xf0, 0x22, 0x12, 0x3c, 0x72, 0xc2, 0x2a, 0xd1, 0xcc,
+ 0x90, 0xe2, 0x21, 0x74, 0x01, 0xf0, 0xf1, 0xf1, 0x12, 0x47, 0x42, 0x12, 0x20, 0x07, 0xef, 0x60,
+ 0x03, 0xaf, 0x19, 0x22, 0xf1, 0xfe, 0xef, 0x60, 0x02, 0xaf, 0x19, 0x22, 0x90, 0xe6, 0x14, 0xf0,
+ 0xc1, 0xe2, 0xe4, 0x90, 0xe2, 0x1b, 0xf0, 0xc1, 0xe2, 0xd1, 0xe2, 0xe4, 0x90, 0xe6, 0x04, 0xf0,
+ 0x22, 0xe4, 0xf5, 0x1a, 0xf5, 0x1b, 0xf5, 0x1c, 0xf5, 0x1d, 0x22, 0xe0, 0xf5, 0x1b, 0xe4, 0xfb,
+ 0x7f, 0x34, 0x7d, 0x26, 0x12, 0x1e, 0x6b, 0x74, 0xff, 0xf5, 0x3b, 0xf5, 0x3c, 0x90, 0xe2, 0x22,
+ 0xe0, 0x54, 0x66, 0x70, 0x11, 0x12, 0x0e, 0x8d, 0xe5, 0x3c, 0x15, 0x3c, 0x70, 0x02, 0x15, 0x3b,
+ 0xe5, 0x3c, 0x45, 0x3b, 0x70, 0xe7, 0xe5, 0x19, 0x70, 0x28, 0x90, 0xe2, 0x22, 0xe0, 0x20, 0xe1,
+ 0x0d, 0x75, 0x19, 0x89, 0x12, 0x14, 0xc2, 0x74, 0x03, 0xf0, 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04,
+ 0x37, 0xe0, 0x60, 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60, 0x60, 0x06, 0x12, 0x14, 0xbf, 0x74,
+ 0x01, 0xf0, 0xaf, 0x19, 0x22, 0xe4, 0xf5, 0x1d, 0xfb, 0x7f, 0x18, 0x7d, 0x26, 0x12, 0x1e, 0x6b,
+ 0x80, 0xa5, 0x75, 0x31, 0x02, 0x7f, 0x02, 0x12, 0x1d, 0x88, 0xe5, 0x19, 0x60, 0x02, 0x21, 0xb4,
+ 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x0c, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xe2, 0x08,
+ 0xe0, 0x54, 0xfc, 0x64, 0x0c, 0x70, 0x37, 0x12, 0x57, 0x20, 0x54, 0x1f, 0x64, 0x02, 0x70, 0x2e,
+ 0x90, 0xe2, 0x08, 0x12, 0x56, 0xc7, 0xa3, 0xe0, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90, 0x04, 0x33,
+ 0xf0, 0x90, 0xe2, 0x09, 0x12, 0x56, 0xc7, 0xa3, 0xe0, 0xfe, 0x13, 0x13, 0x54, 0x3f, 0x4f, 0x90,
+ 0x04, 0x34, 0xf0, 0xe0, 0x70, 0x0c, 0x90, 0x04, 0x33, 0xe0, 0x70, 0x06, 0x80, 0xb2, 0x75, 0x19,
+ 0x8b, 0x22, 0x7f, 0x02, 0xd1, 0x6d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x12, 0x52, 0xea, 0x12, 0x44,
+ 0x6b, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xe2, 0x09, 0xe0, 0x30, 0xe3, 0x08, 0x90, 0x04, 0x3a, 0x74,
+ 0x01, 0xf0, 0x21, 0x9b, 0xb1, 0xb3, 0x12, 0x57, 0x19, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4,
+ 0x12, 0x57, 0x20, 0x54, 0x1f, 0x64, 0x04, 0x60, 0x04, 0x75, 0x19, 0x8a, 0x22, 0x7d, 0x08, 0x12,
+ 0x53, 0xd5, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0xcc, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4, 0x31,
+ 0xb5, 0x60, 0x02, 0x21, 0xb4, 0x90, 0xfc, 0x00, 0xe0, 0x54, 0x0f, 0x90, 0x04, 0x35, 0xf0, 0x90,
+ 0xfc, 0x01, 0xe0, 0x30, 0xe2, 0x1c, 0x12, 0x57, 0x19, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x21, 0xb4,
+ 0x12, 0x1f, 0xf1, 0x75, 0x1d, 0x02, 0xe4, 0x11, 0x58, 0xef, 0x70, 0x78, 0x90, 0xe2, 0x1f, 0x74,
+ 0x06, 0xf0, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0, 0x90, 0x04, 0x35, 0xe0, 0xd3, 0x94, 0x00, 0x40,
+ 0x4a, 0xe4, 0xf5, 0x1a, 0x75, 0x1b, 0xff, 0x75, 0x1c, 0xff, 0x75, 0x1d, 0xf1, 0x7d, 0x40, 0xff,
+ 0xf1, 0xcf, 0xb1, 0xac, 0xe4, 0x90, 0xfc, 0x0d, 0xf0, 0x7b, 0x04, 0x11, 0x59, 0x31, 0xb5, 0x70,
+ 0x43, 0x90, 0xfc, 0x0d, 0xe0, 0x30, 0xe1, 0x23, 0xb1, 0xac, 0xe4, 0x90, 0xfc, 0x10, 0xf0, 0x75,
+ 0x1a, 0x80, 0x7b, 0x04, 0x11, 0x59, 0x31, 0xb5, 0x70, 0x2a, 0x90, 0xfc, 0x10, 0xe0, 0x54, 0x0f,
+ 0x64, 0x01, 0x60, 0x04, 0x75, 0x19, 0x83, 0x22, 0x12, 0x52, 0xfb, 0x90, 0x04, 0x37, 0x74, 0x02,
+ 0xf0, 0x90, 0x00, 0xea, 0xe0, 0x60, 0x0d, 0xe5, 0xa0, 0x55, 0x31, 0x60, 0x07, 0x90, 0x04, 0x32,
+ 0xe0, 0x44, 0x01, 0xf0, 0x22, 0x7f, 0x10, 0x71, 0xe7, 0xef, 0x22, 0x74, 0x01, 0x12, 0x56, 0xf3,
+ 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x1e, 0x6b, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0x7f, 0x05,
+ 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x7f, 0x04, 0x12, 0x1d, 0x88, 0xe5, 0x19, 0x60, 0x02, 0x41, 0x90,
+ 0xe4, 0x90, 0x04, 0x33, 0xf0, 0xa3, 0x74, 0x03, 0xf0, 0xe4, 0xf5, 0x1a, 0x75, 0x1b, 0x03, 0xfb,
+ 0x7d, 0x26, 0x7f, 0x0c, 0x11, 0x5d, 0xef, 0x60, 0x02, 0x41, 0x90, 0x7f, 0x04, 0xd1, 0x6d, 0xef,
+ 0x60, 0x02, 0x41, 0x90, 0x12, 0x52, 0xcf, 0x12, 0x44, 0x6b, 0x60, 0x02, 0x41, 0x90, 0x90, 0x04,
+ 0x35, 0xe0, 0xd3, 0x94, 0x03, 0x40, 0x73, 0x12, 0x53, 0x50, 0xb1, 0xac, 0xf1, 0xcb, 0xf1, 0xfa,
+ 0x7f, 0x20, 0x11, 0x5d, 0xef, 0x70, 0x69, 0x31, 0xb5, 0x70, 0x65, 0x75, 0x1a, 0x03, 0x75, 0x1b,
+ 0xb9, 0x75, 0x1c, 0x01, 0x11, 0x55, 0x90, 0xfc, 0xc4, 0xe0, 0xb4, 0x03, 0x05, 0x12, 0x52, 0xfb,
+ 0x80, 0x03, 0x12, 0x52, 0xea, 0x90, 0x04, 0x39, 0xe0, 0x60, 0x3a, 0x90, 0xfc, 0xd7, 0xe0, 0xff,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfe, 0xd1, 0x5f, 0xef, 0xf0, 0x90, 0xfc, 0xd6, 0xe0, 0xff, 0xee, 0x12,
+ 0x4e, 0x36, 0xef, 0xf0, 0x90, 0xfc, 0xd5, 0xe0, 0xff, 0xee, 0x12, 0x4e, 0x4a, 0xef, 0xf0, 0x90,
+ 0xfc, 0xd4, 0xe0, 0xff, 0xee, 0x12, 0x4e, 0x28, 0xef, 0xf0, 0xee, 0xd1, 0x5f, 0x12, 0x56, 0x6b,
+ 0xd1, 0x5b, 0x12, 0x0c, 0xd9, 0xf1, 0xf3, 0x12, 0x0e, 0x7c, 0x90, 0x04, 0x37, 0x74, 0x04, 0xf0,
+ 0x22, 0x8f, 0x30, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x54, 0x1e, 0x60, 0x01, 0x22, 0x12, 0x52, 0xa7,
+ 0xe5, 0x30, 0x54, 0x1e, 0x70, 0x02, 0x61, 0x6e, 0x12, 0x53, 0x12, 0x12, 0x1f, 0x6c, 0xe4, 0x90,
+ 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xdc, 0xf0, 0x12, 0x47, 0xde, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0xe4, 0xf5, 0x19, 0x12, 0x1f, 0xf1, 0xe4, 0xfb, 0xfd, 0xff, 0x12, 0x1e, 0x6b, 0x90, 0xe2,
+ 0x22, 0xe0, 0x30, 0xe0, 0xf9, 0x7f, 0x05, 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x75, 0x1c, 0x01, 0x75,
+ 0x1d, 0xaa, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x20, 0x11, 0x5d, 0xe5, 0x19, 0x70, 0x18, 0x90, 0xe2,
+ 0x0b, 0xe0, 0xb4, 0x06, 0x0c, 0xa3, 0xe0, 0x54, 0xfc, 0xff, 0xbf, 0xa8, 0x04, 0xd2, 0x2b, 0x80,
+ 0x05, 0x75, 0x19, 0x9a, 0x80, 0x68, 0xe4, 0xf5, 0x19, 0x12, 0x1f, 0xf1, 0x12, 0x57, 0x19, 0x11,
+ 0x5d, 0xe5, 0x19, 0x70, 0x2c, 0x90, 0xe2, 0x08, 0xe0, 0x64, 0xdc, 0x70, 0x24, 0xe5, 0x30, 0x30,
+ 0xe1, 0x1f, 0x11, 0x62, 0x12, 0x53, 0xe1, 0xe5, 0x19, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44,
+ 0x02, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x02, 0xf0, 0x80,
+ 0x2d, 0xe5, 0x19, 0x64, 0x89, 0x70, 0x24, 0xe5, 0x30, 0x30, 0xe2, 0x1f, 0x31, 0xbb, 0x12, 0x53,
+ 0xe1, 0xe5, 0x19, 0x70, 0x16, 0x90, 0x00, 0xc8, 0xe0, 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc7, 0xe0,
+ 0x44, 0x04, 0xf0, 0x90, 0x00, 0xc6, 0x74, 0x04, 0xf0, 0x80, 0x03, 0xe4, 0xf5, 0x19, 0x12, 0x43,
+ 0x96, 0x70, 0x13, 0x90, 0xe6, 0x0d, 0x04, 0xf0, 0x12, 0x0e, 0x7c, 0x90, 0xe6, 0x0e, 0x74, 0x0a,
+ 0xf0, 0x12, 0x0e, 0x7c, 0x80, 0x32, 0xe4, 0xfd, 0x7f, 0x02, 0xf1, 0x84, 0xf1, 0xfa, 0x7f, 0x44,
+ 0x11, 0x5d, 0x31, 0xb5, 0x70, 0x21, 0x7f, 0x42, 0x7e, 0x57, 0x7d, 0x59, 0x7c, 0x43, 0x90, 0xfc,
+ 0x00, 0x12, 0x17, 0x4c, 0x70, 0x11, 0x7e, 0x00, 0x7f, 0xcb, 0x7c, 0xfc, 0x7d, 0x04, 0x12, 0x55,
+ 0xc3, 0x90, 0x00, 0xdc, 0x74, 0x01, 0xf0, 0x00, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x3f,
+ 0xff, 0xff, 0xb1, 0xac, 0x12, 0x56, 0x9a, 0xc2, 0x07, 0x12, 0x4d, 0x1e, 0x60, 0x04, 0x90, 0xe2,
+ 0x34, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x74, 0x02, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0xe2,
+ 0x21, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x80, 0x8f, 0x3b, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xa1, 0x8f,
+ 0x3f, 0x8e, 0x3e, 0x8d, 0x3d, 0x8c, 0x3c, 0xaf, 0x3f, 0xae, 0x3e, 0xad, 0x3d, 0xac, 0x3c, 0xec,
+ 0x4d, 0x4e, 0x4f, 0x60, 0x33, 0x20, 0x29, 0x30, 0x90, 0xe2, 0x31, 0xe0, 0x55, 0x3b, 0x70, 0x28,
+ 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x64, 0x70, 0x20, 0x20, 0x22, 0x1d, 0x12, 0x0e, 0x8d, 0xe5, 0x3f,
+ 0x24, 0xff, 0xf5, 0x3f, 0xe5, 0x3e, 0x34, 0xff, 0xf5, 0x3e, 0xe5, 0x3d, 0x34, 0xff, 0xf5, 0x3d,
+ 0xe5, 0x3c, 0x34, 0xff, 0xf5, 0x3c, 0x80, 0xbf, 0xe5, 0x19, 0x70, 0x2c, 0x90, 0xe2, 0x31, 0xe0,
+ 0x55, 0x3b, 0x70, 0x10, 0x20, 0x29, 0x0d, 0x75, 0x19, 0x89, 0x12, 0x14, 0xc2, 0x74, 0x03, 0xf0,
+ 0xd2, 0x07, 0x80, 0x14, 0x90, 0x04, 0x37, 0xe0, 0x60, 0x0e, 0x90, 0xe2, 0x22, 0xe0, 0x54, 0x60,
+ 0x60, 0x06, 0x12, 0x14, 0xbf, 0x74, 0x01, 0xf0, 0xaf, 0x19, 0x22, 0x12, 0x4c, 0xf5, 0xe4, 0xf5,
+ 0x19, 0x12, 0x4c, 0xbe, 0xef, 0x60, 0x05, 0x75, 0x19, 0x0c, 0xa1, 0x86, 0x12, 0x4c, 0x1a, 0x12,
+ 0x3f, 0xdf, 0x12, 0x4d, 0x08, 0x4e, 0x70, 0x02, 0xa1, 0x86, 0x12, 0x44, 0x88, 0xe5, 0x35, 0x60,
+ 0x06, 0x20, 0x27, 0x03, 0xd3, 0x80, 0x01, 0xc3, 0x92, 0x15, 0xe4, 0x30, 0x15, 0x0d, 0x12, 0x57,
+ 0x46, 0x90, 0xe2, 0x34, 0xb1, 0xa8, 0x12, 0x56, 0x9a, 0x80, 0x0a, 0x12, 0x57, 0x58, 0x90, 0xe2,
+ 0x1f, 0xe0, 0x44, 0x80, 0xf0, 0x12, 0x1e, 0xd4, 0x12, 0x4c, 0x1a, 0x12, 0x45, 0x9a, 0x30, 0x15,
+ 0x74, 0xb1, 0xac, 0xf1, 0xe1, 0x90, 0x04, 0x2a, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x02, 0xa1,
+ 0x57, 0xe5, 0x19, 0x60, 0x02, 0xa1, 0x57, 0x12, 0x47, 0xd0, 0x90, 0xe2, 0x41, 0xe0, 0x70, 0x03,
+ 0x00, 0x80, 0xf7, 0x7b, 0x04, 0x7d, 0x26, 0x7f, 0x44, 0x12, 0x1e, 0x6b, 0x90, 0x04, 0x39, 0xe0,
+ 0x60, 0x0b, 0xe5, 0x1d, 0x24, 0x01, 0xf5, 0x1d, 0xe4, 0x35, 0x1c, 0x80, 0x09, 0xe4, 0x25, 0x1d,
+ 0xf5, 0x1d, 0xe5, 0x1c, 0x34, 0x02, 0xf5, 0x1c, 0xe4, 0x35, 0x1b, 0xf5, 0x1b, 0xe4, 0x35, 0x1a,
+ 0xf5, 0x1a, 0x12, 0x4c, 0xfe, 0x11, 0x07, 0x7f, 0x10, 0x71, 0xe7, 0x12, 0x41, 0xe3, 0x12, 0x49,
+ 0x13, 0xef, 0x60, 0x07, 0xe5, 0x19, 0x70, 0x03, 0x75, 0x19, 0x99, 0xf1, 0xf3, 0x00, 0xf0, 0x00,
+ 0xb1, 0xac, 0x00, 0x80, 0x90, 0xc2, 0x29, 0x90, 0x00, 0xe2, 0x12, 0x4d, 0x29, 0x7b, 0x04, 0x7d,
+ 0x26, 0x7f, 0x48, 0x11, 0x5d, 0x7f, 0x10, 0x71, 0xe7, 0x12, 0x1e, 0xcc, 0x90, 0xe2, 0x21, 0x74,
+ 0x01, 0xf0, 0x12, 0x1e, 0xe2, 0x11, 0x07, 0xc2, 0x29, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0x7f, 0xf0,
+ 0x00, 0xe4, 0x90, 0xe2, 0x33, 0xf0, 0x00, 0x90, 0xe2, 0x31, 0x74, 0xff, 0xf0, 0x00, 0x90, 0x00,
+ 0xe8, 0xe0, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34, 0xf0, 0x00, 0xe5, 0x19, 0x60, 0x08, 0xb4, 0x99,
+ 0x02, 0xff, 0x22, 0x75, 0x19, 0x37, 0xe5, 0x35, 0x60, 0x1b, 0x85, 0x19, 0x5b, 0xe5, 0x19, 0x60,
+ 0x07, 0xc2, 0x1b, 0x12, 0x17, 0x53, 0x80, 0x0a, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xe5, 0x00, 0x00,
+ 0x00, 0x00, 0x12, 0x45, 0x15, 0xaf, 0x19, 0x22, 0xf0, 0x12, 0x1e, 0xe2, 0x90, 0xe6, 0x04, 0x74,
+ 0x08, 0xf0, 0x22, 0x90, 0x04, 0x65, 0xe0, 0x54, 0x01, 0xff, 0x7e, 0x01, 0x90, 0x04, 0x35, 0xe0,
+ 0xfb, 0x70, 0x17, 0xef, 0x70, 0x0a, 0x90, 0x04, 0x66, 0xe0, 0x54, 0xfe, 0xc3, 0x13, 0x04, 0xfe,
+ 0xaf, 0x06, 0xe4, 0xfc, 0xfd, 0xfe, 0x78, 0x09, 0x80, 0x46, 0xeb, 0x64, 0x01, 0x70, 0x54, 0xf5,
+ 0x32, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x11, 0x5d, 0xef, 0x70, 0x48, 0x7d, 0x40, 0x12, 0x53, 0xd5,
+ 0x7b, 0x04, 0x11, 0x00, 0xef, 0x70, 0x3c, 0x31, 0xb5, 0x70, 0x38, 0x90, 0xfc, 0x0a, 0xe0, 0xff,
+ 0xc4, 0x54, 0x0f, 0xf5, 0x32, 0xf1, 0xf3, 0xb1, 0xac, 0xe5, 0x32, 0xd3, 0x94, 0x00, 0x40, 0x19,
+ 0xe5, 0x32, 0x94, 0x0a, 0x50, 0x13, 0xe4, 0xff, 0x7e, 0x20, 0xfd, 0xfc, 0xa9, 0x32, 0xa8, 0x01,
+ 0x12, 0x0c, 0x54, 0x90, 0x04, 0x3b, 0x02, 0x0c, 0xd9, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xe5, 0x00,
+ 0x00, 0x00, 0x00, 0x22, 0x12, 0x0b, 0xe1, 0xef, 0x24, 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed,
+ 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0xe5, 0x32, 0x2f, 0xf5, 0x32, 0xe5, 0x31, 0x3e, 0xf5,
+ 0x31, 0xe5, 0x30, 0x3d, 0xf5, 0x30, 0xe5, 0x2f, 0x3c, 0xf5, 0x2f, 0x90, 0x00, 0xdb, 0xe0, 0x25,
+ 0xe0, 0x25, 0xe0, 0x24, 0xcb, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x8f, 0x32, 0x12,
+ 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0xfb, 0x7d, 0x7e, 0x7f, 0x24, 0x11, 0x5d, 0xef, 0x60,
+ 0x03, 0x7f, 0x89, 0x22, 0x7e, 0x04, 0x7f, 0x5b, 0x12, 0x19, 0x50, 0xe5, 0x32, 0x64, 0x04, 0x60,
+ 0x05, 0xe5, 0x32, 0xb4, 0x08, 0x0a, 0x90, 0xe2, 0x09, 0xe0, 0xff, 0xc4, 0x54, 0x0f, 0x80, 0x03,
+ 0x12, 0x4c, 0x21, 0x90, 0x04, 0x35, 0xf0, 0xe5, 0x32, 0xb4, 0x02, 0x21, 0x90, 0x04, 0x35, 0xe0,
+ 0x60, 0x1b, 0x90, 0xe2, 0x10, 0x12, 0x0c, 0xa1, 0xee, 0x54, 0xfc, 0xfe, 0xe4, 0x24, 0x00, 0xff,
+ 0xee, 0x34, 0x04, 0x12, 0x4d, 0x41, 0xfc, 0x90, 0x00, 0xdb, 0xe0, 0x80, 0x6e, 0x90, 0xe2, 0x0e,
+ 0xe0, 0x54, 0x3c, 0x13, 0x13, 0x54, 0x3f, 0xfb, 0xa3, 0xe0, 0x54, 0x0f, 0xfe, 0xa3, 0xe0, 0xfd,
+ 0xed, 0xff, 0xe4, 0x8f, 0x36, 0x8e, 0x35, 0xf5, 0x34, 0xf5, 0x33, 0x90, 0xe2, 0x12, 0xe0, 0x54,
+ 0x0e, 0xc3, 0x13, 0xfa, 0xe5, 0x36, 0x24, 0x01, 0xf5, 0x36, 0xe4, 0x3e, 0xf5, 0x35, 0xe4, 0x35,
+ 0x34, 0xf5, 0x34, 0xe4, 0x35, 0x33, 0xf5, 0x33, 0x0a, 0x0a, 0xeb, 0x64, 0x09, 0x60, 0x05, 0xeb,
+ 0x24, 0xf7, 0x2a, 0xfa, 0x12, 0x3d, 0xb1, 0xac, 0x33, 0xab, 0x02, 0xa8, 0x03, 0x12, 0x0c, 0x54,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0x03,
+ 0xff, 0xbf, 0x01, 0x0c, 0xeb, 0xd1, 0x5f, 0x12, 0x56, 0x6b, 0xeb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9,
+ 0x90, 0x00, 0xdb, 0xe0, 0xfb, 0xd1, 0x5f, 0x12, 0x56, 0x6b, 0xeb, 0xd1, 0x5f, 0x12, 0x0c, 0xd9,
+ 0x90, 0xe2, 0x17, 0xe0, 0xc4, 0x13, 0x13, 0x54, 0x03, 0xff, 0x90, 0x04, 0x32, 0xe0, 0x54, 0xfc,
+ 0x4f, 0xf0, 0x90, 0xe2, 0x0f, 0xe0, 0x30, 0xe6, 0x18, 0x12, 0x1f, 0xf1, 0x75, 0x1a, 0x04, 0x75,
+ 0x1b, 0x04, 0xe4, 0xfb, 0xfd, 0x7f, 0x10, 0x12, 0x1e, 0x6b, 0x90, 0xe2, 0x22, 0xe0, 0x30, 0xe0,
+ 0xf9, 0x7f, 0x00, 0x22, 0xf1, 0xdf, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x15, 0x74, 0x62, 0xf2,
+ 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x22, 0x8f, 0x32, 0xad, 0x32, 0xe4, 0xff, 0xf1, 0xdf, 0x12, 0x1f,
+ 0xf1, 0xe4, 0xfb, 0x7f, 0x4c, 0x11, 0x02, 0xef, 0x70, 0x20, 0x90, 0xe2, 0x21, 0x74, 0x02, 0xf0,
+ 0x7f, 0x80, 0x71, 0xe7, 0xef, 0x70, 0x13, 0xad, 0x32, 0xe4, 0xff, 0xf1, 0x84, 0x7b, 0x04, 0x7f,
+ 0x38, 0x11, 0x5b, 0xef, 0x70, 0x04, 0x7f, 0x10, 0x71, 0xe7, 0x22, 0xe4, 0xfd, 0x7f, 0x02, 0xae,
+ 0x07, 0x90, 0xe2, 0x2c, 0xed, 0xf0, 0x12, 0x1e, 0xe2, 0x90, 0xe2, 0x2d, 0xee, 0xf0, 0x22, 0xf1,
+ 0xcf, 0x7d, 0x01, 0x7c, 0x00, 0x7f, 0x30, 0xab, 0x07, 0xed, 0x90, 0xe2, 0x1c, 0xf0, 0xeb, 0x4c,
+ 0xa3, 0xf0, 0x22, 0x90, 0xe6, 0x48, 0x74, 0x88, 0xf0, 0x22, 0x12, 0x1f, 0xf1, 0x7b, 0x04, 0x7d,
+ 0x26, 0x22, 0x75, 0x0d, 0x20, 0x75, 0x0c, 0x83, 0x90, 0x04, 0xc3, 0xe0, 0xf5, 0x0f, 0x90, 0x04,
+ 0xc2, 0xe0, 0xf5, 0x0e, 0x90, 0x00, 0xae, 0xe0, 0xff, 0xc3, 0x74, 0x02, 0x9f, 0xf5, 0x11, 0xe4,
+ 0xf5, 0x10, 0x90, 0x00, 0xac, 0xe0, 0x54, 0x7c, 0x13, 0x13, 0x54, 0x3f, 0xf5, 0x13, 0x90, 0x00,
+ 0xb6, 0xe0, 0xf5, 0x12, 0x11, 0xbf, 0xd1, 0x83, 0xe5, 0x37, 0xf0, 0xa3, 0xe5, 0x36, 0xf0, 0xa3,
+ 0xe5, 0x39, 0xf0, 0xa3, 0xe5, 0x38, 0xf0, 0xa3, 0xe5, 0x3b, 0xf0, 0xa3, 0xe5, 0x3a, 0xf0, 0xe5,
+ 0x34, 0xf1, 0xce, 0xe5, 0x35, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0x90, 0x04, 0x9f, 0x30, 0x15, 0x09,
+ 0x74, 0x43, 0xf0, 0xa3, 0x74, 0x16, 0xf0, 0x80, 0x07, 0x74, 0x02, 0xf0, 0xa3, 0x74, 0x18, 0xf0,
+ 0x90, 0x04, 0x9f, 0xe0, 0xf5, 0x0c, 0xa3, 0xe0, 0xf5, 0x0d, 0xe4, 0xf5, 0x0e, 0x75, 0x0f, 0x04,
+ 0x90, 0x00, 0xeb, 0xf1, 0xea, 0xa3, 0xe0, 0xf5, 0x12, 0xa3, 0xe0, 0xf5, 0x13, 0x11, 0xbf, 0x11,
+ 0x36, 0x90, 0x04, 0x9f, 0xe0, 0x44, 0x80, 0xf5, 0x0c, 0x90, 0x00, 0xef, 0xe0, 0xf5, 0x0e, 0xa3,
+ 0xe0, 0xf5, 0x0f, 0xa3, 0xf1, 0xea, 0x11, 0xbf, 0x11, 0x36, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xe5,
+ 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x22, 0x7d,
+ 0x00, 0x7b, 0x00, 0x7e, 0x00, 0x78, 0x34, 0x7c, 0x00, 0x7a, 0x00, 0x79, 0x0c, 0x7f, 0x08, 0x02,
+ 0x0b, 0x10, 0x90, 0x04, 0x76, 0xe0, 0xf5, 0x26, 0x90, 0x03, 0x50, 0xe0, 0xff, 0xc4, 0x54, 0x0f,
+ 0xf5, 0x27, 0xef, 0x54, 0x0f, 0xf5, 0x28, 0xaf, 0x27, 0x74, 0x01, 0xa8, 0x07, 0x08, 0x80, 0x02,
+ 0xc3, 0x33, 0xd8, 0xfc, 0xf5, 0x29, 0x90, 0x03, 0x51, 0xe0, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1e,
+ 0x12, 0x4c, 0xec, 0xe5, 0x26, 0x12, 0x0d, 0x2b, 0x29, 0x39, 0x00, 0x29, 0x40, 0x01, 0x29, 0x49,
+ 0x02, 0x29, 0x60, 0x03, 0x29, 0x8a, 0x05, 0x2a, 0x47, 0x06, 0x2a, 0x4d, 0x07, 0x2a, 0x4d, 0x08,
+ 0x2a, 0x80, 0x0c, 0x2a, 0xc1, 0x0d, 0x29, 0x6b, 0x0f, 0x2a, 0x65, 0x10, 0x2a, 0x75, 0x11, 0x2a,
+ 0xde, 0x12, 0x2a, 0xc7, 0x13, 0x00, 0x00, 0x2a, 0xe2, 0x7f, 0xff, 0x12, 0x37, 0x93, 0x80, 0x05,
+ 0x7f, 0xff, 0x12, 0x43, 0x4d, 0xad, 0x07, 0x41, 0xda, 0xe4, 0xfd, 0xaf, 0x29, 0x12, 0x44, 0x03,
+ 0x8f, 0x2a, 0xd1, 0x62, 0xe5, 0x2a, 0x70, 0x02, 0x41, 0xe6, 0xad, 0x29, 0x7f, 0x0b, 0xe1, 0xa8,
+ 0x7d, 0x01, 0xaf, 0x29, 0x12, 0x44, 0x03, 0xe4, 0xff, 0xc1, 0x62, 0x75, 0x0d, 0x17, 0x75, 0x0c,
+ 0x82, 0xe4, 0xf5, 0x0f, 0x90, 0x03, 0x50, 0xe0, 0xf5, 0x0e, 0x74, 0xc5, 0x25, 0x27, 0xf1, 0x01,
+ 0xf5, 0x11, 0xe4, 0xf5, 0x10, 0x12, 0x42, 0xd4, 0x01, 0x36, 0x7e, 0x04, 0x7f, 0x97, 0x7b, 0x08,
+ 0x12, 0x37, 0x33, 0x74, 0xc5, 0x25, 0x27, 0xf1, 0x01, 0xfd, 0x60, 0x04, 0xe5, 0x28, 0x60, 0x06,
+ 0x7e, 0x00, 0x7f, 0x00, 0x80, 0x11, 0xe5, 0x27, 0x60, 0x05, 0x90, 0x00, 0xc9, 0x80, 0x03, 0x90,
+ 0x00, 0xbb, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x90, 0x04, 0x95, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x4e,
+ 0x70, 0x04, 0x7f, 0x01, 0xc1, 0x0d, 0x90, 0x04, 0x96, 0xe0, 0x90, 0x04, 0x98, 0xf0, 0x90, 0x04,
+ 0x95, 0xe0, 0x90, 0x04, 0x97, 0xf0, 0x90, 0x00, 0xdc, 0xe0, 0x90, 0x04, 0x9a, 0x60, 0x05, 0x74,
+ 0x02, 0xf0, 0x80, 0x03, 0x74, 0x01, 0xf0, 0xed, 0xb4, 0x01, 0x04, 0x7f, 0x01, 0x80, 0x16, 0x12,
+ 0x47, 0xc9, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x44, 0x80, 0xff, 0x90, 0x04, 0x3a, 0xe0,
+ 0xfe, 0x25, 0xe0, 0x4f, 0xff, 0x90, 0x04, 0x99, 0xef, 0xf0, 0x90, 0x04, 0x3b, 0xe0, 0x90, 0x04,
+ 0x9b, 0xf0, 0x90, 0x04, 0x3c, 0xe0, 0x90, 0x04, 0x9c, 0xf0, 0x90, 0x04, 0x3d, 0xe0, 0x90, 0x04,
+ 0x9d, 0xf0, 0x90, 0x04, 0x3e, 0xe0, 0x90, 0x04, 0x9e, 0xf0, 0xc2, 0xaf, 0x12, 0x47, 0x39, 0x74,
+ 0xc5, 0x25, 0x27, 0xf1, 0x01, 0x90, 0x04, 0x86, 0xf0, 0x74, 0x02, 0x12, 0x56, 0xe8, 0x7a, 0x04,
+ 0x79, 0x97, 0xf1, 0xe4, 0xd2, 0xaf, 0x22, 0x12, 0x57, 0x0f, 0x02, 0x40, 0xf0, 0x90, 0x03, 0x50,
+ 0xe0, 0xff, 0xa3, 0xe0, 0xfd, 0xf1, 0xdd, 0xe5, 0x26, 0x7e, 0x00, 0xb4, 0x07, 0x02, 0x7e, 0x01,
+ 0x8e, 0x30, 0x02, 0x3e, 0x40, 0xf1, 0xdd, 0xaf, 0x27, 0x12, 0x55, 0x23, 0x51, 0xe7, 0x90, 0x00,
+ 0xdc, 0x74, 0x01, 0xf0, 0x22, 0x12, 0x54, 0x85, 0x51, 0xe7, 0xe4, 0x90, 0x00, 0xdc, 0xf0, 0x22,
+ 0x90, 0x03, 0x53, 0xe0, 0xff, 0x54, 0x01, 0xfe, 0x74, 0xe9, 0x25, 0x27, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0xee, 0xf0, 0xe4, 0x90, 0x00, 0xe7, 0xf0, 0xa3, 0xf0, 0x90, 0x03, 0x52, 0xe0,
+ 0x60, 0x13, 0xef, 0x54, 0x02, 0xc3, 0x13, 0x90, 0x00, 0xe7, 0x60, 0x04, 0x74, 0x02, 0x80, 0x02,
+ 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x90, 0xe2, 0x34, 0xf0, 0xe4, 0xfd, 0x80,
+ 0x19, 0x12, 0x57, 0x0f, 0x02, 0x53, 0xf8, 0xe5, 0x27, 0x64, 0x01, 0x70, 0x19, 0xf1, 0xdd, 0xad,
+ 0x28, 0xaf, 0x27, 0x12, 0x3c, 0x7a, 0x8f, 0x2a, 0xad, 0x2a, 0x7f, 0x02, 0x80, 0x0d, 0xc2, 0x15,
+ 0x01, 0x5a, 0x7f, 0x02, 0xb1, 0x18, 0x22, 0xad, 0x07, 0x7f, 0x02, 0xd1, 0x83, 0xed, 0xf1, 0x81,
+ 0xef, 0x54, 0x0f, 0xd1, 0xf7, 0xe4, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xe4, 0xf5,
+ 0x26, 0x90, 0x04, 0x7e, 0xf0, 0x53, 0x21, 0xfe, 0x90, 0x04, 0x74, 0xe0, 0x12, 0x0d, 0x2b, 0x2b,
+ 0x3a, 0x00, 0x2b, 0x51, 0x04, 0x2b, 0x62, 0x05, 0x2b, 0x41, 0x06, 0x2b, 0x47, 0x07, 0x2c, 0x7a,
+ 0x08, 0x2c, 0x7f, 0x09, 0x2b, 0x76, 0x0b, 0x2b, 0xa4, 0x0c, 0x2c, 0xd3, 0x0d, 0x2c, 0xfc, 0x10,
+ 0x2d, 0x01, 0x11, 0x2d, 0x09, 0x13, 0x00, 0x00, 0x2d, 0x16, 0x7d, 0x10, 0xe4, 0xff, 0x02, 0x42,
+ 0x98, 0xe4, 0xff, 0xf1, 0x0a, 0x81, 0xfa, 0x90, 0x03, 0x41, 0xe0, 0x24, 0xff, 0x92, 0x2e, 0x81,
+ 0xfa, 0x75, 0x0c, 0x80, 0x75, 0x0d, 0x11, 0xe4, 0xf5, 0x0e, 0x12, 0x56, 0xa7, 0xe0, 0xf5, 0x0f,
+ 0x81, 0xc3, 0x90, 0x03, 0x42, 0xe0, 0xf5, 0x29, 0xa3, 0xe0, 0xf5, 0x2a, 0x12, 0x56, 0xa7, 0xe0,
+ 0x55, 0x29, 0x45, 0x2a, 0xa1, 0x10, 0x90, 0x03, 0x40, 0xe0, 0x14, 0x60, 0x0b, 0x04, 0x70, 0x13,
+ 0x53, 0xb4, 0xef, 0xe5, 0xa0, 0xc4, 0x80, 0x07, 0x53, 0xb4, 0xdf, 0xe5, 0xa0, 0xc4, 0x13, 0x54,
+ 0x01, 0xf5, 0x0f, 0xe4, 0xf5, 0x0e, 0x75, 0x0c, 0x80, 0x75, 0x0d, 0x12, 0xfd, 0xfb, 0x12, 0x57,
+ 0x3d, 0xfe, 0x81, 0xcc, 0x90, 0x03, 0x40, 0xe0, 0xff, 0xc3, 0x94, 0x02, 0x40, 0x21, 0xef, 0xd3,
+ 0x94, 0x06, 0x50, 0x1b, 0x90, 0xe2, 0xa4, 0xe0, 0x54, 0x0c, 0xff, 0xbf, 0x0c, 0x05, 0x75, 0x26,
+ 0x08, 0x80, 0x0c, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0xf0, 0x74, 0x04, 0x12, 0x47, 0x30, 0xf0, 0x90,
+ 0x03, 0x40, 0xe0, 0x12, 0x0d, 0x2b, 0x2b, 0xf2, 0x00, 0x2c, 0x03, 0x01, 0x2c, 0x11, 0x02, 0x2c,
+ 0x22, 0x03, 0x2c, 0x37, 0x04, 0x2c, 0x45, 0x05, 0x2c, 0x51, 0x06, 0x2c, 0x64, 0x07, 0x00, 0x00,
+ 0x2c, 0x76, 0x43, 0xb4, 0x10, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x54, 0xf0, 0xff, 0xe5, 0xa0, 0x54,
+ 0xef, 0x80, 0x2f, 0x43, 0xb4, 0x20, 0xf1, 0xd6, 0x54, 0xe0, 0xff, 0xe5, 0xa0, 0x54, 0xdf, 0x80,
+ 0x21, 0x43, 0xb4, 0x01, 0xe5, 0xa0, 0x54, 0xfe, 0xff, 0x90, 0x03, 0x41, 0xe0, 0x4f, 0xf5, 0xa0,
+ 0x80, 0x54, 0x43, 0xb4, 0x04, 0x90, 0x03, 0x41, 0xe0, 0x25, 0xe0, 0x25, 0xe0, 0xff, 0xe5, 0xa0,
+ 0x54, 0xfb, 0x4f, 0xf5, 0xa0, 0x80, 0x3f, 0x43, 0xb2, 0x20, 0xf1, 0xd6, 0x54, 0xe0, 0xff, 0xe5,
+ 0x80, 0x54, 0xdf, 0x80, 0x1a, 0x43, 0xb2, 0x40, 0x12, 0x56, 0xc4, 0xe5, 0x80, 0x54, 0xbf, 0x80,
+ 0x0e, 0x43, 0xb2, 0x80, 0xf1, 0xd6, 0x33, 0x33, 0x54, 0x80, 0xff, 0xe5, 0x80, 0x54, 0x7f, 0x4f,
+ 0xf5, 0x80, 0x80, 0x12, 0x43, 0xb4, 0x40, 0x12, 0x56, 0xc4, 0xe5, 0xa0, 0x54, 0xbf, 0x4f, 0xf5,
+ 0xa0, 0xe4, 0x90, 0x04, 0xc4, 0xf0, 0xad, 0x26, 0x81, 0xfe, 0x12, 0x44, 0x71, 0xa1, 0x11, 0x90,
+ 0x03, 0x41, 0xe0, 0xf5, 0x27, 0x12, 0x44, 0x71, 0xe5, 0x27, 0x30, 0xe1, 0x0e, 0x53, 0xb4, 0xef,
+ 0x12, 0x0e, 0x8d, 0xe5, 0xa0, 0x20, 0xe4, 0x03, 0x43, 0x27, 0x20, 0xe4, 0x90, 0xe6, 0x74, 0xf0,
+ 0xa3, 0xf0, 0xa3, 0xf0, 0x90, 0xe6, 0x82, 0xe5, 0x27, 0xf0, 0xe4, 0xfd, 0xff, 0x51, 0xeb, 0xb1,
+ 0x38, 0x43, 0x87, 0x01, 0x00, 0x00, 0x00, 0x12, 0x42, 0x04, 0x12, 0x47, 0x1f, 0x75, 0x0c, 0xc0,
+ 0x75, 0x0d, 0x0a, 0x7d, 0x00, 0x7b, 0x00, 0x12, 0x57, 0x3d, 0x7e, 0x00, 0x7f, 0x08, 0x12, 0x0b,
+ 0x10, 0x01, 0x36, 0x90, 0x03, 0x41, 0xe0, 0x60, 0x10, 0x90, 0x03, 0x40, 0xe0, 0x90, 0x04, 0x31,
+ 0x60, 0x02, 0x80, 0x0e, 0x74, 0x0a, 0xf0, 0x80, 0x11, 0x90, 0x03, 0x40, 0xe0, 0x90, 0x04, 0x30,
+ 0x60, 0x05, 0x74, 0x14, 0xf0, 0x80, 0x03, 0x74, 0x16, 0xf0, 0x80, 0x15, 0x7d, 0x3b, 0xe4, 0x80,
+ 0x12, 0xe4, 0xfd, 0xff, 0x51, 0xeb, 0xc2, 0x22, 0x22, 0x90, 0x03, 0x41, 0xe0, 0x90, 0x00, 0xe6,
+ 0xf0, 0xe4, 0xfd, 0xff, 0x41, 0xeb, 0xe4, 0xff, 0xb1, 0x38, 0x90, 0x04, 0x6d, 0xe0, 0x90, 0xe2,
+ 0x66, 0xf0, 0x90, 0x04, 0x6c, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0xe4, 0xf1, 0x85, 0xef, 0x44, 0x80,
+ 0xf1, 0xce, 0x74, 0x01, 0xf0, 0xff, 0xa1, 0xf7, 0x53, 0xe8, 0xfc, 0x90, 0xe2, 0x75, 0xe0, 0x20,
+ 0xe4, 0xf9, 0x53, 0xe8, 0xfc, 0x90, 0xe2, 0x75, 0xe0, 0x20, 0xe4, 0xf9, 0x22, 0xe2, 0xff, 0x7b,
+ 0x01, 0x8f, 0x41, 0x8b, 0x42, 0x8a, 0x43, 0x89, 0x44, 0x12, 0x0e, 0xa1, 0xaa, 0x43, 0xa9, 0x44,
+ 0xae, 0x02, 0xee, 0xf5, 0x9a, 0xaf, 0x01, 0xef, 0xf5, 0x9b, 0xe5, 0x41, 0xd3, 0x94, 0x04, 0x50,
+ 0x21, 0xb1, 0x38, 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x56,
+ 0x45, 0xd1, 0xf3, 0x90, 0x04, 0x84, 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x01, 0xb1, 0xf7, 0x02,
+ 0x0e, 0xcf, 0xb1, 0x38, 0xe4, 0x90, 0xe2, 0x67, 0xf0, 0xe5, 0x41, 0x04, 0xc3, 0x13, 0x04, 0x90,
+ 0xe2, 0x66, 0xf0, 0x90, 0x04, 0x85, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x04, 0x86, 0x12, 0x56,
+ 0x55, 0x90, 0x04, 0x83, 0xe0, 0x90, 0xe2, 0x65, 0xf0, 0xb1, 0xed, 0x15, 0x41, 0x15, 0x41, 0xb1,
+ 0x38, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe6, 0x7b, 0x12, 0x56, 0x45, 0xe5,
+ 0x41, 0xd3, 0x94, 0x06, 0x50, 0x05, 0xd1, 0xf3, 0x75, 0x41, 0x06, 0xb1, 0xed, 0x74, 0xfa, 0x25,
+ 0x41, 0xf5, 0x41, 0x70, 0xda, 0x12, 0x0e, 0xcf, 0xd2, 0xe8, 0xd2, 0xe9, 0x22, 0x90, 0x04, 0x84,
+ 0xe0, 0x90, 0xe2, 0x64, 0xf0, 0x7f, 0x00, 0x15, 0x5d, 0xa8, 0x5d, 0xa6, 0x07, 0x00, 0x00, 0x00,
+ 0x00, 0xa8, 0x5d, 0xe6, 0x60, 0x04, 0xd2, 0xe8, 0xd2, 0xe9, 0x05, 0x5d, 0x22, 0xae, 0x07, 0xd1,
+ 0x83, 0x74, 0x04, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90,
+ 0x03, 0x50, 0xe0, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0x03, 0x53, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90,
+ 0x03, 0x52, 0xe0, 0x90, 0xe2, 0x6b, 0xf0, 0x74, 0x02, 0x12, 0x56, 0xd1, 0x04, 0xf0, 0x7f, 0x00,
+ 0xb1, 0xf7, 0xb1, 0x38, 0x90, 0x03, 0x55, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x54, 0xe0,
+ 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xee, 0xf0, 0xe4, 0xf1, 0x87, 0xf1, 0xfa, 0x74, 0x03, 0xf0, 0x0f,
+ 0x80, 0x95, 0xb1, 0x38, 0x90, 0x03, 0x51, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0x03, 0x50, 0xe0,
+ 0x90, 0xe2, 0x67, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0xa3, 0xf0, 0xf1, 0xfa, 0x74, 0x10, 0xf0, 0x7f,
+ 0x01, 0xa1, 0xf7, 0xb1, 0x38, 0x90, 0xe2, 0x66, 0x22, 0xd1, 0x83, 0x74, 0x05, 0xf0, 0xe4, 0xa3,
+ 0xf0, 0xa3, 0x74, 0x08, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0xe6, 0xb8, 0xe0, 0x90, 0xe2, 0x6b, 0xf0,
+ 0x90, 0xe6, 0xb9, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x90, 0xe2, 0x65, 0x74, 0x43, 0xf0, 0x90, 0xe2,
+ 0x64, 0x74, 0x0c, 0xf0, 0x7f, 0x00, 0xb1, 0xf7, 0xb1, 0x38, 0x90, 0xe6, 0xba, 0xe0, 0x90, 0xe2,
+ 0x67, 0xf0, 0x90, 0xe6, 0xbb, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0xbc, 0xe0, 0x90, 0xe2,
+ 0x69, 0xf0, 0x90, 0xe6, 0xbd, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0xbe, 0xe0, 0x90, 0xe2,
+ 0x6b, 0xf0, 0x90, 0xe6, 0xbf, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x12, 0x56, 0xcf, 0x74, 0x0c, 0xf0,
+ 0x0f, 0xa1, 0xf7, 0x90, 0x04, 0x83, 0xe0, 0x44, 0x80, 0x90, 0xe2, 0x65, 0xf0, 0x22, 0x74, 0xc5,
+ 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0, 0x22, 0x8f, 0x2b, 0x75, 0x2c, 0x01, 0x12,
+ 0x42, 0x2b, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0xf5, 0x2d, 0xe4, 0xf5, 0x2e, 0x12, 0x43, 0xa0,
+ 0xf0, 0x74, 0xc5, 0x25, 0x2c, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe4, 0xf0, 0x90, 0xe2,
+ 0x24, 0xf0, 0x00, 0x12, 0x42, 0x91, 0x12, 0x0e, 0x7c, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0x7f, 0x1e,
+ 0x12, 0x3d, 0xf5, 0x12, 0x41, 0xe3, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0x65, 0x2d, 0x60, 0x30,
+ 0xe5, 0x2b, 0x60, 0x16, 0x74, 0xc5, 0x25, 0x2c, 0xf1, 0x01, 0xfe, 0x45, 0x2d, 0xff, 0xe5, 0x2d,
+ 0xd3, 0x9e, 0x7d, 0x00, 0x40, 0x02, 0x7d, 0x01, 0xf1, 0x8e, 0xe5, 0x2c, 0x60, 0x07, 0x90, 0x00,
+ 0xb9, 0xe0, 0x20, 0xe0, 0x05, 0x90, 0x04, 0xb3, 0x80, 0x03, 0x90, 0x04, 0xb4, 0x74, 0x0a, 0xf0,
+ 0x22, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0xa3, 0xf0, 0x22, 0xb1, 0x38,
+ 0x74, 0x10, 0xf1, 0xf2, 0xef, 0xf0, 0xe4, 0x90, 0xe2, 0x69, 0xf0, 0x90, 0xe2, 0x68, 0xed, 0xf1,
+ 0xcb, 0x74, 0x09, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xe4, 0xfe, 0xed, 0x30, 0xe0, 0x05, 0x90, 0x04,
+ 0xbf, 0xe0, 0xfe, 0xed, 0x30, 0xe1, 0x06, 0x90, 0x04, 0xc0, 0xe0, 0x42, 0x06, 0xb1, 0x38, 0xed,
+ 0xf1, 0xf2, 0xee, 0xf1, 0xcb, 0xef, 0xf0, 0x7f, 0x01, 0xa1, 0xf7, 0xf0, 0x74, 0xc2, 0x90, 0xe2,
+ 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x33, 0x22, 0x7b, 0x01, 0x7a,
+ 0x03, 0x79, 0x52, 0x22, 0x7b, 0x01, 0x7f, 0x08, 0xa1, 0x51, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5,
+ 0x11, 0x22, 0x90, 0xe2, 0x67, 0xf0, 0x90, 0xe2, 0x66, 0x22, 0x74, 0x82, 0x90, 0xe2, 0x65, 0xf0,
+ 0x90, 0xe2, 0x64, 0x22, 0xae, 0x05, 0xe4, 0xfd, 0xef, 0x54, 0x0f, 0xff, 0xd3, 0x94, 0x0f, 0x50,
+ 0x05, 0x11, 0x3b, 0x4a, 0x70, 0x04, 0x7d, 0x15, 0x80, 0x1c, 0x11, 0x3b, 0xf5, 0x82, 0x8a, 0x83,
+ 0xe0, 0xfc, 0xee, 0x60, 0x05, 0xec, 0x44, 0x05, 0x80, 0x03, 0xec, 0x54, 0xfa, 0xfe, 0x11, 0x3b,
+ 0xf5, 0x82, 0x8a, 0x83, 0xee, 0xf0, 0x7f, 0x03, 0x02, 0x2a, 0xeb, 0xef, 0x25, 0xe0, 0x24, 0x65,
+ 0xf5, 0x82, 0xe4, 0x34, 0x11, 0xf5, 0x83, 0xe4, 0x93, 0xfa, 0x74, 0x01, 0x93, 0x22, 0x7f, 0x02,
+ 0xe4, 0xfe, 0xee, 0x11, 0xb0, 0xe0, 0xfd, 0x20, 0xe6, 0x42, 0x11, 0xa5, 0x11, 0x45, 0xf5, 0x82,
+ 0x8a, 0x83, 0xe4, 0xf0, 0x90, 0xe3, 0x04, 0xef, 0xf0, 0x00, 0x00, 0x00, 0x44, 0x80, 0xfc, 0x90,
+ 0xe3, 0x49, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x53, 0x05, 0x03, 0xee, 0x60, 0x03, 0xbe, 0x02, 0x15,
+ 0xed, 0x70, 0x07, 0x90, 0xe3, 0x49, 0xec, 0xf0, 0x7d, 0x03, 0xbd, 0x03, 0x08, 0x90, 0xe3, 0x49,
+ 0xec, 0xf0, 0x00, 0x00, 0x00, 0x11, 0xa5, 0x11, 0xb9, 0x74, 0x11, 0xf0, 0x0f, 0x0f, 0x0e, 0xee,
+ 0x64, 0x04, 0x70, 0xae, 0x22, 0xee, 0x25, 0xe0, 0x24, 0xe8, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0x22,
+ 0x25, 0xe0, 0x24, 0xf0, 0xf5, 0x82, 0xe4, 0x34, 0x0f, 0xf5, 0x83, 0xe4, 0x93, 0xfc, 0x74, 0x01,
+ 0x93, 0xf5, 0x82, 0x8c, 0x83, 0x22, 0x11, 0x4e, 0xe4, 0xff, 0x7e, 0x02, 0xef, 0xc3, 0x94, 0x04,
+ 0x50, 0x2c, 0xef, 0x11, 0xb0, 0xe0, 0x30, 0xe6, 0x20, 0xef, 0x11, 0xa6, 0xf5, 0x83, 0xd1, 0xb6,
+ 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0xe4, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04, 0xee, 0xf0, 0x00,
+ 0x00, 0x00, 0x8d, 0x82, 0x8c, 0x83, 0x74, 0x05, 0xf0, 0x0f, 0x0e, 0x0e, 0x80, 0xce, 0x22, 0xe5,
+ 0x14, 0xc3, 0x94, 0x04, 0x40, 0x03, 0x12, 0x50, 0xc5, 0x11, 0xc6, 0xe4, 0x90, 0xe3, 0x12, 0xf0,
+ 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x00, 0xa3, 0xf0, 0x7f, 0x03, 0x51, 0x3c, 0x74, 0x01, 0x93,
+ 0x70, 0x02, 0xe4, 0x93, 0x60, 0x07, 0x51, 0x3c, 0x11, 0xbb, 0xe4, 0xf0, 0x00, 0x0f, 0xbf, 0x10,
+ 0xea, 0x90, 0xe2, 0xeb, 0x74, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xe4, 0xf0, 0x7e, 0xe2, 0x7f, 0x86,
+ 0x7b, 0x1c, 0xfa, 0xfd, 0xf1, 0x37, 0x12, 0x57, 0x67, 0xf5, 0x14, 0x22, 0xc0, 0xe0, 0xc0, 0xf0,
+ 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0,
+ 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xf1, 0xf3, 0x90, 0x00, 0xab, 0xe4, 0xf0,
+ 0x78, 0xa3, 0xf2, 0x78, 0xa5, 0xf2, 0x78, 0x1a, 0x74, 0x40, 0xf2, 0x78, 0x48, 0x74, 0x86, 0xf2,
+ 0x00, 0xf2, 0x00, 0x78, 0x04, 0x74, 0x06, 0xf2, 0x7f, 0x02, 0xd1, 0xf2, 0x11, 0x4e, 0x11, 0xc8,
+ 0xe4, 0xff, 0x51, 0x3c, 0x74, 0x01, 0x93, 0x70, 0x02, 0xe4, 0x93, 0x60, 0x08, 0x51, 0x3c, 0x11,
+ 0xbb, 0xe0, 0x54, 0xfd, 0xf0, 0x0f, 0xbf, 0x10, 0xe9, 0x90, 0x00, 0xa9, 0xe4, 0xf0, 0xa3, 0x74,
+ 0x40, 0xf0, 0x78, 0x24, 0xe4, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x25, 0x74, 0x40, 0xf2, 0x90, 0x00,
+ 0x60, 0xe4, 0xf0, 0xa3, 0xf0, 0x90, 0x00, 0x68, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xee, 0x12, 0x4e,
+ 0xf8, 0x90, 0x00, 0x66, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x90, 0x00, 0x6e, 0xec, 0xf0, 0xa3, 0xed,
+ 0xf0, 0xaa, 0x06, 0xa9, 0x07, 0x7b, 0x01, 0xd1, 0xbd, 0xaa, 0x04, 0xa9, 0x05, 0x74, 0x07, 0xd1,
+ 0xbf, 0x30, 0x25, 0x0b, 0xc2, 0x26, 0x90, 0x04, 0x81, 0xe4, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90,
+ 0x00, 0xad, 0xe4, 0xf0, 0xc2, 0x27, 0xc2, 0x24, 0xc2, 0x25, 0xc2, 0x00, 0x90, 0x04, 0xb4, 0xf0,
+ 0x90, 0x04, 0xb3, 0xf0, 0xe5, 0x14, 0xc3, 0x94, 0x04, 0x40, 0x06, 0xe4, 0xfd, 0x7f, 0x04, 0xf1,
+ 0x0e, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xef, 0x75, 0xf0, 0x02,
+ 0x90, 0x11, 0x65, 0x02, 0x0d, 0x16, 0xef, 0x14, 0x60, 0x15, 0x14, 0x60, 0x1a, 0x24, 0x81, 0x60,
+ 0x12, 0x24, 0xfb, 0x60, 0x16, 0x24, 0x86, 0x70, 0x1c, 0x51, 0xa9, 0xe4, 0xf0, 0x80, 0x33, 0x78,
+ 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0xe2, 0x54, 0x01,
+ 0x51, 0xa9, 0xf0, 0x80, 0x1d, 0x53, 0x07, 0x0f, 0x51, 0x3c, 0xd1, 0xb6, 0x4c, 0x70, 0x03, 0x7f,
+ 0x15, 0x22, 0x51, 0x3c, 0xd1, 0xd2, 0xe0, 0x7f, 0x00, 0x30, 0xe1, 0x02, 0x7f, 0x01, 0x51, 0xa9,
+ 0xef, 0xf0, 0x51, 0xa9, 0xa3, 0xe4, 0xf0, 0x78, 0x8b, 0x74, 0x02, 0xf2, 0xe5, 0x17, 0x78, 0xb3,
+ 0xf2, 0xe5, 0x18, 0x78, 0xb4, 0xf2, 0x7f, 0x00, 0x22, 0x85, 0x18, 0x82, 0x85, 0x17, 0x83, 0x22,
+ 0x78, 0xb8, 0xe2, 0xf5, 0x41, 0x78, 0xb9, 0xe2, 0xf5, 0x42, 0x78, 0xba, 0xe2, 0xf5, 0x43, 0x78,
+ 0xbb, 0xe2, 0xf5, 0x44, 0x78, 0xbc, 0xe2, 0xf5, 0x45, 0xe5, 0x41, 0x54, 0x03, 0xff, 0xc2, 0x17,
+ 0xc2, 0x18, 0xe5, 0x41, 0x54, 0x60, 0x90, 0x00, 0xaf, 0xf0, 0xc2, 0x24, 0x64, 0x20, 0x60, 0x05,
+ 0xe0, 0x64, 0x40, 0x70, 0x75, 0x90, 0x00, 0xac, 0xe0, 0xfe, 0x30, 0xe7, 0x69, 0x54, 0x7c, 0xfe,
+ 0x13, 0x13, 0x54, 0x3f, 0x65, 0x45, 0x70, 0x5e, 0xef, 0x64, 0x01, 0x70, 0x59, 0xd2, 0x17, 0xe5,
+ 0x42, 0x24, 0x02, 0x60, 0x32, 0x14, 0x60, 0x02, 0xa1, 0xe5, 0xe5, 0x41, 0x64, 0x21, 0x60, 0x02,
+ 0xa1, 0xe5, 0xe5, 0x43, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0xbe, 0xe2, 0x60, 0x02, 0xa1, 0xe5, 0x53,
+ 0x91, 0xef, 0x75, 0xa1, 0x01, 0x90, 0x00, 0xab, 0xf0, 0x7e, 0x00, 0x7f, 0x7a, 0x7b, 0x1f, 0xfa,
+ 0xfd, 0xf1, 0x37, 0xc2, 0x00, 0xa1, 0xa0, 0xe5, 0x41, 0x64, 0xa1, 0x60, 0x02, 0xa1, 0xe5, 0xe5,
+ 0x43, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0xbe, 0xe2, 0x64, 0x01, 0x60, 0x02, 0xa1, 0xe5, 0x90, 0x00,
+ 0xac, 0xe0, 0x54, 0x03, 0x81, 0xeb, 0xd2, 0x18, 0xa1, 0xa0, 0x90, 0x00, 0xae, 0xe0, 0x64, 0x02,
+ 0x60, 0x02, 0x81, 0x3a, 0xe5, 0x42, 0xb4, 0x09, 0x05, 0x12, 0x47, 0xf0, 0x80, 0x14, 0xe5, 0x42,
+ 0x70, 0x10, 0xe5, 0x41, 0xb4, 0x82, 0x0b, 0xd2, 0x17, 0xaf, 0x45, 0x51, 0x46, 0xef, 0x60, 0x02,
+ 0xa1, 0xe5, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02, 0x81, 0x31, 0x90, 0x00, 0xac, 0xe0, 0x30, 0xe7,
+ 0x39, 0xe5, 0x42, 0x64, 0x06, 0x70, 0x2b, 0xe5, 0x44, 0x64, 0x02, 0x60, 0x06, 0xe5, 0x44, 0x64,
+ 0x07, 0x70, 0x1f, 0xd2, 0x24, 0x90, 0x00, 0x76, 0xf1, 0xe0, 0x30, 0x27, 0x06, 0xe5, 0x44, 0x64,
+ 0x02, 0x60, 0x08, 0x20, 0x27, 0x14, 0xe5, 0x44, 0xb4, 0x07, 0x0f, 0x90, 0x00, 0x74, 0xf1, 0xe0,
+ 0x80, 0x08, 0xe5, 0x42, 0xb4, 0x0b, 0x03, 0x12, 0x56, 0xd9, 0xe5, 0x42, 0x64, 0x03, 0x70, 0x32,
+ 0xe5, 0x41, 0xb4, 0x02, 0x15, 0xe5, 0x43, 0x70, 0x11, 0xe5, 0x45, 0x64, 0x02, 0x60, 0x05, 0xe5,
+ 0x45, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x45, 0xb1, 0xed, 0xe5, 0x41, 0x70, 0x14, 0xe5, 0x43,
+ 0xb4, 0x01, 0x08, 0x90, 0x00, 0xb0, 0x74, 0x03, 0xf0, 0x80, 0x07, 0xe5, 0x43, 0xb4, 0x02, 0x02,
+ 0xd2, 0x17, 0xe5, 0x42, 0x64, 0x01, 0x70, 0x29, 0xe5, 0x41, 0xb4, 0x02, 0x15, 0xe5, 0x43, 0x70,
+ 0x11, 0xe5, 0x45, 0x64, 0x02, 0x60, 0x05, 0xe5, 0x45, 0xb4, 0x86, 0x06, 0xd2, 0x17, 0xaf, 0x45,
+ 0xd1, 0x3f, 0xe5, 0x41, 0x70, 0x0b, 0xe5, 0x43, 0xb4, 0x01, 0x06, 0x90, 0x00, 0xb0, 0x74, 0x01,
+ 0xf0, 0x30, 0x17, 0x02, 0xa1, 0xa0, 0xd2, 0x18, 0xa1, 0xa0, 0x90, 0x00, 0xaf, 0xe0, 0x60, 0x02,
+ 0xa1, 0xe5, 0xd2, 0x17, 0xe5, 0x42, 0x12, 0x0d, 0x2b, 0x35, 0x13, 0x00, 0x35, 0x3e, 0x01, 0x35,
+ 0x75, 0x03, 0x34, 0x65, 0x06, 0x35, 0x0b, 0x08, 0x34, 0xfa, 0x09, 0x34, 0xe7, 0x0a, 0x34, 0xef,
+ 0x0b, 0x00, 0x00, 0x35, 0xe5, 0xe5, 0x44, 0x24, 0xfe, 0x60, 0x29, 0x14, 0x60, 0x3d, 0x24, 0xfd,
+ 0x60, 0x13, 0x14, 0x60, 0x2a, 0x24, 0x06, 0x60, 0x02, 0xa1, 0xe5, 0x78, 0x8b, 0x74, 0x12, 0xf2,
+ 0x90, 0x00, 0x62, 0x80, 0x08, 0x78, 0x8b, 0x74, 0x0a, 0xf2, 0x90, 0x00, 0x64, 0xe0, 0x78, 0xb3,
+ 0xf2, 0xa3, 0x80, 0x14, 0x90, 0x00, 0x6c, 0x12, 0x56, 0x7f, 0x90, 0x00, 0x6d, 0x80, 0x09, 0x90,
+ 0x00, 0x6e, 0x12, 0x56, 0x7f, 0x90, 0x00, 0x6f, 0xe0, 0xa1, 0x30, 0xe5, 0x43, 0xc3, 0x94, 0x08,
+ 0x50, 0x15, 0xe5, 0x43, 0x25, 0xe0, 0x24, 0x99, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0xff, 0x4e, 0x70, 0x06, 0xd2, 0x18, 0xc2, 0x17, 0xa1, 0xa0, 0x8e, 0x48, 0x8f,
+ 0x49, 0x8e, 0x4a, 0x8f, 0x4b, 0x85, 0x4b, 0x82, 0x85, 0x4a, 0x83, 0xe0, 0x78, 0x8b, 0xf2, 0xe5,
+ 0x48, 0x78, 0xb3, 0xf2, 0xef, 0x80, 0x49, 0x90, 0x00, 0x60, 0xe0, 0xd1, 0xdd, 0x80, 0x41, 0x12,
+ 0x56, 0xd9, 0x90, 0x00, 0x60, 0xe5, 0x43, 0xf0, 0xa1, 0xa0, 0xad, 0x43, 0x7f, 0x05, 0xf1, 0x0e,
+ 0x90, 0x00, 0x61, 0xe5, 0x43, 0xf0, 0x12, 0x47, 0xf0, 0xa1, 0xa0, 0x90, 0x00, 0x61, 0xe0, 0xd1,
+ 0xdd, 0x80, 0x1d, 0xe5, 0x41, 0x24, 0x7f, 0x60, 0x09, 0x14, 0x60, 0x19, 0x24, 0x02, 0x60, 0x02,
+ 0xa1, 0xe5, 0x90, 0x00, 0xb0, 0xe0, 0x51, 0xa9, 0xf0, 0xa3, 0xe4, 0xf0, 0x74, 0x02, 0xd1, 0xe6,
+ 0x78, 0xb4, 0xf2, 0x80, 0x6b, 0xaf, 0x45, 0x51, 0x46, 0xef, 0x60, 0x64, 0xa1, 0xe5, 0xe5, 0x41,
+ 0xb4, 0x02, 0x1f, 0xe5, 0x43, 0x70, 0x1b, 0xaf, 0x45, 0xd1, 0x3f, 0xef, 0x60, 0x02, 0xa1, 0xe5,
+ 0xe5, 0x45, 0x64, 0x02, 0x60, 0x0c, 0xe5, 0x45, 0x64, 0x86, 0x60, 0x06, 0xad, 0x45, 0x7f, 0x07,
+ 0xf1, 0x0e, 0xe5, 0x41, 0x70, 0x3a, 0xe5, 0x43, 0x64, 0x01, 0x70, 0x34, 0x90, 0x00, 0xb0, 0xe0,
+ 0x54, 0xfd, 0xf0, 0x80, 0x2b, 0xe5, 0x41, 0x24, 0xfe, 0x60, 0x1a, 0x24, 0x02, 0x70, 0x66, 0xe5,
+ 0x43, 0xb4, 0x01, 0x09, 0x90, 0x00, 0xb0, 0xe0, 0x44, 0x02, 0xf0, 0x80, 0x13, 0xe5, 0x43, 0x64,
+ 0x02, 0x60, 0x0d, 0x80, 0x50, 0xe5, 0x43, 0x70, 0x4c, 0xaf, 0x45, 0xb1, 0xed, 0xef, 0x70, 0x45,
+ 0x30, 0x18, 0x38, 0x30, 0x25, 0x11, 0xe4, 0x90, 0x04, 0x81, 0xf0, 0x90, 0x04, 0x7c, 0xf0, 0x90,
+ 0x00, 0xb1, 0xf0, 0xa3, 0xf0, 0xc2, 0x26, 0xf1, 0xd8, 0xe5, 0x41, 0x20, 0xe7, 0x18, 0x78, 0xbf,
+ 0xe2, 0x90, 0x00, 0xb1, 0xf0, 0x78, 0xbe, 0xe2, 0xa3, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x70, 0x02,
+ 0xa3, 0xe0, 0x60, 0x02, 0xd2, 0x26, 0xd2, 0x25, 0x12, 0x2e, 0x89, 0x30, 0x17, 0x0e, 0x78, 0xa0,
+ 0xe2, 0x44, 0x80, 0xf2, 0x22, 0x90, 0xe6, 0xa0, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0xef, 0x54, 0x0f,
+ 0xfe, 0xef, 0x14, 0x60, 0x1a, 0x14, 0x60, 0x1f, 0x24, 0x82, 0x60, 0x0b, 0x14, 0x60, 0x14, 0x24,
+ 0xfb, 0x60, 0x18, 0x24, 0x86, 0x70, 0x1b, 0x78, 0xa0, 0xe2, 0x44, 0x01, 0xf2, 0x80, 0x2d, 0x78,
+ 0xa1, 0x80, 0x0a, 0x78, 0xa2, 0x80, 0x06, 0x78, 0xa3, 0x80, 0x02, 0x78, 0xa5, 0x74, 0x01, 0xf2,
+ 0x80, 0x1a, 0x75, 0xf0, 0x02, 0xee, 0x51, 0x40, 0xd1, 0xb6, 0x4c, 0x70, 0x03, 0x7f, 0x15, 0x22,
+ 0x75, 0xf0, 0x02, 0xee, 0x51, 0x40, 0xd1, 0xd2, 0xe0, 0x44, 0x02, 0xf0, 0x7f, 0x00, 0x22, 0xad,
+ 0x07, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x60, 0x51, 0x24, 0xfe, 0x60, 0x18, 0x24, 0x81, 0x60, 0x0e,
+ 0x24, 0xfb, 0x60, 0x1f, 0x24, 0x85, 0x70, 0x26, 0xe4, 0x78, 0xa1, 0xf2, 0x80, 0x3b, 0xe4, 0x78,
+ 0xa2, 0xf2, 0x80, 0x35, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x2f, 0x78, 0xa3, 0xf2, 0x7f, 0x02, 0xd1,
+ 0xf2, 0x80, 0x26, 0x90, 0x00, 0xab, 0xe0, 0x70, 0x20, 0x78, 0xa5, 0xf2, 0x80, 0x1b, 0xec, 0x51,
+ 0x3d, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0x4e, 0x70, 0x03, 0x7f, 0x15, 0x22, 0x75, 0xf0, 0x02,
+ 0xec, 0x51, 0x40, 0xd1, 0xd2, 0xe0, 0x54, 0xfd, 0xf0, 0xed, 0x30, 0xe7, 0x03, 0x43, 0x04, 0x10,
+ 0xd1, 0xc5, 0xe0, 0x30, 0xe7, 0x0d, 0xed, 0x54, 0x0f, 0xfc, 0xed, 0x20, 0xe7, 0x03, 0x43, 0x04,
+ 0x10, 0xd1, 0xc5, 0x7f, 0x00, 0x22, 0xe4, 0x93, 0xfc, 0x74, 0x01, 0x93, 0x22, 0x74, 0x02, 0x90,
+ 0x00, 0x01, 0x02, 0x0b, 0x7c, 0x90, 0xe6, 0x83, 0xec, 0xf0, 0x44, 0x20, 0xf0, 0xec, 0xf0, 0x22,
+ 0xf5, 0x83, 0xe4, 0x93, 0xfe, 0x74, 0x01, 0x93, 0xf5, 0x82, 0x8e, 0x83, 0x22, 0x85, 0x18, 0x82,
+ 0x85, 0x17, 0x83, 0xf0, 0x74, 0x01, 0x78, 0x8b, 0xf2, 0xe5, 0x17, 0x78, 0xb3, 0xf2, 0xfe, 0xe5,
+ 0x18, 0x22, 0xef, 0x44, 0x80, 0xfe, 0xf1, 0x8c, 0x00, 0xef, 0xf0, 0x00, 0xe4, 0xf0, 0x00, 0x90,
+ 0xe6, 0x49, 0xee, 0xf0, 0x00, 0xf0, 0x30, 0x20, 0x04, 0x00, 0xf0, 0x00, 0xf0, 0x22, 0xae, 0x07,
+ 0x12, 0x2d, 0x38, 0xf1, 0xd8, 0x90, 0xe2, 0x66, 0xee, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0xed, 0xf0,
+ 0xe4, 0x12, 0x2f, 0x87, 0x12, 0x56, 0xcf, 0x74, 0x0b, 0xf0, 0x7f, 0x01, 0x02, 0x2d, 0xf7, 0x7e,
+ 0xf8, 0x7f, 0x00, 0x7a, 0x00, 0xe4, 0xfd, 0x8e, 0x4c, 0x8f, 0x4d, 0x8d, 0x4e, 0x8a, 0x4f, 0x8b,
+ 0x50, 0x12, 0x57, 0x34, 0xe5, 0x4c, 0xf5, 0x9a, 0xe5, 0x4d, 0xf5, 0x9b, 0xe5, 0x50, 0xae, 0x4f,
+ 0x78, 0x03, 0xce, 0xc3, 0x13, 0xce, 0x13, 0xd8, 0xf9, 0xff, 0xe5, 0x50, 0x54, 0x07, 0xfd, 0xef,
+ 0x1f, 0xaa, 0x06, 0x70, 0x01, 0x1e, 0x4a, 0x60, 0x0f, 0xac, 0x4e, 0x78, 0x7b, 0xec, 0xf2, 0xf2,
+ 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0x80, 0xe7, 0xaf, 0x05, 0x1d, 0xef, 0x60, 0x07, 0x78, 0x7b,
+ 0xe5, 0x4e, 0xf2, 0x80, 0xf3, 0x12, 0x0e, 0xcf, 0x85, 0x5a, 0xe8, 0x22, 0x90, 0xe6, 0x04, 0x74,
+ 0x80, 0xf0, 0x22, 0x8f, 0x2b, 0x90, 0x00, 0xe3, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xc8, 0xe0, 0xf4,
+ 0x55, 0x2b, 0x70, 0x03, 0x7f, 0x10, 0x22, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0xe5, 0x2b, 0x54, 0x1e,
+ 0x60, 0x0c, 0xf1, 0x8c, 0x12, 0x0e, 0x97, 0xaf, 0x2b, 0x12, 0x3d, 0xf5, 0xf1, 0xe9, 0x20, 0x20,
+ 0x04, 0x7f, 0x04, 0xd1, 0xf2, 0xf1, 0x8c, 0x00, 0x74, 0x06, 0xf0, 0x00, 0x74, 0x08, 0xf0, 0x00,
+ 0xe4, 0xf0, 0x12, 0x41, 0xe3, 0x7f, 0x00, 0x22, 0x90, 0x00, 0xfd, 0xe0, 0x44, 0x08, 0xf0, 0x22,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0x8e, 0x15, 0xf5, 0x16, 0x22, 0x7f, 0x02, 0xd1, 0xf2, 0xe4, 0x90, 0xe6,
+ 0x04, 0xf0, 0x22, 0x53, 0x91, 0xef, 0x75, 0xa1, 0x00, 0x22, 0xf1, 0xf3, 0x32, 0xef, 0x54, 0x0f,
+ 0xfe, 0xd3, 0x94, 0x0f, 0x50, 0x07, 0xee, 0x12, 0x30, 0x3c, 0x4a, 0x70, 0x26, 0xee, 0x64, 0x01,
+ 0x70, 0x1a, 0xbd, 0x02, 0x17, 0xbf, 0x01, 0x05, 0x90, 0xe6, 0xa1, 0x80, 0x08, 0xef, 0x64, 0x81,
+ 0x70, 0x28, 0x90, 0xe6, 0xa2, 0xe0, 0x54, 0x01, 0xf5, 0x0f, 0x80, 0x1e, 0x7d, 0x15, 0x7f, 0x03,
+ 0x02, 0x2a, 0xeb, 0xee, 0x25, 0xe0, 0x24, 0x65, 0xf5, 0x82, 0xe4, 0x34, 0x11, 0x12, 0x36, 0xd0,
+ 0xe0, 0x5d, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01, 0x8f, 0x0f, 0xbd, 0x02, 0x05, 0x75, 0x0d, 0x22,
+ 0x80, 0x03, 0x75, 0x0d, 0x26, 0x75, 0x0c, 0x83, 0xe4, 0xf5, 0x0e, 0xfd, 0xfb, 0xfe, 0x12, 0x28,
+ 0xc5, 0x02, 0x28, 0x36, 0xc2, 0x15, 0x12, 0x0f, 0xf8, 0xff, 0x12, 0x14, 0xb8, 0xf5, 0x34, 0x12,
+ 0x17, 0xd0, 0xa3, 0xe0, 0xf5, 0x35, 0x90, 0x00, 0xae, 0xe0, 0xb4, 0x02, 0x03, 0x7f, 0x18, 0x22,
+ 0xe5, 0x34, 0x24, 0xfe, 0x60, 0x14, 0x14, 0x60, 0x1e, 0x14, 0x60, 0x2f, 0x14, 0x60, 0x45, 0x24,
+ 0x04, 0x60, 0x02, 0x21, 0x20, 0x90, 0x00, 0x62, 0x80, 0x03, 0x90, 0x00, 0x64, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0x8e, 0x36, 0xf5, 0x37, 0x80, 0x7c, 0x90, 0x00, 0x70, 0x31, 0xa4, 0xd2, 0x15, 0x90, 0x00,
+ 0x68, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x6c, 0x80, 0x12, 0x90, 0x00, 0x72, 0x31, 0xa4,
+ 0xd2, 0x15, 0x90, 0x00, 0x66, 0xee, 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x6e, 0xee, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x80, 0x4f, 0x90, 0x00, 0x78, 0x31, 0xa4, 0x31, 0xd6, 0xf5, 0x82, 0x8c, 0x83, 0xe0,
+ 0xfd, 0xd3, 0x94, 0x08, 0x50, 0x14, 0xe5, 0x35, 0xfb, 0x7a, 0x00, 0xef, 0x2b, 0xff, 0xea, 0x3e,
+ 0xfe, 0xc3, 0xef, 0x94, 0x40, 0xee, 0x94, 0x03, 0x40, 0x03, 0x7f, 0x17, 0x22, 0x90, 0x00, 0x78,
+ 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0x75, 0xf0, 0x02, 0xed, 0x90, 0x00, 0x99, 0x12, 0x0d, 0x16, 0xee,
+ 0xf0, 0xa3, 0xef, 0xf0, 0x90, 0x00, 0x78, 0xe4, 0x85, 0x35, 0xf0, 0x12, 0x0b, 0xb0, 0x80, 0x03,
+ 0x7f, 0x17, 0x22, 0x90, 0x04, 0x88, 0xe0, 0x24, 0x04, 0xff, 0x12, 0x1d, 0x36, 0xa9, 0x07, 0x7b,
+ 0x01, 0x8b, 0x38, 0xf5, 0x39, 0x89, 0x3a, 0xfc, 0xad, 0x01, 0xe5, 0x35, 0xfb, 0x31, 0xb0, 0x30,
+ 0x15, 0x5f, 0xe5, 0x37, 0x24, 0x07, 0xf5, 0x82, 0xe4, 0x35, 0x36, 0xf5, 0x83, 0xe0, 0x30, 0xe6,
+ 0x08, 0x90, 0x00, 0xb0, 0x74, 0x01, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0x00, 0xb0, 0xf0, 0x90, 0x00,
+ 0xb9, 0xe0, 0x60, 0x3d, 0x31, 0xc4, 0x24, 0x17, 0xf0, 0x31, 0xc4, 0x04, 0xf0, 0xe5, 0x34, 0xb4,
+ 0x03, 0x0e, 0x90, 0x00, 0x71, 0xe0, 0x90, 0x00, 0x70, 0x31, 0xb9, 0x90, 0x00, 0x76, 0x80, 0x0c,
+ 0x90, 0x00, 0x73, 0xe0, 0x90, 0x00, 0x72, 0x31, 0xb9, 0x90, 0x00, 0x74, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xaa, 0x06, 0x75, 0x38, 0x01, 0x8a, 0x39, 0xf5, 0x3a, 0xac, 0x39, 0xad, 0x3a, 0x7b, 0x17, 0x31,
+ 0xb0, 0x7f, 0x00, 0x22, 0xe0, 0xfe, 0xa3, 0xe0, 0xff, 0xac, 0x06, 0x8c, 0x36, 0xf5, 0x37, 0x22,
+ 0x7a, 0x00, 0xaf, 0x37, 0xae, 0x36, 0x02, 0x19, 0x58, 0x25, 0x35, 0xff, 0xe0, 0x34, 0x00, 0xf5,
+ 0x36, 0x8f, 0x37, 0x22, 0x74, 0x02, 0x25, 0x37, 0xf5, 0x37, 0xe4, 0x35, 0x36, 0xf5, 0x36, 0x85,
+ 0x37, 0x82, 0xf5, 0x83, 0xe0, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfc, 0xa3, 0xe0, 0x22, 0x90, 0x00,
+ 0xae, 0xe0, 0xb4, 0x02, 0x03, 0x7f, 0x18, 0x22, 0xef, 0x24, 0xfe, 0x60, 0x13, 0x14, 0x60, 0x19,
+ 0x14, 0x60, 0x20, 0x24, 0x03, 0x70, 0x2f, 0x90, 0x00, 0x62, 0x51, 0x5b, 0x7e, 0x12, 0x80, 0x29,
+ 0x90, 0x00, 0x64, 0x51, 0x5b, 0x7e, 0x0a, 0x80, 0x20, 0x90, 0x00, 0x68, 0x51, 0x5b, 0x90, 0x00,
+ 0x68, 0x80, 0x08, 0x90, 0x00, 0x66, 0x51, 0x5b, 0x90, 0x00, 0x66, 0x51, 0x7e, 0x90, 0x00, 0x02,
+ 0x12, 0x0b, 0x4f, 0xfe, 0x80, 0x03, 0x7f, 0x17, 0x22, 0x51, 0x6d, 0xe4, 0xf0, 0xa3, 0xee, 0xf0,
+ 0x74, 0x03, 0x51, 0x74, 0x74, 0x24, 0x51, 0x6c, 0xe0, 0x90, 0x04, 0x85, 0x51, 0x6c, 0xa3, 0xe0,
+ 0x90, 0x04, 0x86, 0xf0, 0xee, 0x24, 0x02, 0xff, 0xe5, 0x35, 0x24, 0x02, 0xfd, 0xe4, 0x35, 0x34,
+ 0xfa, 0xa9, 0x05, 0x7b, 0x01, 0x12, 0x2d, 0x51, 0x7f, 0x00, 0x22, 0xe0, 0xfe, 0xa3, 0xe0, 0x24,
+ 0xfe, 0xf9, 0xee, 0x34, 0xff, 0xaf, 0x01, 0xf5, 0x34, 0x8f, 0x35, 0x22, 0xf0, 0x85, 0x35, 0x82,
+ 0x85, 0x34, 0x83, 0x22, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x84, 0x22, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xaa, 0x06, 0xf9, 0x7b, 0x01, 0x22, 0x8f, 0x2e, 0x12, 0x2e, 0xfe, 0x64, 0x01, 0x60, 0x0a, 0x90,
+ 0x00, 0xb7, 0x74, 0x11, 0xf0, 0xa3, 0x74, 0x3d, 0xf0, 0x90, 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0x24, 0x04, 0x30, 0x1e, 0x08, 0x12, 0x17, 0xa6, 0x74, 0x05, 0xf0, 0x80, 0x05, 0x12, 0x17, 0xa6,
+ 0xe4, 0xf0, 0x90, 0x00, 0xb6, 0xe0, 0x60, 0x45, 0x12, 0x0b, 0x36, 0xff, 0x90, 0x00, 0xb7, 0x71,
+ 0x05, 0xef, 0xf0, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0x8d, 0x82, 0x8c, 0x83, 0x71, 0xf4, 0xf1,
+ 0xcd, 0x90, 0x04, 0x83, 0x74, 0x43, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x10, 0xf0, 0xe5, 0x2e, 0xc4,
+ 0x54, 0xf0, 0x90, 0x04, 0x85, 0xf0, 0x74, 0xc5, 0x25, 0x2e, 0x12, 0x2f, 0x01, 0x90, 0x04, 0x86,
+ 0xf0, 0x90, 0x00, 0xb7, 0x51, 0x7c, 0x7f, 0x2a, 0x12, 0x2d, 0x51, 0x80, 0x02, 0x71, 0x0f, 0x7f,
+ 0x00, 0x22, 0x90, 0x04, 0x87, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xf5, 0x82, 0x8c, 0x83, 0x22, 0x90,
+ 0x00, 0xb7, 0xe0, 0xfe, 0xa3, 0xe0, 0x4e, 0x60, 0x39, 0x12, 0x47, 0x5a, 0xe4, 0xff, 0xef, 0x24,
+ 0x04, 0xfd, 0xe4, 0x33, 0xfc, 0x90, 0x00, 0xb7, 0xe0, 0xfa, 0xa3, 0xe0, 0x2d, 0xf5, 0x82, 0xea,
+ 0x3c, 0xf5, 0x83, 0xe0, 0xfe, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf8, 0xf5, 0x83, 0xee,
+ 0xf0, 0x0f, 0xbf, 0x24, 0xd9, 0x7f, 0x24, 0x7e, 0x00, 0x71, 0x53, 0xe4, 0x90, 0x00, 0xb7, 0xf0,
+ 0xa3, 0xf0, 0x22, 0xc2, 0x19, 0xc2, 0x1a, 0x90, 0x00, 0xad, 0xe0, 0x70, 0x02, 0x61, 0xeb, 0x90,
+ 0x04, 0xb8, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0xc3, 0x9f, 0xec, 0x9e, 0x50, 0x06, 0xae, 0x04, 0xaf,
+ 0x05, 0x80, 0x00, 0xee, 0x71, 0xec, 0x4e, 0x60, 0x72, 0x90, 0x00, 0xa9, 0xe0, 0xfe, 0xa3, 0xe0,
+ 0xff, 0x12, 0x47, 0x4d, 0x50, 0x0c, 0xd2, 0x19, 0x90, 0x04, 0xb8, 0xe0, 0xff, 0xa3, 0xe0, 0xcf,
+ 0x71, 0xec, 0x90, 0x04, 0xb1, 0xe0, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00, 0xa3, 0xe0, 0x78, 0x99,
+ 0xf2, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x04, 0xb1, 0xe0, 0xfe,
+ 0xa3, 0xe0, 0xfb, 0xaa, 0x06, 0xe4, 0xf9, 0xf8, 0xd0, 0x07, 0xd0, 0x06, 0x12, 0x0b, 0xd3, 0x90,
+ 0x04, 0xb6, 0x12, 0x0c, 0xd9, 0x90, 0x00, 0xaa, 0xe0, 0x24, 0xff, 0xff, 0x90, 0x00, 0xa9, 0xe0,
+ 0x34, 0xff, 0xfe, 0x90, 0x04, 0xb1, 0xe0, 0x5e, 0xfe, 0xa3, 0xe0, 0x5f, 0x4e, 0x60, 0x02, 0xd2,
+ 0x1a, 0x20, 0x19, 0x07, 0xa2, 0x1a, 0x92, 0x1b, 0x12, 0x17, 0x53, 0x22, 0x90, 0x04, 0xb1, 0xf0,
+ 0xa3, 0xef, 0xf0, 0x22, 0xa3, 0xf0, 0x90, 0x00, 0xfd, 0xe0, 0x44, 0x0c, 0xf0, 0x22, 0x8f, 0x2e,
+ 0x8d, 0x2f, 0x90, 0x00, 0xc7, 0xe0, 0xfd, 0xa3, 0xe0, 0x90, 0x00, 0xc7, 0xf0, 0x12, 0x4d, 0x72,
+ 0x90, 0x00, 0xc7, 0xed, 0xf0, 0xe5, 0x2e, 0x04, 0xfd, 0xe5, 0x2f, 0x20, 0xe0, 0x08, 0xe5, 0x5c,
+ 0x5d, 0x60, 0x03, 0x7f, 0x9b, 0x22, 0xef, 0x14, 0x70, 0x11, 0x91, 0x72, 0xaf, 0x2f, 0x12, 0x43,
+ 0xae, 0xb1, 0xb9, 0x90, 0x04, 0x37, 0xe0, 0xf5, 0x0e, 0x80, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00,
+ 0xb6, 0xe0, 0x60, 0x2b, 0x75, 0x0d, 0x11, 0x75, 0x0c, 0xc3, 0x74, 0xc5, 0x25, 0x2e, 0x12, 0x2f,
+ 0x01, 0xf5, 0x0f, 0xe5, 0x2e, 0xc4, 0x54, 0xf0, 0xf5, 0x0e, 0xe5, 0x2f, 0x54, 0x03, 0xf5, 0x11,
+ 0xe4, 0x90, 0x00, 0xb7, 0xf0, 0x71, 0xf4, 0xf1, 0xcd, 0x12, 0x28, 0xbf, 0x12, 0x28, 0x36, 0x7f,
+ 0x00, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x54, 0xdf, 0xf0, 0x22, 0x74, 0xff, 0x90, 0x04, 0x9f, 0xf0,
+ 0xa3, 0xf0, 0x12, 0x2e, 0xfe, 0x60, 0x03, 0xed, 0x60, 0x03, 0x7f, 0x0a, 0x22, 0x12, 0x42, 0x41,
+ 0xef, 0x60, 0x03, 0x7f, 0x08, 0x22, 0x12, 0x0c, 0x67, 0x8f, 0x2e, 0x8e, 0x2d, 0x8d, 0x2c, 0x8c,
+ 0x2b, 0xf1, 0xdf, 0x12, 0x4d, 0x08, 0x91, 0x72, 0x90, 0x04, 0x39, 0xe0, 0x70, 0x50, 0xaf, 0x2e,
+ 0xae, 0x2d, 0xad, 0x2c, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xad, 0xb1, 0xe1, 0xb1, 0xca, 0xfd, 0x90,
+ 0x04, 0x3b, 0x12, 0x0c, 0xad, 0x12, 0x26, 0x34, 0x12, 0x4d, 0x38, 0xfc, 0x78, 0x09, 0x12, 0x0c,
+ 0x54, 0xef, 0x24, 0xff, 0xf5, 0x36, 0xee, 0x34, 0xff, 0xf5, 0x35, 0xed, 0x34, 0xff, 0xf5, 0x34,
+ 0xec, 0x34, 0xff, 0xf5, 0x33, 0xb1, 0xb1, 0xfc, 0xb1, 0xa8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03,
+ 0x7f, 0x0c, 0x22, 0xb1, 0xb1, 0xac, 0x33, 0xb1, 0xd5, 0x40, 0x3e, 0x7f, 0x0c, 0x22, 0xb1, 0xa8,
+ 0xc0, 0x00, 0xb1, 0xc1, 0x12, 0x0c, 0x41, 0xd0, 0x00, 0xb1, 0xe1, 0xb1, 0xc1, 0x12, 0x0c, 0x41,
+ 0xa8, 0x04, 0xa9, 0x05, 0xaa, 0x06, 0xab, 0x07, 0xb1, 0xca, 0xfd, 0x12, 0x26, 0x34, 0x12, 0x0c,
+ 0xa1, 0xb1, 0xa8, 0xd3, 0x12, 0x0c, 0x30, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x12, 0x26, 0x5b, 0x12,
+ 0x0c, 0xa1, 0xb1, 0xd5, 0x40, 0x03, 0x7f, 0x0c, 0x22, 0x85, 0x2e, 0x1d, 0x85, 0x2d, 0x1c, 0x85,
+ 0x2c, 0x1b, 0x85, 0x2b, 0x1a, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x80, 0x12, 0x20, 0x5d, 0xef, 0x60,
+ 0x03, 0xaf, 0x19, 0x22, 0x85, 0x32, 0x1d, 0x85, 0x31, 0x1c, 0x85, 0x30, 0x1b, 0x85, 0x2f, 0x1a,
+ 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x84, 0x12, 0x20, 0x5d, 0xef, 0x60, 0x03, 0xaf, 0x19, 0x22, 0x12,
+ 0x1f, 0xf1, 0x7b, 0x01, 0x7d, 0x26, 0x7f, 0x98, 0x12, 0x20, 0x5d, 0xef, 0x60, 0x03, 0xaf, 0x19,
+ 0x22, 0xe4, 0xf5, 0x19, 0x12, 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0x12, 0x1f, 0xff, 0x90,
+ 0x04, 0x9f, 0x12, 0x4d, 0x01, 0xe5, 0x19, 0x60, 0x0a, 0x90, 0x04, 0x9f, 0xe0, 0x70, 0x02, 0xa3,
+ 0xe0, 0x70, 0xde, 0xb1, 0xb9, 0x7f, 0x00, 0x22, 0xab, 0x2e, 0xaa, 0x2d, 0xa9, 0x2c, 0xa8, 0x2b,
+ 0x22, 0xaf, 0x36, 0xae, 0x35, 0xad, 0x34, 0x22, 0xf0, 0x90, 0xe2, 0x1f, 0xe0, 0x44, 0x20, 0xf0,
+ 0x22, 0x90, 0x04, 0x3b, 0x12, 0x0c, 0xa1, 0x78, 0x09, 0x22, 0x90, 0x04, 0x2a, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0xff, 0xe4, 0xfc, 0x22, 0xab, 0x32, 0xaa, 0x31, 0xa9, 0x30, 0xa8, 0x2f, 0xd3, 0x02, 0x0c,
+ 0x30, 0x12, 0x0b, 0xe1, 0x8f, 0x2e, 0x8e, 0x2d, 0x8d, 0x2c, 0x8c, 0x2b, 0x8f, 0x32, 0x8e, 0x31,
+ 0x8d, 0x30, 0x8c, 0x2f, 0x22, 0x8f, 0x2f, 0x7f, 0x03, 0x7e, 0x01, 0xc2, 0xe9, 0x90, 0xe2, 0x75,
+ 0xe0, 0x20, 0xe4, 0xf9, 0x90, 0xe2, 0xa4, 0xe0, 0x5f, 0x6f, 0x60, 0x19, 0x90, 0xe2, 0xa6, 0xef,
+ 0xf0, 0xee, 0x12, 0x56, 0xbb, 0xb1, 0xb8, 0x12, 0x50, 0x90, 0xd1, 0x28, 0xf1, 0xee, 0xaf, 0x2f,
+ 0x12, 0x22, 0x91, 0xb1, 0xb9, 0xd2, 0xe9, 0x22, 0x90, 0xe6, 0x01, 0x74, 0xa3, 0xf0, 0x90, 0xe6,
+ 0x09, 0x74, 0xff, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x01, 0xf0, 0x12, 0x52, 0xb2, 0x81, 0x72,
+ 0x8f, 0x2b, 0x8d, 0x2c, 0x8b, 0x2d, 0x8a, 0x2e, 0x89, 0x2f, 0xe5, 0x2b, 0xc4, 0x54, 0x0f, 0xf5,
+ 0x32, 0xf1, 0xdf, 0xee, 0xf5, 0x33, 0xed, 0xf5, 0x34, 0x90, 0x00, 0x07, 0x12, 0x0b, 0x4f, 0x24,
+ 0xff, 0x92, 0x10, 0xe5, 0x30, 0x70, 0x27, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x03, 0x20, 0x1f,
+ 0x1d, 0xf1, 0xc2, 0x90, 0xe6, 0x04, 0x74, 0x04, 0xf0, 0x00, 0x00, 0x00, 0x90, 0xe6, 0x49, 0x74,
+ 0x84, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x7f, 0x01, 0x12, 0x54, 0x4f, 0xaf, 0x32,
+ 0x12, 0x42, 0x41, 0x8f, 0x31, 0xe5, 0x31, 0x60, 0x02, 0xe1, 0x22, 0xad, 0x2c, 0xaf, 0x2b, 0x12,
+ 0x55, 0xe2, 0x8f, 0x31, 0xe5, 0x31, 0x70, 0x7a, 0xd3, 0xe5, 0x34, 0x94, 0xff, 0xe5, 0x33, 0x94,
+ 0x0f, 0x40, 0x05, 0x75, 0x31, 0x3a, 0x80, 0x6a, 0xe5, 0x30, 0x60, 0x11, 0x90, 0x00, 0xdd, 0xe0,
+ 0x20, 0xe1, 0x03, 0x30, 0x1f, 0x07, 0xf1, 0xc2, 0xe4, 0xff, 0x12, 0x54, 0x4f, 0xe4, 0xfd, 0x7f,
+ 0x23, 0x12, 0x2f, 0xa8, 0xe5, 0x32, 0x64, 0x01, 0x70, 0x1b, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0,
+ 0x02, 0xd1, 0x28, 0x91, 0x72, 0xe5, 0x30, 0x60, 0x0c, 0xe4, 0xff, 0x12, 0x1e, 0xef, 0xf1, 0xb9,
+ 0x12, 0x24, 0x6b, 0x8f, 0x31, 0xe5, 0x30, 0x70, 0x29, 0xe5, 0x32, 0x64, 0x01, 0x70, 0x1d, 0x91,
+ 0x72, 0xf1, 0xb9, 0x12, 0x4a, 0x43, 0x8f, 0x31, 0x90, 0xe2, 0xa6, 0xe0, 0x44, 0x03, 0x12, 0x43,
+ 0x43, 0xe0, 0x54, 0xfc, 0xf0, 0x90, 0x00, 0xfb, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe6, 0x19, 0x74,
+ 0x20, 0xf0, 0xe5, 0x31, 0x60, 0x5b, 0xe5, 0x30, 0x60, 0x18, 0xe4, 0x90, 0xe6, 0x1b, 0xf0, 0x00,
+ 0x12, 0x25, 0xac, 0x00, 0x12, 0x27, 0xf3, 0x00, 0xf0, 0x00, 0x12, 0x56, 0x9a, 0x12, 0x42, 0x2b,
+ 0x80, 0x05, 0x7f, 0x04, 0x12, 0x36, 0xf2, 0x30, 0x22, 0x1b, 0x90, 0xe2, 0x40, 0x74, 0x04, 0xf0,
+ 0x90, 0xe2, 0xea, 0x74, 0x30, 0xf0, 0x12, 0x0e, 0x97, 0xe4, 0x90, 0xe2, 0x40, 0xf0, 0x90, 0xe2,
+ 0xea, 0xf0, 0x75, 0x31, 0x22, 0x90, 0x04, 0x83, 0x74, 0x02, 0xf0, 0x74, 0x14, 0xf1, 0xf6, 0xe5,
+ 0x30, 0xf0, 0x90, 0x04, 0x86, 0xe5, 0x31, 0xf0, 0x7a, 0x03, 0x79, 0x50, 0x12, 0x2f, 0xe4, 0x80,
+ 0x07, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x2a, 0xeb, 0xe5, 0x31, 0x70, 0x0d, 0xe5, 0x14, 0xc3, 0x94,
+ 0x04, 0x40, 0x1d, 0x90, 0x00, 0xb9, 0xe0, 0x60, 0x17, 0xe5, 0x30, 0x60, 0x0d, 0x20, 0x22, 0x0a,
+ 0x12, 0x42, 0x2b, 0x7f, 0x05, 0x7e, 0x00, 0x12, 0x50, 0x6e, 0x12, 0x0e, 0x7c, 0x12, 0x41, 0xe3,
+ 0xc2, 0x22, 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xa1, 0xb8, 0xab, 0x2d, 0xaa, 0x2e, 0xa9, 0x2f, 0xe4,
+ 0xff, 0x22, 0xe4, 0x90, 0xe2, 0x41, 0xf0, 0xa3, 0xe0, 0x54, 0xfe, 0xf0, 0x22, 0x30, 0x25, 0x08,
+ 0x30, 0x0b, 0xfa, 0x12, 0x11, 0xe9, 0x80, 0xf5, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31, 0x90,
+ 0x00, 0x05, 0x12, 0x0b, 0x4f, 0xfe, 0x90, 0x00, 0x06, 0x12, 0x0b, 0x4f, 0xfd, 0x22, 0xe4, 0x90,
+ 0xe6, 0x02, 0xf0, 0xa3, 0xf0, 0x22, 0x90, 0x04, 0x84, 0xf0, 0x90, 0x04, 0x85, 0x22, 0xe4, 0x78,
+ 0x8a, 0xf2, 0x78, 0xb5, 0xf2, 0x12, 0x18, 0x87, 0x75, 0x14, 0x01, 0x75, 0x17, 0x00, 0x75, 0x18,
+ 0xb3, 0xe5, 0x18, 0x30, 0xe0, 0x08, 0x05, 0x18, 0xe5, 0x18, 0x70, 0x02, 0x05, 0x17, 0x22, 0x71,
+ 0x3b, 0x78, 0x68, 0x74, 0x0b, 0xf2, 0x22, 0xe4, 0x90, 0x04, 0x93, 0xf0, 0xa3, 0xf0, 0x90, 0x04,
+ 0x87, 0xa3, 0xe0, 0x30, 0xe0, 0x0a, 0x90, 0x04, 0x87, 0x11, 0xe9, 0x90, 0x04, 0x8f, 0x11, 0xe9,
+ 0x12, 0x51, 0xaa, 0x11, 0x1f, 0x31, 0xad, 0xd2, 0xaf, 0xc2, 0xac, 0xd2, 0xa8, 0xd2, 0xaa, 0x90,
+ 0xe2, 0x7a, 0xe0, 0x54, 0xbf, 0xf0, 0x90, 0xe2, 0x7e, 0xe0, 0x44, 0x04, 0xf0, 0xf1, 0x1f, 0x7d,
+ 0x03, 0x7f, 0x40, 0x51, 0x98, 0x90, 0x00, 0xe5, 0xe0, 0xb4, 0x5a, 0x04, 0x51, 0x04, 0x80, 0x02,
+ 0xd1, 0x7a, 0x90, 0x00, 0xfd, 0xe0, 0x20, 0xe0, 0xf9, 0x30, 0x2e, 0x1b, 0x90, 0x04, 0x93, 0x11,
+ 0xe9, 0x90, 0x04, 0x93, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x0c, 0xf5, 0x29, 0xf5, 0x2a, 0xf5,
+ 0x2b, 0xfb, 0xfd, 0xff, 0x12, 0x51, 0x86, 0xc2, 0xaf, 0x30, 0x00, 0x0b, 0x90, 0x00, 0xfd, 0xe0,
+ 0x20, 0xe2, 0x04, 0xd2, 0xaf, 0x91, 0x91, 0xd2, 0xaf, 0x30, 0x08, 0x03, 0x12, 0x2a, 0xfe, 0x30,
+ 0x09, 0x08, 0x30, 0x2a, 0x03, 0x12, 0x1f, 0xb9, 0x51, 0xe4, 0x30, 0x0a, 0x09, 0x30, 0x2a, 0x03,
+ 0x12, 0x1f, 0xb9, 0x12, 0x28, 0xd2, 0x30, 0x0b, 0x09, 0x30, 0x2a, 0x03, 0x12, 0x1f, 0xb9, 0x12,
+ 0x11, 0xe9, 0x30, 0x05, 0x0d, 0x90, 0x00, 0xe8, 0xe0, 0x60, 0x05, 0x7f, 0x01, 0x12, 0x2f, 0x0a,
+ 0xc2, 0x05, 0x30, 0x07, 0x94, 0x31, 0xc2, 0x80, 0x90, 0xe4, 0x75, 0xf0, 0x01, 0x02, 0x0b, 0xb0,
+ 0xae, 0x07, 0xac, 0x03, 0x7b, 0xff, 0x74, 0xc5, 0x2e, 0x12, 0x2f, 0x01, 0x70, 0x01, 0xfb, 0xed,
+ 0x60, 0x02, 0x7b, 0x01, 0xaf, 0x06, 0xad, 0x04, 0x12, 0x55, 0xca, 0xef, 0x60, 0x02, 0x7b, 0x02,
+ 0xeb, 0xf4, 0x60, 0x05, 0xaf, 0x03, 0x02, 0x2e, 0x0d, 0x74, 0xc5, 0x2e, 0x12, 0x2f, 0x01, 0xfb,
+ 0x90, 0x04, 0x9f, 0xe4, 0xf0, 0xa3, 0xeb, 0xf0, 0xee, 0x70, 0x1b, 0x90, 0x00, 0xbb, 0x31, 0xa2,
+ 0xef, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa7, 0xcf, 0xf0, 0xa3, 0xef,
+ 0xf0, 0x90, 0x00, 0xbd, 0x80, 0x19, 0x90, 0x00, 0xc9, 0x31, 0xa2, 0xef, 0x12, 0x4e, 0x44, 0xe0,
+ 0xfb, 0xa3, 0xe0, 0x90, 0x04, 0xa7, 0xcb, 0xf0, 0xa3, 0xeb, 0xf0, 0xef, 0x12, 0x26, 0x5f, 0xe0,
+ 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa9, 0xcf, 0xf0, 0xa3, 0xef, 0xf0, 0xe4, 0x90, 0x04, 0xa3, 0x12,
+ 0x2f, 0x86, 0xa3, 0x11, 0xea, 0x90, 0x04, 0xa7, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x70, 0x05, 0x90,
+ 0x04, 0xa9, 0x11, 0xea, 0x90, 0x04, 0x83, 0x74, 0x02, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x13, 0xf0,
+ 0xf1, 0x39, 0x90, 0x04, 0x86, 0xec, 0xf0, 0x7b, 0x01, 0x7a, 0x04, 0x79, 0x9f, 0x7f, 0x0c, 0x02,
+ 0x2d, 0x51, 0xe0, 0xff, 0xa3, 0xe0, 0x90, 0x04, 0xa1, 0xcf, 0xf0, 0xa3, 0x22, 0x90, 0x04, 0xc0,
+ 0x74, 0x06, 0xf0, 0x90, 0x04, 0xbf, 0xe0, 0x70, 0x08, 0x90, 0xe2, 0xa6, 0x74, 0x0c, 0x71, 0x43,
+ 0xf0, 0x22, 0xc2, 0x22, 0xe4, 0xff, 0x51, 0x41, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x51, 0x91,
+ 0x71, 0x9d, 0xf0, 0x12, 0x17, 0xb6, 0x51, 0x2b, 0xf1, 0xd0, 0x7f, 0x1e, 0x12, 0x3d, 0xf5, 0xc2,
+ 0x07, 0xc2, 0x05, 0x90, 0x00, 0xe1, 0x74, 0x02, 0xf0, 0x7a, 0xf8, 0xf1, 0x11, 0x74, 0x26, 0xf0,
+ 0x90, 0x00, 0xdd, 0xe0, 0x44, 0x02, 0xf0, 0x90, 0xe2, 0x42, 0xe0, 0x54, 0xfe, 0xf0, 0xe4, 0x90,
+ 0xe2, 0x41, 0xf0, 0x22, 0xe4, 0x90, 0x00, 0xe5, 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x44, 0x03, 0xf0,
+ 0x90, 0xe2, 0xa4, 0x74, 0x01, 0xf0, 0x90, 0xe2, 0xa6, 0xe0, 0x54, 0xfc, 0xf0, 0x71, 0x96, 0x60,
+ 0x08, 0x12, 0x3e, 0x28, 0x12, 0x3f, 0xee, 0x51, 0x68, 0x80, 0xb8, 0x90, 0xe6, 0xa6, 0xe0, 0x30,
+ 0xe2, 0xf9, 0x90, 0xe2, 0xe7, 0xe0, 0x30, 0xe1, 0xf9, 0x90, 0xe2, 0xe7, 0xe0, 0x30, 0xe5, 0xf9,
+ 0x22, 0xe4, 0xfe, 0x90, 0x00, 0xfb, 0xe0, 0x60, 0x1c, 0x90, 0xe2, 0xa4, 0xe0, 0x54, 0x03, 0xff,
+ 0xbf, 0x03, 0x03, 0x7f, 0x08, 0x22, 0x90, 0xe2, 0xa6, 0x74, 0x03, 0xf0, 0x74, 0x01, 0xf1, 0x30,
+ 0xf0, 0x90, 0x00, 0xfb, 0xf0, 0xaf, 0x06, 0x22, 0xe4, 0x90, 0xe2, 0x24, 0xf0, 0x00, 0x51, 0x91,
+ 0x00, 0x12, 0x0e, 0x8d, 0x90, 0x04, 0x38, 0xe0, 0x90, 0xe2, 0x1f, 0xf0, 0x00, 0x90, 0xe2, 0x2e,
+ 0x74, 0x03, 0xf0, 0x00, 0x90, 0xe2, 0x19, 0x74, 0xa5, 0xf0, 0x00, 0x12, 0x0e, 0x8d, 0x02, 0x3c,
+ 0x72, 0x90, 0xe2, 0x21, 0x74, 0x20, 0xf0, 0x22, 0x8f, 0x2b, 0x8d, 0x0d, 0x85, 0x2b, 0x0c, 0x75,
+ 0x0f, 0x05, 0xe4, 0xf5, 0x0e, 0x85, 0x08, 0x11, 0xf5, 0x10, 0x85, 0x09, 0x13, 0x51, 0xd2, 0x12,
+ 0x28, 0x36, 0xe5, 0x2b, 0x44, 0x80, 0xf5, 0x0c, 0x85, 0x0b, 0x0f, 0x85, 0x0a, 0x0e, 0x90, 0x04,
+ 0xbf, 0xe0, 0xf5, 0x11, 0xa3, 0xe0, 0xf5, 0x10, 0xa3, 0xe0, 0xf5, 0x13, 0xe4, 0x51, 0xd2, 0x02,
+ 0x28, 0x36, 0xf5, 0x12, 0x78, 0x34, 0x7c, 0x00, 0xfd, 0xfb, 0x7a, 0x00, 0x79, 0x0c, 0xfe, 0x7f,
+ 0x08, 0x02, 0x0b, 0x10, 0xe4, 0xf5, 0x26, 0x90, 0x04, 0x7f, 0xf0, 0x53, 0x21, 0xfd, 0x90, 0x04,
+ 0x75, 0xe0, 0x70, 0x42, 0x90, 0x03, 0x49, 0xe0, 0x14, 0x60, 0x1e, 0x14, 0x60, 0x29, 0x24, 0x02,
+ 0x70, 0x2a, 0x90, 0xe6, 0x80, 0xe0, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x30, 0xe3, 0x02,
+ 0x71, 0x3b, 0x90, 0xe2, 0xa6, 0x74, 0x30, 0x80, 0x09, 0x7f, 0x1e, 0x71, 0x4d, 0x90, 0xe2, 0xa6,
+ 0x74, 0x03, 0x71, 0x43, 0xf0, 0x80, 0x08, 0x75, 0x26, 0x01, 0x80, 0x03, 0x75, 0x26, 0x26, 0xad,
+ 0x26, 0x7f, 0x01, 0x02, 0x2a, 0xeb, 0x7f, 0x01, 0x02, 0x2d, 0x18, 0x90, 0xe6, 0x80, 0xe0, 0x44,
+ 0x08, 0xf0, 0x22, 0xf0, 0xe4, 0x90, 0xe2, 0xa4, 0xf0, 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x00, 0xc8,
+ 0xe0, 0x5f, 0xff, 0x90, 0x00, 0xe3, 0xe0, 0x70, 0x03, 0x7f, 0x11, 0x22, 0xef, 0x54, 0x1e, 0x60,
+ 0x07, 0x71, 0x6f, 0x90, 0x00, 0xc8, 0xef, 0xf0, 0xe4, 0x90, 0x00, 0xe3, 0xf0, 0xff, 0x22, 0x71,
+ 0x96, 0xfe, 0x5f, 0xfd, 0x60, 0x0f, 0xff, 0xc2, 0x14, 0x71, 0xe5, 0xe4, 0xfb, 0xfd, 0xff, 0x12,
+ 0x1e, 0x6b, 0x71, 0x9d, 0xf0, 0x43, 0xb4, 0x41, 0xe4, 0x90, 0x00, 0xc6, 0xf0, 0x43, 0xa0, 0x40,
+ 0x90, 0x00, 0xc8, 0xe0, 0xff, 0x22, 0x90, 0x00, 0xc8, 0xe0, 0x54, 0x1e, 0x22, 0x12, 0x0e, 0x7c,
+ 0x90, 0x00, 0xc8, 0xe0, 0x54, 0xe1, 0xf0, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0xe1, 0x22, 0xe4, 0xf5,
+ 0x19, 0xef, 0x30, 0xe0, 0x1c, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x70, 0x25, 0x91, 0x6b, 0x70,
+ 0x21, 0x90, 0x00, 0xc7, 0xe0, 0xff, 0x71, 0x96, 0xfe, 0xef, 0x4e, 0x90, 0x00, 0xc7, 0xf0, 0x80,
+ 0x11, 0x90, 0x00, 0xc7, 0xe0, 0x54, 0x1e, 0x60, 0x04, 0xc2, 0x14, 0x71, 0xe5, 0x71, 0xa7, 0xf0,
+ 0x91, 0x88, 0xaf, 0x19, 0x22, 0xe4, 0xfc, 0x12, 0x1f, 0xf1, 0x30, 0x14, 0x04, 0xf1, 0x42, 0x7c,
+ 0x26, 0xad, 0x04, 0xe4, 0xfb, 0x7f, 0x1c, 0x12, 0x1e, 0x6b, 0xec, 0x60, 0x03, 0x12, 0x20, 0x07,
+ 0xaf, 0x19, 0x22, 0x8f, 0x2b, 0xe5, 0x5c, 0x55, 0x2b, 0x60, 0x03, 0x7f, 0x00, 0x22, 0xe5, 0x2b,
+ 0xf4, 0xff, 0x90, 0x00, 0xba, 0xe0, 0x5f, 0xf0, 0xed, 0x60, 0x35, 0xe0, 0x45, 0x2b, 0xf0, 0xe5,
+ 0x2b, 0x14, 0xff, 0x51, 0x41, 0x30, 0x27, 0x40, 0x20, 0x20, 0x3d, 0x90, 0x00, 0xb9, 0xe0, 0x60,
+ 0x37, 0x12, 0x37, 0x8c, 0x12, 0x0e, 0x97, 0xd2, 0x20, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x00, 0x90,
+ 0xe6, 0x12, 0x74, 0xa0, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x12, 0x37, 0xe9, 0x80, 0x18,
+ 0x74, 0xc5, 0x25, 0x2b, 0x12, 0x2f, 0x01, 0xff, 0x60, 0x0b, 0x90, 0x00, 0xc7, 0xe0, 0x5f, 0x70,
+ 0x04, 0x7f, 0x01, 0x71, 0xae, 0x12, 0x48, 0x17, 0x7f, 0x01, 0x22, 0xd2, 0x14, 0x71, 0xe5, 0xef,
+ 0x22, 0x71, 0x96, 0x60, 0x0c, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x3e, 0x28, 0x91,
+ 0x88, 0x90, 0x00, 0xe5, 0x74, 0x5a, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xe0, 0x90, 0x04, 0x38, 0xf0,
+ 0x22, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x10, 0x75, 0x5b, 0x02, 0xb1, 0x1c, 0x90, 0xe6, 0xa3, 0x74,
+ 0x01, 0xf0, 0x90, 0xe6, 0xa5, 0xf0, 0x22, 0x74, 0x00, 0xf5, 0x9a, 0x74, 0x7e, 0xf5, 0x9b, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xba, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbb, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbc, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xbd, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb9, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb8, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb7, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0x04, 0xb6, 0xf0, 0x90,
+ 0xe6, 0x7b, 0xe0, 0xb1, 0x93, 0x24, 0xff, 0x92, 0x10, 0xe0, 0x54, 0x0f, 0xff, 0xc2, 0x2f, 0xa2,
+ 0x10, 0x92, 0x11, 0x12, 0x14, 0xd0, 0x8f, 0x5b, 0x90, 0x00, 0xfd, 0xe0, 0x20, 0xe2, 0x05, 0x20,
+ 0x2f, 0x02, 0xb1, 0x15, 0x22, 0xc2, 0x00, 0xb1, 0x1c, 0xd2, 0x2f, 0x22, 0x90, 0x00, 0xad, 0xe0,
+ 0x60, 0x69, 0xf1, 0x5a, 0x7f, 0x02, 0x12, 0x36, 0xf2, 0x12, 0x0e, 0xb8, 0x7a, 0xf8, 0x79, 0x00,
+ 0x7e, 0xf8, 0xf1, 0x27, 0x78, 0x7c, 0x74, 0x55, 0xf2, 0x74, 0x53, 0xf2, 0x74, 0x42, 0xf2, 0x74,
+ 0x53, 0xf2, 0x90, 0x04, 0xba, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2, 0xa3, 0xe0, 0xf2,
+ 0x90, 0x04, 0xb9, 0xe0, 0xf2, 0x90, 0x04, 0xb8, 0xe0, 0xf2, 0x90, 0x04, 0xb7, 0xe0, 0xf2, 0x90,
+ 0x04, 0xb6, 0xe0, 0xf2, 0xe5, 0x5b, 0x7f, 0x00, 0x60, 0x02, 0x7f, 0x01, 0x78, 0x7c, 0xef, 0xf2,
+ 0x00, 0x00, 0x00, 0xe4, 0x78, 0x98, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x99, 0x74, 0x0d, 0xf2, 0x12,
+ 0x0e, 0xe6, 0x90, 0x00, 0xab, 0xe0, 0x60, 0x03, 0x12, 0x17, 0xe6, 0x22, 0x25, 0xe0, 0xff, 0x12,
+ 0x0b, 0x4f, 0xfe, 0xc4, 0x13, 0x13, 0x13, 0x54, 0x01, 0x22, 0x8b, 0x3b, 0x8a, 0x3c, 0x89, 0x3d,
+ 0xc0, 0x03, 0xc0, 0x02, 0xc0, 0x01, 0x12, 0x0c, 0x67, 0xf1, 0xde, 0x12, 0x0c, 0xad, 0x12, 0x0b,
+ 0xc6, 0xd0, 0x01, 0xd0, 0x02, 0xd0, 0x03, 0x12, 0x0c, 0x87, 0x90, 0x04, 0x39, 0xe0, 0xab, 0x3b,
+ 0xaa, 0x3c, 0xa9, 0x3d, 0x70, 0x20, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0x90, 0x00, 0x02, 0xb1,
+ 0x8c, 0x4f, 0xf5, 0x1a, 0xee, 0x90, 0x00, 0x03, 0xb1, 0x8c, 0x4f, 0xf5, 0x1b, 0xee, 0x25, 0xe0,
+ 0xf5, 0x1c, 0xe4, 0xf5, 0x1d, 0x22, 0x12, 0x0b, 0x36, 0xf5, 0x1a, 0x90, 0x00, 0x01, 0x12, 0x0b,
+ 0x4f, 0xf5, 0x1b, 0x90, 0x00, 0x02, 0x12, 0x0b, 0x4f, 0xf5, 0x1c, 0x90, 0x00, 0x03, 0x12, 0x0b,
+ 0x4f, 0xf5, 0x1d, 0x22, 0x30, 0x15, 0x07, 0xc2, 0x1b, 0x12, 0x17, 0x53, 0x80, 0x02, 0xd1, 0x1b,
+ 0x12, 0x14, 0xc2, 0xe5, 0x34, 0xf0, 0x75, 0x5b, 0x22, 0xa1, 0x15, 0xe4, 0xf5, 0x3b, 0xf5, 0x3c,
+ 0x78, 0x04, 0x74, 0x80, 0xf2, 0x12, 0x0e, 0x97, 0xe5, 0xaa, 0x20, 0xe0, 0x2e, 0x90, 0xe6, 0xa3,
+ 0xe0, 0xc4, 0x54, 0x07, 0xff, 0x60, 0x13, 0x7e, 0x00, 0x90, 0x00, 0xa9, 0xe0, 0xfc, 0xa3, 0xe0,
+ 0xfd, 0x12, 0x0b, 0x9e, 0x8e, 0x3b, 0x8f, 0x3c, 0x80, 0x11, 0x90, 0xe6, 0x90, 0xe0, 0xfe, 0xa3,
+ 0xe0, 0x7c, 0x00, 0x24, 0x00, 0xf5, 0x3c, 0xec, 0x3e, 0xf5, 0x3b, 0xae, 0x3b, 0xaf, 0x3c, 0xf1,
+ 0x4d, 0x40, 0x0d, 0x90, 0xe6, 0xa3, 0xe0, 0x44, 0x01, 0xf0, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22,
+ 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x7f, 0x02, 0x02, 0x36, 0xf2, 0xe4, 0x90, 0x00, 0xb6, 0xf0, 0x90,
+ 0x00, 0xc7, 0xf0, 0x90, 0x00, 0xb9, 0xf0, 0xa3, 0xf0, 0xf5, 0x5c, 0x90, 0x00, 0xdd, 0xf0, 0x90,
+ 0x00, 0xdc, 0xf0, 0x90, 0x00, 0xdb, 0xf0, 0x90, 0x00, 0xbb, 0x74, 0x08, 0xf0, 0xa3, 0xe4, 0xf0,
+ 0xa3, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xc9, 0x74, 0x02, 0xf0, 0xa3, 0xe4,
+ 0xf0, 0x12, 0x26, 0x5b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x00, 0xc8, 0xf0,
+ 0xf1, 0x09, 0x74, 0x38, 0xf0, 0xe4, 0xa3, 0xf0, 0xa3, 0x74, 0x02, 0xf0, 0xc2, 0x23, 0xe4, 0x90,
+ 0x00, 0xe6, 0xf0, 0xc2, 0x20, 0x90, 0x00, 0xc5, 0xf0, 0xa3, 0xf0, 0xc2, 0x21, 0x90, 0x00, 0xeb,
+ 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0xef, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0x90, 0x00, 0xe7, 0x74, 0x08, 0xf0, 0xa3, 0xf0, 0xa3, 0x74, 0x01, 0xf0, 0xa3, 0xf0, 0xe4,
+ 0xf5, 0xb2, 0x75, 0xb4, 0x40, 0x75, 0xa0, 0x40, 0x22, 0x90, 0x00, 0xe1, 0x74, 0x14, 0xf0, 0x7a,
+ 0xfc, 0x7b, 0x01, 0x79, 0x00, 0x90, 0x00, 0xde, 0x12, 0x0d, 0x22, 0x90, 0x00, 0xe2, 0x22, 0x90,
+ 0x00, 0xfd, 0xe0, 0x44, 0x01, 0xf0, 0x22, 0x74, 0xf8, 0xf5, 0x9d, 0x74, 0x00, 0xf5, 0x9e, 0x22,
+ 0x90, 0xe2, 0xa4, 0xf0, 0xe4, 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x03, 0x50, 0xe0, 0x90, 0x04, 0x85,
+ 0xf0, 0x22, 0x90, 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0xa3, 0xe0, 0xf5, 0x1b, 0x22, 0xe4, 0xfc, 0xfd,
+ 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xad, 0xd3, 0x02, 0x0c, 0x30, 0xe5, 0x14, 0xb4, 0x05, 0x08, 0x90,
+ 0xe6, 0xa5, 0xe0, 0x54, 0x09, 0x70, 0xf8, 0x22, 0x12, 0x4d, 0x72, 0x90, 0x04, 0x95, 0xef, 0xf0,
+ 0xbf, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x90, 0x00, 0x01, 0x12, 0x0b, 0x4f, 0xfe, 0x54, 0xc0, 0xff,
+ 0xbf, 0xc0, 0x03, 0x7f, 0x8f, 0x22, 0xee, 0x54, 0x3f, 0xff, 0x64, 0x3f, 0x60, 0x05, 0xef, 0x64,
+ 0x1c, 0x70, 0x30, 0xf1, 0x5a, 0x7b, 0x40, 0x12, 0x37, 0x2f, 0xf1, 0x27, 0x90, 0xe6, 0x7c, 0x74,
+ 0x03, 0xf0, 0xe4, 0xf0, 0x90, 0x04, 0x95, 0xe0, 0xb4, 0x01, 0x0c, 0xf1, 0xc9, 0x60, 0x08, 0x90,
+ 0xe6, 0x7c, 0x74, 0x80, 0xf0, 0x80, 0x05, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xe4, 0x90, 0xe6, 0x7c,
+ 0xf0, 0x80, 0x03, 0x7f, 0x85, 0x22, 0x7f, 0x00, 0x22, 0x90, 0x04, 0x32, 0xe0, 0x54, 0x03, 0x22,
+ 0x90, 0x00, 0xdd, 0xe0, 0x54, 0xfd, 0xf0, 0x90, 0xe2, 0x42, 0x74, 0x25, 0xf0, 0x22, 0x90, 0x00,
+ 0xdb, 0xe0, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xd3, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22,
+ 0x90, 0x00, 0xba, 0xe0, 0xf4, 0xff, 0x90, 0x00, 0xb9, 0xe0, 0xfe, 0x5f, 0xfd, 0x75, 0x14, 0x05,
+ 0xee, 0x60, 0x13, 0x90, 0x00, 0xad, 0x74, 0x01, 0xf0, 0xed, 0x60, 0x05, 0x7f, 0x0a, 0x12, 0x2f,
+ 0xa8, 0x20, 0x27, 0x02, 0x11, 0x17, 0x22, 0x30, 0x20, 0x2f, 0x12, 0x37, 0x8c, 0x7f, 0x02, 0x12,
+ 0x36, 0xf2, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0x90, 0xe6, 0x12, 0x74, 0xa2, 0xf0, 0x00, 0xe4, 0x90,
+ 0xe6, 0x18, 0xf0, 0x00, 0x90, 0xe6, 0x13, 0x74, 0x22, 0xf0, 0x00, 0x90, 0xe6, 0x19, 0x74, 0x20,
+ 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0xc2, 0x20, 0x22, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x12, 0x32, 0xb0, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0,
+ 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0,
+ 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0,
+ 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0xe5, 0x14, 0xd3, 0x94, 0x04,
+ 0x40, 0x02, 0x11, 0xb8, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x00, 0xd0,
+ 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe4, 0xfd, 0x7f, 0x02, 0x12, 0x37, 0x0e, 0x75,
+ 0x14, 0x04, 0x22, 0x8f, 0x3a, 0x74, 0xff, 0xf5, 0x3b, 0xf5, 0x3c, 0xe4, 0xf5, 0x3d, 0xe5, 0x3c,
+ 0x15, 0x3c, 0xae, 0x3b, 0x70, 0x02, 0x15, 0x3b, 0x4e, 0x60, 0x0d, 0x90, 0xe6, 0xa5, 0xe0, 0x55,
+ 0x3a, 0x60, 0x05, 0x12, 0x0e, 0x8d, 0x80, 0xe6, 0x90, 0xe6, 0xa5, 0xe0, 0x55, 0x3a, 0x60, 0x20,
+ 0x75, 0x3d, 0x99, 0xe4, 0x90, 0xe6, 0x1a, 0xf0, 0x00, 0x90, 0xe6, 0x48, 0x74, 0x86, 0xf0, 0x00,
+ 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0x31, 0x48, 0xe5, 0x14, 0xd3, 0x94, 0x04, 0x40, 0x02, 0x11, 0xb8,
+ 0xaf, 0x3d, 0x22, 0x91, 0xb5, 0x12, 0x47, 0x29, 0xe4, 0xf5, 0x39, 0x7f, 0x08, 0x11, 0xc3, 0xef,
+ 0x60, 0x03, 0x7f, 0x99, 0x22, 0x74, 0xf8, 0x91, 0xa4, 0xff, 0x91, 0xac, 0x0f, 0xbf, 0x40, 0xfa,
+ 0xe4, 0x90, 0xe6, 0x98, 0xf0, 0xa3, 0x74, 0x40, 0xf0, 0x05, 0x39, 0xe5, 0x39, 0xc3, 0x94, 0x08,
+ 0x40, 0xd9, 0x12, 0x25, 0xac, 0x7f, 0x00, 0x22, 0x90, 0xe6, 0x1a, 0x74, 0x40, 0xf0, 0x22, 0xb1,
+ 0x72, 0x8f, 0x33, 0xe5, 0x33, 0xb4, 0x02, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75, 0x34, 0x03, 0x12,
+ 0x46, 0x04, 0x7f, 0x84, 0x22, 0x20, 0x14, 0x10, 0x30, 0x1e, 0x0d, 0xa2, 0x14, 0x92, 0x15, 0x75,
+ 0x34, 0x0d, 0x12, 0x46, 0x04, 0x7f, 0x38, 0x22, 0xe5, 0x33, 0x64, 0x01, 0x70, 0x24, 0x90, 0x00,
+ 0xdd, 0xe0, 0x20, 0xe0, 0x03, 0x12, 0x3e, 0x28, 0x12, 0x3c, 0x72, 0x30, 0x14, 0x0e, 0x7f, 0x01,
+ 0x12, 0x1e, 0xef, 0x51, 0x3a, 0x12, 0x24, 0x6b, 0x8f, 0x32, 0x80, 0x06, 0x51, 0x3a, 0x51, 0x43,
+ 0x8f, 0x32, 0x31, 0x48, 0x20, 0x2a, 0x03, 0x12, 0x3d, 0xb9, 0x30, 0x14, 0x26, 0x90, 0x00, 0xef,
+ 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0x12, 0x3f, 0xd9, 0xed, 0xff,
+ 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00,
+ 0xef, 0x80, 0x24, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xad, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0,
+ 0x03, 0x12, 0x3f, 0xd9, 0xed, 0xff, 0xe4, 0xfc, 0xfd, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0,
+ 0x00, 0x12, 0x0b, 0xc6, 0x90, 0x00, 0xeb, 0x12, 0x0c, 0xd9, 0x30, 0x21, 0x21, 0x90, 0x00, 0xf3,
+ 0x12, 0x0c, 0xa1, 0x90, 0x00, 0xeb, 0x12, 0x17, 0x4c, 0x50, 0x0e, 0x90, 0x00, 0xf7, 0x12, 0x0c,
+ 0xa1, 0x90, 0x00, 0xef, 0x12, 0x17, 0x4c, 0x40, 0x05, 0xd2, 0x15, 0x12, 0x28, 0x5a, 0x30, 0x0a,
+ 0x0e, 0x90, 0x04, 0x76, 0xe0, 0xb4, 0x12, 0x07, 0x91, 0xec, 0xc2, 0x15, 0x12, 0x28, 0x5a, 0x30,
+ 0x23, 0x03, 0x12, 0x1f, 0x2c, 0xc2, 0x22, 0xaf, 0x32, 0x22, 0xab, 0x2f, 0xaa, 0x30, 0xa9, 0x31,
+ 0x7f, 0x01, 0x22, 0x91, 0xf5, 0x75, 0x39, 0x64, 0xe4, 0xf5, 0x3a, 0xf5, 0x19, 0xe5, 0x35, 0x60,
+ 0x02, 0xb1, 0x5a, 0x12, 0x47, 0xc9, 0x7f, 0x00, 0x70, 0x02, 0x7f, 0x01, 0xef, 0x70, 0x0b, 0x12,
+ 0x14, 0xc2, 0x74, 0x0d, 0xf0, 0x75, 0x19, 0x38, 0x61, 0xf8, 0x91, 0x1a, 0x91, 0xbe, 0xef, 0x60,
+ 0x05, 0x75, 0x19, 0x0c, 0x61, 0xf8, 0x91, 0x1a, 0x12, 0x3f, 0xdf, 0xb1, 0x08, 0x4e, 0x70, 0x02,
+ 0x61, 0xf8, 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0xe5, 0x35, 0x70, 0x02, 0x61, 0x53, 0x30, 0x27, 0x02,
+ 0x61, 0x53, 0x91, 0x1a, 0x12, 0x45, 0x9a, 0xe4, 0x78, 0x18, 0xf2, 0x78, 0x15, 0x74, 0x22, 0xf2,
+ 0xe4, 0x78, 0x1b, 0xf2, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x49, 0x74, 0x88, 0xf2, 0xf2, 0x12,
+ 0x27, 0xe1, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x64, 0x12, 0x1e, 0x6b, 0x80, 0x6e, 0x90, 0x04, 0x2a,
+ 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x69, 0xe5, 0x19, 0x70, 0x65, 0x12, 0x25, 0xac, 0x91, 0xb5,
+ 0x91, 0xa4, 0xfd, 0x90, 0xe6, 0xa3, 0xe0, 0x30, 0xe2, 0x03, 0x30, 0x22, 0xf6, 0x90, 0xe6, 0x91,
+ 0xe0, 0xc3, 0x94, 0x40, 0x50, 0x03, 0x30, 0x22, 0xf4, 0x20, 0x22, 0x1f, 0x7a, 0xf0, 0x79, 0x00,
+ 0x74, 0xf0, 0x12, 0x47, 0x29, 0x7f, 0x40, 0xae, 0x07, 0x1f, 0xee, 0x60, 0x04, 0x91, 0xac, 0x80,
+ 0xf6, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0x0d, 0xbd, 0x08, 0xc8, 0x90, 0xe6, 0x9c, 0x12, 0x23,
+ 0xd8, 0x8f, 0x3a, 0x12, 0x47, 0x42, 0xe4, 0xf5, 0x1c, 0xf5, 0x1d, 0xfb, 0x7d, 0x26, 0x7f, 0x34,
+ 0x12, 0x1e, 0x6b, 0x91, 0xfe, 0xe5, 0x3a, 0x60, 0x02, 0xf5, 0x19, 0x12, 0x20, 0x07, 0x80, 0x8d,
+ 0x12, 0x27, 0x86, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x78, 0x48, 0x74, 0x88, 0xf2, 0xf2, 0x12, 0x1f,
+ 0xb9, 0xe5, 0x19, 0x60, 0x02, 0x61, 0xe8, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00,
+ 0x00, 0x61, 0xe8, 0x90, 0x00, 0xe1, 0xb1, 0x29, 0x20, 0x2a, 0x2a, 0x91, 0x1a, 0x12, 0x45, 0x9a,
+ 0xe4, 0xfb, 0x7d, 0x26, 0xaf, 0x39, 0x12, 0x20, 0x5d, 0xef, 0x70, 0x29, 0x91, 0x21, 0x70, 0x0a,
+ 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0, 0x60, 0x1b, 0x12, 0x14, 0xc2, 0x74, 0x01, 0xf0,
+ 0x75, 0x19, 0x37, 0x80, 0x63, 0x12, 0x1f, 0xf1, 0x90, 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0xa3, 0x12,
+ 0x1f, 0xfb, 0xef, 0x70, 0x21, 0x90, 0x04, 0x2a, 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x7b, 0x00, 0x7a,
+ 0x02, 0xaf, 0x35, 0x91, 0x28, 0x12, 0x23, 0xde, 0xe5, 0x19, 0x70, 0x0a, 0x90, 0x04, 0xb6, 0x12,
+ 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x35, 0x60, 0x10, 0xe5, 0x19, 0x70, 0x0c, 0x90, 0x04,
+ 0x2a, 0xe0, 0x70, 0x04, 0xa3, 0xe0, 0x64, 0x80, 0x60, 0x1c, 0x12, 0x1f, 0xb9, 0xef, 0x70, 0x18,
+ 0x91, 0x21, 0x70, 0x0a, 0xa3, 0xe0, 0x70, 0x06, 0xa3, 0xe0, 0x54, 0xe0, 0x60, 0x0a, 0x12, 0x14,
+ 0xbf, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x2a, 0xe4, 0x90, 0xe6, 0x18, 0xf0, 0xa3, 0x74, 0x20,
+ 0xf0, 0xe5, 0x19, 0x60, 0x03, 0x75, 0x19, 0x37, 0xb1, 0x1e, 0xff, 0x60, 0x04, 0x90, 0xe2, 0x34,
+ 0xf0, 0xe5, 0x35, 0x60, 0x10, 0x20, 0x22, 0x0d, 0xb1, 0x13, 0x60, 0x03, 0x12, 0x46, 0x1b, 0x85,
+ 0x19, 0x5b, 0x12, 0x45, 0x15, 0xb1, 0x48, 0xaf, 0x19, 0x22, 0xab, 0x36, 0xaa, 0x37, 0xa9, 0x38,
+ 0x22, 0x90, 0xe2, 0x08, 0xe0, 0x54, 0x03, 0x22, 0x7e, 0x32, 0xef, 0x60, 0x31, 0x12, 0x37, 0x8c,
+ 0x30, 0x27, 0x02, 0x7e, 0x0a, 0xaf, 0x06, 0x1e, 0xef, 0x60, 0x08, 0x90, 0x00, 0x7a, 0xe0, 0xf5,
+ 0x3b, 0x80, 0xf2, 0xe5, 0xaa, 0x20, 0xe0, 0x09, 0x90, 0xe6, 0x49, 0x74, 0x02, 0xf0, 0x00, 0x80,
+ 0xf2, 0x90, 0xe6, 0x18, 0x74, 0x30, 0xf0, 0x00, 0xe4, 0x90, 0xe6, 0x04, 0xf0, 0x22, 0xd3, 0xed,
+ 0x94, 0x01, 0xec, 0x94, 0x00, 0x40, 0x1c, 0x90, 0xe6, 0xa4, 0xe0, 0x20, 0xe3, 0x04, 0x30, 0x22,
+ 0xf6, 0x22, 0x91, 0x9d, 0x12, 0x1e, 0xe2, 0x91, 0x9d, 0x12, 0x1e, 0xe2, 0x90, 0xe6, 0x19, 0x74,
+ 0x30, 0xf0, 0x22, 0x90, 0xe6, 0xa4, 0xe0, 0x30, 0xe2, 0x04, 0x30, 0x22, 0xf6, 0x22, 0x90, 0xe6,
+ 0x94, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed, 0xc3, 0x9b, 0xee, 0x9a, 0x40, 0xf1, 0x90, 0xe6, 0x49,
+ 0x74, 0x04, 0xf0, 0x22, 0xf5, 0x9a, 0x74, 0x00, 0xf5, 0x9b, 0xe4, 0x22, 0x90, 0xe6, 0x7c, 0xe0,
+ 0x90, 0xe6, 0x7b, 0xf0, 0x22, 0x7a, 0xfc, 0x79, 0x00, 0x7e, 0xfc, 0x74, 0xfc, 0x22, 0x12, 0x3f,
+ 0xdf, 0xed, 0xff, 0xe4, 0xfc, 0xfd, 0x12, 0x0c, 0xb9, 0x12, 0x0b, 0xc6, 0x90, 0x04, 0x2c, 0x12,
+ 0x0c, 0xd9, 0x12, 0x26, 0x5b, 0xb1, 0x38, 0xfc, 0x90, 0x04, 0x2c, 0x12, 0x47, 0x53, 0x40, 0x09,
+ 0x12, 0x14, 0xc2, 0x74, 0x08, 0xf0, 0x7f, 0x0c, 0x22, 0x7f, 0x00, 0x22, 0xe4, 0x90, 0x04, 0x80,
+ 0xf0, 0x53, 0x21, 0xfb, 0x22, 0x8f, 0x35, 0x8b, 0x36, 0x8a, 0x37, 0x89, 0x38, 0x22, 0x90, 0x04,
+ 0x2a, 0x74, 0xff, 0xf5, 0xf0, 0x02, 0x0b, 0xb0, 0x90, 0x04, 0x2a, 0xed, 0xff, 0xee, 0xf0, 0xa3,
+ 0xef, 0xf0, 0x22, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1, 0xec, 0x4d, 0x4e, 0x4f, 0x22, 0x90, 0xe2,
+ 0x31, 0x74, 0x08, 0xf0, 0x90, 0x00, 0xe8, 0xe0, 0x22, 0xe0, 0x54, 0x30, 0xff, 0x90, 0x04, 0x2a,
+ 0xe0, 0xfc, 0xa3, 0xe0, 0xfd, 0x02, 0x27, 0xe7, 0x12, 0x0c, 0xa1, 0xef, 0x24, 0x01, 0xff, 0xe4,
+ 0x3e, 0xfe, 0xe4, 0x3d, 0xfd, 0xe4, 0x3c, 0x22, 0xe4, 0x90, 0x00, 0xfc, 0xf0, 0xc2, 0xab, 0xc2,
+ 0x8e, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x30, 0xf5, 0x89, 0x22, 0x90, 0x00, 0xfc, 0x74, 0x04, 0xf0,
+ 0xe4, 0xf5, 0x8d, 0xf5, 0x8b, 0xe5, 0x89, 0x54, 0x0f, 0x44, 0x10, 0xf5, 0x89, 0xd2, 0x8e, 0xd2,
+ 0xab, 0x22, 0x90, 0x00, 0xc7, 0xe0, 0xfe, 0xa3, 0xe0, 0x5e, 0xbf, 0x01, 0x0e, 0x54, 0x1e, 0x60,
+ 0x0a, 0x90, 0x00, 0xba, 0xe0, 0x30, 0xe1, 0x03, 0x7f, 0x01, 0x22, 0x7f, 0x02, 0x22, 0x8d, 0x2e,
+ 0xe4, 0xfd, 0xb1, 0x72, 0xac, 0x07, 0xbc, 0x02, 0x03, 0x7f, 0x84, 0x22, 0x12, 0x47, 0x5a, 0x12,
+ 0x47, 0x27, 0xe5, 0x2e, 0xb4, 0x23, 0x0c, 0xe4, 0x90, 0xe6, 0x7c, 0xf0, 0xf0, 0xf0, 0x74, 0x08,
+ 0xf0, 0x7d, 0x02, 0xec, 0x70, 0x2a, 0x90, 0x00, 0xbd, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xbe, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbf, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00,
+ 0xc0, 0xd1, 0x13, 0x90, 0x00, 0xbb, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xbc, 0x80, 0x2b,
+ 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x12, 0x26, 0x5f, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0xd1, 0x36,
+ 0xe0, 0x90, 0xe6, 0x7c, 0xd1, 0x44, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xef, 0xd1, 0x28, 0xd1, 0x13,
+ 0x90, 0x00, 0xc9, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0x90, 0x00, 0xca, 0xe0, 0x90, 0xe6, 0x7c, 0xf0,
+ 0x7f, 0x00, 0x22, 0xe0, 0x90, 0xe6, 0x7c, 0xf0, 0xed, 0xf0, 0xe4, 0xf0, 0x22, 0xb1, 0x72, 0xbf,
+ 0x02, 0x03, 0x7f, 0x84, 0x22, 0x7f, 0x00, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xce, 0xf5, 0x82,
+ 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcc, 0xf5, 0x82, 0xe4, 0x34,
+ 0x00, 0xf5, 0x83, 0x22, 0xf0, 0x90, 0x00, 0xdb, 0xe0, 0xff, 0x25, 0xe0, 0x25, 0xe0, 0x24, 0xcd,
+ 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0x22, 0xac, 0x07, 0xb1, 0x72, 0xbf, 0x02, 0x03, 0x7f,
+ 0x84, 0x22, 0xec, 0x04, 0xff, 0xed, 0x60, 0x05, 0xef, 0x42, 0x5c, 0x80, 0x04, 0xef, 0xf4, 0x52,
+ 0x5c, 0x7f, 0x00, 0x22, 0xc0, 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0,
+ 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0xe6, 0x80,
+ 0xe0, 0x30, 0xe7, 0x23, 0x90, 0x00, 0x66, 0xe0, 0xff, 0xa3, 0xe0, 0xcf, 0xd1, 0xf8, 0x90, 0x00,
+ 0x68, 0x12, 0x18, 0x7b, 0xf0, 0x90, 0x00, 0xa9, 0x74, 0x02, 0xf0, 0xa3, 0xe4, 0xf0, 0x7d, 0x01,
+ 0x7f, 0x06, 0x12, 0x37, 0x0e, 0xd2, 0x27, 0x90, 0x00, 0x6c, 0x12, 0x3a, 0x7c, 0x12, 0x36, 0xbd,
+ 0x90, 0x00, 0x6e, 0xe0, 0xfe, 0xa3, 0xe0, 0xaa, 0x06, 0xf9, 0x90, 0x00, 0x01, 0x74, 0x07, 0x12,
+ 0x0b, 0x7c, 0x90, 0x00, 0xa9, 0xe0, 0x78, 0x24, 0xf2, 0xa3, 0xe0, 0x78, 0x25, 0xf2, 0x12, 0x37,
+ 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x03, 0xd0, 0x02, 0xd0, 0x01, 0xd0, 0x00, 0xd0,
+ 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x90, 0x00, 0x6c, 0xf0, 0xa3, 0xef, 0xf0, 0x22,
+ 0x12, 0x37, 0xf3, 0xd2, 0x28, 0x32, 0x12, 0x37, 0xf3, 0x32, 0xc0, 0xe0, 0xc0, 0xf0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01, 0xc0, 0x02, 0xc0, 0x03, 0xc0,
+ 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x78, 0x8b, 0xe2, 0xff, 0xc3, 0x90, 0x00, 0xb2, 0xe0,
+ 0x9f, 0xf0, 0x90, 0x00, 0xb1, 0xe0, 0x94, 0x00, 0xf0, 0xe0, 0x70, 0x02, 0xa3, 0xe0, 0x60, 0x05,
+ 0x12, 0x37, 0xd8, 0xd2, 0x26, 0x74, 0x43, 0x12, 0x3a, 0x74, 0x74, 0x0c, 0xf0, 0x90, 0x04, 0x85,
+ 0x74, 0x40, 0xf0, 0x78, 0x8b, 0xe2, 0x90, 0x04, 0x86, 0xf0, 0x7a, 0xe7, 0x79, 0x40, 0x12, 0x2d,
+ 0x4d, 0x12, 0x37, 0xf3, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02,
+ 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0,
+ 0xe0, 0xc0, 0xf0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x01,
+ 0xc0, 0x02, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc0, 0x06, 0xc0, 0x07, 0x90, 0x04, 0x83, 0x74,
+ 0x43, 0xf0, 0x74, 0x0c, 0x12, 0x3f, 0xf6, 0x74, 0x60, 0xf0, 0x78, 0x8d, 0xe2, 0x90, 0x04, 0x86,
+ 0xf0, 0x7a, 0xe7, 0x79, 0x80, 0x12, 0x2d, 0x4d, 0x12, 0x37, 0xd8, 0x78, 0x8d, 0xe4, 0xf2, 0x53,
+ 0x91, 0xef, 0xf5, 0xa1, 0xd0, 0x07, 0xd0, 0x06, 0xd0, 0x05, 0xd0, 0x04, 0xd0, 0x03, 0xd0, 0x02,
+ 0xd0, 0x01, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xf0, 0xd0, 0xe0, 0x32, 0xc0,
+ 0xe0, 0xc0, 0x83, 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x00, 0xc0, 0x06, 0xc0, 0x07,
+ 0xe4, 0x53, 0x91, 0xef, 0xf5, 0xa1, 0x20, 0x00, 0x65, 0x90, 0xe6, 0xa3, 0xe0, 0x20, 0xe2, 0x5e,
+ 0x90, 0xf0, 0x00, 0xe0, 0xb4, 0x55, 0x17, 0xa3, 0xe0, 0xb4, 0x53, 0x12, 0xa3, 0xe0, 0xb4, 0x42,
+ 0x0d, 0xa3, 0xe0, 0xb4, 0x43, 0x08, 0x90, 0xe6, 0x91, 0xe0, 0x64, 0x1f, 0x60, 0x15, 0x90, 0x00,
+ 0xab, 0x74, 0x01, 0xf0, 0x78, 0x49, 0x74, 0x82, 0xf2, 0x78, 0xa3, 0x74, 0x01, 0xf2, 0x78, 0xa5,
+ 0xf2, 0x80, 0x2b, 0x7f, 0x00, 0x74, 0x00, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0xf0, 0xf5, 0x83, 0xe0,
+ 0xfe, 0x74, 0x7a, 0x2f, 0xf5, 0x82, 0xe4, 0x34, 0x00, 0xf5, 0x83, 0xee, 0xf0, 0x0f, 0xbf, 0x1f,
+ 0xe4, 0x90, 0xf0, 0x00, 0xe4, 0xf0, 0x90, 0xe6, 0x49, 0x74, 0x82, 0xf0, 0xd2, 0x00, 0xd0, 0x07,
+ 0xd0, 0x06, 0xd0, 0x00, 0xd0, 0xd0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x32, 0x8e, 0x35,
+ 0x8f, 0x36, 0xe5, 0x36, 0x25, 0xe0, 0xf5, 0x36, 0xe5, 0x35, 0x33, 0xf5, 0x35, 0xe5, 0x36, 0x15,
+ 0x36, 0xae, 0x35, 0x70, 0x02, 0x15, 0x35, 0x4e, 0x60, 0x05, 0x12, 0x0e, 0x7c, 0x80, 0xee, 0x22,
+ 0xe4, 0x90, 0xe2, 0x34, 0xf0, 0x90, 0x04, 0xc4, 0xe0, 0x60, 0x29, 0x43, 0xb4, 0x40, 0x90, 0x00,
+ 0xe6, 0xe0, 0x60, 0x0e, 0x43, 0xa0, 0x40, 0x7f, 0x96, 0x7e, 0x00, 0x11, 0x6e, 0x53, 0xa0, 0xbf,
+ 0x80, 0x0c, 0x53, 0xa0, 0xbf, 0x7f, 0x96, 0x7e, 0x00, 0x11, 0x6e, 0x43, 0xa0, 0x40, 0x7f, 0x96,
+ 0x7e, 0x00, 0x11, 0x6e, 0x22, 0x78, 0x80, 0xe2, 0x44, 0x0a, 0xf2, 0x7f, 0x64, 0x7e, 0x00, 0x11,
+ 0x6e, 0x78, 0x5d, 0x74, 0xff, 0xf2, 0x90, 0xe3, 0x5f, 0xf0, 0x78, 0x5f, 0xf2, 0x53, 0x91, 0xef,
+ 0x22, 0x11, 0xc5, 0x78, 0x80, 0xe2, 0x44, 0x04, 0xf2, 0xe2, 0x54, 0xf7, 0xf2, 0x22, 0x7b, 0x09,
+ 0xef, 0x70, 0x02, 0xc3, 0x22, 0xbf, 0x01, 0x02, 0x7b, 0x0b, 0x90, 0x04, 0xb6, 0x12, 0x0c, 0xa1,
+ 0xa8, 0x03, 0x12, 0x0c, 0x41, 0x90, 0x00, 0x90, 0xe0, 0x6e, 0x70, 0x03, 0xa3, 0xe0, 0x6f, 0xc3,
+ 0x60, 0x01, 0xd3, 0x22, 0x7e, 0x01, 0xe4, 0x90, 0x00, 0xdb, 0xf0, 0xc2, 0x1e, 0x90, 0x00, 0xdc,
+ 0xe0, 0x60, 0x3c, 0xef, 0xd3, 0x94, 0x01, 0x40, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0xff,
+ 0x22, 0xef, 0x60, 0x10, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x17, 0x20, 0x1c, 0x02, 0x80, 0x12,
+ 0xd2, 0x1e, 0x80, 0x18, 0x90, 0x00, 0xb9, 0xe0, 0x30, 0xe0, 0x04, 0xe4, 0xfe, 0x80, 0x0d, 0x20,
+ 0x1c, 0x08, 0x90, 0x00, 0xdb, 0x74, 0x01, 0xf0, 0x80, 0x02, 0xd2, 0x1e, 0xaf, 0x06, 0x22, 0xef,
+ 0x60, 0x03, 0x7f, 0x01, 0x22, 0x90, 0x00, 0xb9, 0xe0, 0x7f, 0x01, 0x30, 0xe0, 0x02, 0x7f, 0x00,
+ 0x22, 0x8b, 0x54, 0x8a, 0x55, 0x89, 0x56, 0x12, 0x1d, 0x5b, 0x90, 0x04, 0x73, 0xe0, 0x8d, 0x82,
+ 0x75, 0x83, 0x00, 0x02, 0x0b, 0x7c, 0x12, 0x2e, 0x83, 0xef, 0xf0, 0xa3, 0xed, 0xf0, 0xa3, 0xeb,
+ 0xf0, 0xa3, 0xe5, 0x29, 0xf0, 0xa3, 0xe5, 0x2a, 0xf0, 0xa3, 0xe5, 0x2b, 0xf0, 0x74, 0xc0, 0x12,
+ 0x2f, 0xfc, 0x74, 0x7f, 0xf0, 0x7f, 0x01, 0x02, 0x2d, 0xf7, 0x75, 0x92, 0xe6, 0x90, 0xe6, 0x0d,
+ 0x74, 0x01, 0xf0, 0xa3, 0x74, 0x0a, 0xf0, 0x90, 0xe6, 0x00, 0x74, 0x14, 0xf0, 0xc2, 0x88, 0x43,
+ 0xb8, 0x04, 0xe4, 0xf5, 0x8e, 0x78, 0x82, 0x74, 0x05, 0xf2, 0x75, 0xaf, 0x07, 0x78, 0x04, 0x74,
+ 0x02, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x12, 0x74, 0xa2, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x18,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x04, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x13, 0x74, 0x22,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x19, 0x74, 0x20, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x06,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x14, 0x74, 0xe2, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1a, 0x74, 0x40,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x04, 0x74, 0x08, 0xf2, 0x00, 0x00, 0x00, 0x78, 0x15, 0x74, 0x62,
+ 0xf2, 0x00, 0x00, 0x00, 0x78, 0x1b, 0x74, 0x40, 0xf2, 0x00, 0x00, 0x00, 0xe4, 0x78, 0x04, 0xf2,
+ 0x00, 0x00, 0x00, 0x90, 0xe3, 0x04, 0xf0, 0x90, 0xe2, 0xa6, 0xf0, 0xa3, 0xf0, 0x00, 0x00, 0x00,
+ 0x78, 0x0b, 0x74, 0x03, 0xf2, 0x00, 0x00, 0x00, 0x90, 0xe2, 0x1f, 0x74, 0x20, 0xf0, 0x90, 0xe4,
+ 0xdf, 0xf0, 0x75, 0xe8, 0x03, 0xd2, 0xdd, 0xc2, 0x1c, 0xd2, 0x1d, 0x22, 0xc0, 0xe0, 0xc0, 0x83,
+ 0xc0, 0x82, 0x90, 0xe2, 0x43, 0x74, 0x01, 0xf0, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe1, 0x06, 0x90,
+ 0xe2, 0x41, 0x74, 0x01, 0xf0, 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xc0, 0xe0, 0xc0, 0x83,
+ 0xc0, 0x82, 0xc0, 0xd0, 0x75, 0xd0, 0x00, 0xc0, 0x07, 0xc2, 0x8b, 0x90, 0x00, 0xe8, 0xe0, 0xff,
+ 0x90, 0xe2, 0x31, 0xe0, 0x5f, 0x60, 0x05, 0x74, 0xff, 0xf0, 0xd2, 0x05, 0xd0, 0x07, 0xd0, 0xd0,
+ 0xd0, 0x82, 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0x74, 0x30, 0x51, 0xe2, 0x74, 0x03, 0x51, 0xd8, 0x74,
+ 0x78, 0xf0, 0x90, 0x04, 0x3f, 0xe0, 0x90, 0xe6, 0x0d, 0xf0, 0x12, 0x0e, 0x97, 0x90, 0x04, 0x36,
+ 0xe0, 0x90, 0xe6, 0x0e, 0xf0, 0x12, 0x0e, 0x97, 0x90, 0x04, 0x40, 0xe0, 0xf5, 0x8e, 0x22, 0x51,
+ 0xe0, 0x04, 0x51, 0xd8, 0x04, 0xf0, 0x80, 0xda, 0xf0, 0xa3, 0x14, 0xf0, 0x90, 0x04, 0x36, 0x22,
+ 0x74, 0x02, 0x90, 0x00, 0xe4, 0xf0, 0x90, 0x04, 0x3f, 0x22, 0x51, 0xe0, 0x14, 0xf0, 0xa3, 0x04,
+ 0xf0, 0x90, 0x04, 0x30, 0xe0, 0x90, 0x04, 0x36, 0xf0, 0x80, 0xb7, 0x90, 0x00, 0xe4, 0x74, 0x01,
+ 0xf0, 0x90, 0x04, 0x3f, 0xf0, 0xe4, 0xa3, 0xf0, 0x90, 0x04, 0x31, 0xe0, 0x90, 0x04, 0x36, 0xf0,
+ 0x80, 0xa0, 0xe4, 0x90, 0x04, 0x2a, 0xf0, 0xa3, 0xf0, 0x90, 0x04, 0x33, 0xf0, 0xa3, 0xf0, 0x12,
+ 0x26, 0x5b, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x90, 0x04, 0x32, 0xf0, 0x90, 0x04,
+ 0x39, 0xf0, 0xc2, 0x2b, 0x90, 0x04, 0x37, 0xf0, 0xc2, 0x2a, 0xa3, 0xf0, 0xc2, 0x29, 0xc2, 0x2a,
+ 0x90, 0x04, 0x3a, 0xf0, 0x90, 0x04, 0x41, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0xff, 0xff, 0x41, 0xa7,
+ 0x75, 0x31, 0x01, 0x12, 0x25, 0xac, 0x71, 0xbf, 0xf0, 0x71, 0xda, 0xa3, 0x74, 0x09, 0xf0, 0x90,
+ 0xfc, 0x00, 0x74, 0x55, 0xf0, 0xa3, 0x74, 0xaa, 0x12, 0x2f, 0x81, 0xa3, 0xf0, 0x90, 0xe6, 0x9c,
+ 0xf0, 0x74, 0x08, 0x71, 0xca, 0xb4, 0xaa, 0x0a, 0xa3, 0xe0, 0xb4, 0x55, 0x05, 0x75, 0x31, 0x02,
+ 0x80, 0x2a, 0x90, 0xe2, 0x1f, 0x74, 0x05, 0xf0, 0x12, 0x25, 0xac, 0x71, 0xbf, 0xf0, 0x90, 0xfc,
+ 0x00, 0x74, 0x5a, 0xf0, 0xe4, 0x12, 0x2f, 0x87, 0x90, 0xe6, 0x9c, 0xf0, 0x74, 0x04, 0x71, 0xca,
+ 0x64, 0xa5, 0x60, 0x08, 0x90, 0xe2, 0x1f, 0x74, 0x01, 0xf0, 0x80, 0x0c, 0x75, 0x1a, 0x03, 0x75,
+ 0x1b, 0xb7, 0x85, 0x31, 0x1c, 0x12, 0x20, 0x55, 0x90, 0xe2, 0x1e, 0x74, 0x14, 0xf0, 0x22, 0x90,
+ 0xe6, 0x15, 0x74, 0x22, 0xf0, 0xe4, 0x90, 0xe6, 0x1b, 0x22, 0xa3, 0xf0, 0xff, 0x12, 0x27, 0x96,
+ 0x90, 0xfc, 0x00, 0xe0, 0x22, 0xe4, 0xff, 0x12, 0x27, 0x84, 0x90, 0xe2, 0x1e, 0x74, 0x40, 0xf0,
+ 0x22, 0xe5, 0x19, 0x70, 0x12, 0x12, 0x1f, 0xf1, 0x75, 0x1c, 0x02, 0xe4, 0xfb, 0x7d, 0x26, 0x7f,
+ 0x40, 0x12, 0x20, 0x5d, 0x12, 0x27, 0xcb, 0x22, 0x12, 0x2e, 0xfe, 0x60, 0x03, 0xed, 0x60, 0x07,
+ 0x7d, 0x0a, 0x7f, 0x02, 0x02, 0x2a, 0xeb, 0xeb, 0x14, 0x60, 0x12, 0x14, 0x60, 0x17, 0x24, 0x02,
+ 0x70, 0x1c, 0x75, 0x2b, 0x04, 0x75, 0x2c, 0x45, 0x75, 0x2d, 0x05, 0x80, 0x11, 0x75, 0x2b, 0x04,
+ 0x75, 0x2c, 0x4a, 0x80, 0x06, 0x75, 0x2b, 0x04, 0x75, 0x2c, 0x5b, 0x75, 0x2d, 0x11, 0x90, 0x04,
+ 0x83, 0x74, 0x02, 0xf0, 0x90, 0x04, 0x84, 0x74, 0x15, 0xf0, 0xe4, 0x90, 0x04, 0x85, 0xf0, 0x90,
+ 0x04, 0x86, 0xe5, 0x2d, 0xf0, 0xaa, 0x2b, 0xa9, 0x2c, 0x7b, 0x01, 0xff, 0x02, 0x2d, 0x51, 0xad,
+ 0x07, 0x12, 0x47, 0x09, 0x74, 0x38, 0xf0, 0x12, 0x17, 0xb6, 0x90, 0x00, 0xdd, 0xe0, 0x54, 0xfd,
+ 0xf0, 0xed, 0x60, 0x09, 0xd2, 0x1f, 0x90, 0xe2, 0x42, 0x74, 0x29, 0xf0, 0x22, 0xc2, 0x1f, 0x90,
+ 0xe2, 0x42, 0x74, 0x11, 0xf0, 0x22, 0x7f, 0x01, 0x91, 0x4f, 0x90, 0x00, 0xdd, 0xe0, 0x20, 0xe0,
+ 0x03, 0x12, 0x3e, 0x28, 0x22, 0x90, 0x00, 0xdc, 0xe0, 0x70, 0x03, 0x7f, 0x0b, 0x22, 0x91, 0x76,
+ 0xe4, 0xff, 0x91, 0x97, 0x7f, 0x00, 0x22, 0x8f, 0x30, 0xe4, 0x90, 0xe6, 0x19, 0xf0, 0x00, 0x00,
+ 0x00, 0x90, 0xe6, 0x13, 0x74, 0x22, 0xf0, 0xe4, 0x90, 0xe6, 0x19, 0xf0, 0x90, 0xe6, 0x49, 0x74,
+ 0x84, 0xf0, 0xf0, 0x90, 0xe6, 0x04, 0x74, 0x04, 0xf0, 0x7e, 0xf4, 0x7f, 0x00, 0x7b, 0x00, 0x7a,
+ 0x02, 0x7d, 0xff, 0x12, 0x37, 0x37, 0xe5, 0x30, 0x60, 0x1e, 0x90, 0xf4, 0x00, 0x12, 0x0c, 0xe5,
+ 0x43, 0x59, 0x57, 0x42, 0x7e, 0xf4, 0x7f, 0x04, 0x7c, 0x00, 0x7d, 0xcb, 0xb1, 0xc3, 0x90, 0xf4,
+ 0x14, 0x12, 0x0c, 0xe5, 0x43, 0x59, 0x57, 0x42, 0x12, 0x3c, 0x72, 0x12, 0x1f, 0xf1, 0x7d, 0x01,
+ 0x7c, 0x00, 0x7f, 0x10, 0x12, 0x27, 0xe7, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0x60, 0x12, 0x20, 0x5d,
+ 0x90, 0xe6, 0x94, 0x12, 0x23, 0xd8, 0xef, 0x60, 0x03, 0x7f, 0x37, 0x22, 0x12, 0x1f, 0xf1, 0x90,
+ 0x04, 0x33, 0xe0, 0xf5, 0x1a, 0x90, 0x04, 0x34, 0x12, 0x1f, 0xfb, 0xd2, 0x07, 0x12, 0x3d, 0xb9,
+ 0x7f, 0x00, 0x22, 0x8f, 0x2b, 0x12, 0x0c, 0x67, 0x8f, 0x2f, 0x8e, 0x2e, 0x8d, 0x2d, 0x8c, 0x2c,
+ 0x90, 0x00, 0xdc, 0xe0, 0x60, 0x03, 0x7f, 0x4c, 0x22, 0x91, 0x76, 0xe5, 0x2b, 0x64, 0x01, 0x70,
+ 0x76, 0x90, 0x00, 0xcb, 0x12, 0x0c, 0xa1, 0x90, 0x04, 0x9f, 0x12, 0x0c, 0xd9, 0x90, 0x04, 0x9f,
+ 0x12, 0x0c, 0xa1, 0xab, 0x2f, 0xaa, 0x2e, 0xa9, 0x2d, 0xa8, 0x2c, 0xd3, 0x12, 0x0c, 0x30, 0x40,
+ 0x03, 0x7f, 0x0c, 0x22, 0x90, 0x00, 0xd3, 0x12, 0x0c, 0xe5, 0x00, 0x00, 0x00, 0x01, 0xe5, 0x2f,
+ 0x24, 0xff, 0xff, 0xe5, 0x2e, 0x34, 0xff, 0xfe, 0xe5, 0x2d, 0x34, 0xff, 0xfd, 0xe5, 0x2c, 0x34,
+ 0xff, 0x90, 0x00, 0xcb, 0xb1, 0xba, 0xff, 0xe4, 0x35, 0x2e, 0xfe, 0xe4, 0x35, 0x2d, 0xfd, 0xe4,
+ 0x35, 0x2c, 0x90, 0x00, 0xd7, 0xb1, 0xba, 0xfb, 0xe4, 0x35, 0x2e, 0xfa, 0xe4, 0x35, 0x2d, 0xf9,
+ 0xe4, 0x35, 0x2c, 0xf8, 0x90, 0x04, 0x9f, 0x12, 0x0c, 0xa1, 0x12, 0x0b, 0xd3, 0x90, 0x00, 0xcf,
+ 0x12, 0x0c, 0xd9, 0x7f, 0x01, 0x81, 0x97, 0x7f, 0x2b, 0x22, 0xfc, 0x12, 0x0c, 0xd9, 0xe5, 0x2f,
+ 0x24, 0x01, 0x22, 0x7b, 0x10, 0x7a, 0x00, 0x02, 0x19, 0x58, 0xed, 0xd3, 0x94, 0x01, 0x50, 0x0c,
+ 0xed, 0x60, 0x0c, 0xef, 0x60, 0x06, 0x90, 0x00, 0xdc, 0xe0, 0x70, 0x03, 0x7f, 0x01, 0x22, 0x7f,
+ 0x00, 0x22, 0xae, 0x07, 0xee, 0xc4, 0x54, 0x0f, 0xff, 0x74, 0x01, 0xa8, 0x07, 0x08, 0x80, 0x02,
+ 0xc3, 0x33, 0xd8, 0xfc, 0xfc, 0xe4, 0xfb, 0x12, 0x2e, 0xfe, 0x70, 0x04, 0x7b, 0x09, 0x80, 0x1b,
+ 0xee, 0x54, 0x0f, 0x60, 0x04, 0x7b, 0x0a, 0x80, 0x12, 0xb1, 0xca, 0xef, 0x60, 0x04, 0x7b, 0x0b,
+ 0x80, 0x09, 0x90, 0x00, 0xba, 0xe0, 0x5c, 0x60, 0x02, 0x7b, 0x13, 0xaf, 0x03, 0x22, 0xc0, 0xe0,
+ 0xc0, 0x83, 0xc0, 0x82, 0x30, 0x28, 0x0a, 0xc2, 0x28, 0x90, 0x00, 0xfc, 0x74, 0x04, 0xf0, 0x80,
+ 0x0d, 0x90, 0x00, 0xfc, 0xe0, 0x60, 0x07, 0x14, 0xf0, 0xe0, 0x70, 0x02, 0xd2, 0x22, 0xd0, 0x82,
+ 0xd0, 0x83, 0xd0, 0xe0, 0x32, 0xe0, 0x90, 0xe2, 0x66, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2,
+ 0x69, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x68, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2,
+ 0x6b, 0xf0, 0x90, 0xe6, 0x7b, 0xe0, 0x90, 0xe2, 0x6a, 0xf0, 0x22, 0x12, 0x0c, 0xa1, 0xef, 0x24,
+ 0xff, 0xff, 0xee, 0x34, 0xff, 0xfe, 0xed, 0x34, 0xff, 0xfd, 0xec, 0x34, 0xff, 0xfc, 0x22, 0xe0,
+ 0xfe, 0xa3, 0xe0, 0xac, 0x06, 0x8c, 0x46, 0xf5, 0x47, 0x85, 0x47, 0x82, 0x85, 0x46, 0x83, 0xa3,
+ 0xa3, 0xe0, 0x78, 0x8b, 0xf2, 0xee, 0x78, 0xb3, 0xf2, 0x22, 0x90, 0xe6, 0x15, 0x74, 0x62, 0xf0,
+ 0x90, 0xe6, 0x1b, 0x74, 0x40, 0xf0, 0x22, 0x90, 0x03, 0x40, 0xe0, 0xfe, 0xa3, 0xe0, 0xfd, 0xed,
+ 0x8e, 0x27, 0xf5, 0x28, 0x85, 0x28, 0x82, 0x85, 0x27, 0x83, 0x22, 0x90, 0xe2, 0xa4, 0xf0, 0xe4,
+ 0x90, 0xe2, 0xa6, 0x22, 0x90, 0x03, 0x41, 0xe0, 0xc4, 0x33, 0x33, 0x54, 0xc0, 0xff, 0x22, 0x74,
+ 0xc3, 0x90, 0xe2, 0x65, 0xf0, 0x90, 0xe2, 0x64, 0x22, 0x78, 0x83, 0x74, 0x02, 0xf2, 0x74, 0x22,
+ 0xf2, 0x74, 0x16, 0xf2, 0x74, 0x36, 0xf2, 0x22, 0x90, 0x04, 0x83, 0xf0, 0x90, 0x04, 0x84, 0x74,
+ 0x12, 0xf0, 0x22, 0x90, 0xe2, 0x1f, 0xf0, 0x02, 0x1e, 0xe2, 0x85, 0x2d, 0x82, 0x85, 0x2c, 0x83,
+ 0xe0, 0xf2, 0x05, 0x2d, 0x22, 0x8d, 0x82, 0x8c, 0x83, 0xa3, 0xa3, 0xa3, 0xe0, 0xfd, 0x22, 0x90,
+ 0x03, 0x51, 0xe0, 0xfb, 0xad, 0x28, 0xaf, 0x27, 0x22, 0xe4, 0xfb, 0x7d, 0x26, 0x7f, 0xdc, 0x22,
+ 0x90, 0xe2, 0x0b, 0xe0, 0x54, 0x78, 0x13, 0x13, 0x13, 0x22, 0x74, 0x74, 0x25, 0x51, 0xf5, 0x82,
+ 0xe4, 0x34, 0x04, 0x22, 0x85, 0xe8, 0x5a, 0xe4, 0xf5, 0xe8, 0x02, 0x0e, 0xa1, 0x78, 0x34, 0x7c,
+ 0x00, 0x7a, 0x00, 0x79, 0x0c, 0x22, 0x90, 0xe2, 0x33, 0xf0, 0x12, 0x1e, 0xe2, 0xe4, 0x22, 0xc2,
+ 0xe8, 0x90, 0xe6, 0xb5, 0x74, 0x01, 0xf0, 0x22, 0x90, 0xe2, 0x34, 0xf0, 0x02, 0x1e, 0xe2, 0x90,
+ 0x04, 0xb0, 0xe0, 0xfd, 0x7c, 0x00, 0x22, 0xe4, 0x78, 0x5c, 0xf2, 0x78, 0x5e, 0xf2, 0x22, 0x34,
+ 0x01, 0xfe, 0xf0, 0xa3, 0xef, 0xf0, 0x22, 0x00
+ }
+} ;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastoria.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,35 @@
+/* Cypress West Bridge API header file (cyastioch.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASTORIA_H_
+#define _INCLUDED_CYASTORIA_H_
+
+#if !defined(__doxygen__)
+
+#include "cyaserr.h"
+#include "cyasmisc.h"
+#include "cyasstorage.h"
+#include "cyasusb.h"
+#include "cyasch9.h"
+
+#endif
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastsdkversion.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,30 @@
+/* Cypress Astoria Sdk Version file (cyastsdkversion.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASTSDK_VERSION_H_
+#define _INCLUDED_CYASTSDK_VERSION_H_
+
+/* Astoria SDK version 1.2.1 */
+#define CYAS_MAJOR_VERSION (1)
+#define CYAS_MINOR_VERSION (2)
+#define CYAS_BUILD_NUMBER (197)
+
+#endif /*_INCLUDED_CYASTSDK_VERSION_H_*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyastypes.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,66 @@
+/* Cypress West Bridge API header file (cyastypes.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASTYPES_H_
+#define _INCLUDED_CYASTYPES_H_
+
+#include "cyashaldef.h"
+
+/* Types that are not available on specific platforms.
+ * These are used only in the reference HAL implementations and
+ * are not required for using the API.
+ */
+#ifdef __unix__
+typedef unsigned long DWORD;
+typedef void * LPVOID;
+#define WINAPI
+#define INFINITE (0xFFFFFFFF)
+#define PtrToUint(ptr) ((unsigned int)(ptr))
+#endif
+
+/* Basic types used by the entire API */
+
+/* Summary
+ This type represents an endpoint number
+*/
+typedef uint8_t CyAsEndPointNumber_t ;
+
+/* Summary
+ This type is used to return status information from an API call.
+*/
+typedef uint16_t CyAsReturnStatus_t ;
+
+/* Summary
+ This type represents a bus number
+*/
+typedef uint32_t CyAsBusNumber_t ;
+
+/* Summary
+ All APIs provided with this release are marked extern through this definition.
+ This definition can be changed to meet the scope changes required in the user
+ build environment.
+
+ For example, this can be changed to __declspec(exportdll) to enable exporting
+ the API from a DLL.
+ */
+#define EXTERN extern
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasusb.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1407 @@
+/* Cypress West Bridge API header file (cyasusb.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASUSB_H_
+#define _INCLUDED_CYASUSB_H_
+
+#include "cyasmisc.h"
+
+#include "cyas_cplus_start.h"
+
+/*@@Enumeration Model
+ Summary
+ The USB enumeration process is the process of communicating to the USB host information
+ about the capabilities of the connected device. This process is completed by servicing
+ requests for various types of descriptors. In the software APIs described below, this
+ process is controlled in one of two ways.
+
+ Description
+ There are advantages to either type of enumeration and this is why both models are supported.
+ P Port processor based enumeraton gives the P port processor maximum control and flexibility
+ for providing USB configuration information. However, this does require (near) real time data
+ responses from the P port processor during the enumeration process. West Bridge based enumeration
+ requires no real time information from the P port processor, ensuring the fastest possible
+ enumeration times.
+
+ * P Port Based Enumeration *
+ The first method for handling USB enumeration is for the processor client to handle all
+ endpoint zero requests for descriptors. This mode is configured by indicating to the API
+ that the processor wants to handle all endpoint zero requests. This is done by setting
+ bit 0 in the end_point_mask to a 1. The processor uses CyAsUsbReadDataAsync() to read
+ the request and CyAsUsbWriteDataAsync() to write the response.
+
+ * West Bridge Based Enumeration *
+ The second method for handling USB enumeration is the configuration information method.
+ Before enabling a connection from the West Bridge device to the USB connector, the P Port
+ processor sends information about the USB configuration to West Bridge through the configuration
+ APIs. This information is stored within the West Bridge device. When a USB cable is attached,
+ the West Bridge device then handles all descriptor requests based on the stored information.
+ Note that this method of enumeration only supports a single USB configuration.
+
+ In either model of enumeration, the processor client is responsible for ensuring that
+ the system meets USB Chapter 9 compliance requirements. This can be done by providing spec
+ compliant descriptors, and handling any setup packets that are sent to the client
+ appropriately.
+
+ Mass storage class compliance will be ensured by the West Bridge firmware when the mass
+ storage functionality is enabled.
+*/
+
+/*@@Endpoint Configuration
+ Summary
+ The West Bridge device has one 64-byte control endpoint, one 64-byte low bandwidth endpoint, four bulk
+ endpoints dedicated for mass storage usage, and up to ten bulk/interrupt/isochronous
+ endpoints that can be used for USB-to-Processor communication.
+
+ Description
+ The four storage endpoints (Endpoints 2, 4, 6 and 8) are reserved for accessing storage
+ devices attached to West Bridge and are not available for use by the processor. These are
+ used implicitly when using the storage API to read/write to the storage media.
+
+ Endpoint 0 is the standard USB control pipe used for all enumeration activity. Though
+ the endpoint buffer is not directly accessible from the processor, read/write activity
+ can be performed on this endpoint through the API layers. This endpoint is always
+ configured as a bi-directional control endpoint.
+
+ Endpoint 1 is a 64-byte endpoint that can be used for low bandwidth bulk/interrupt
+ activity. The physical buffer is not accessible from the processor, but can be read/written
+ through the API. As the data coming to this endpoint is being handled through the
+ software layers, there can be loss of data if a read call is not waiting when an OUT
+ packet arrives.
+
+ Endpoints 3, 5, 7, 9, 10, 11, 12, 13, 14 and 15 are ten configurable endpoints
+ mapped to parts of a total 4 KB FIFO buffer space on the West Bridge device. This 4 KB
+ physical buffer space is divided into up to four endpoints called PEP1, PEP2, PEP3 and PEP4
+ in this software document. There are multiple configurations in which this buffer space
+ can be used, and the size and number of buffers available to each physical endpoint
+ vary between these configurations. See the West Bridge PDD for details on the buffer
+ orientation corresponding to each configuration.
+
+ * Note *
+ PEPs 1, 2, 3 and 4 are called Physical EP 3, 5, 7 and 9 in the West Bridge PDD. The
+ sequential number scheme is used in the software to disambiguate these from the logical
+ endpoint numbers, and also for convenience of array indexing.
+*/
+
+#if !defined(__doxygen__)
+
+
+#endif
+
+/* Summary
+ This constants defines the maximum size of a USB descriptor when referenced via the
+ CyAsUsbSetDescriptor or CyAsUsbGetDescriptor functions.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+*/
+#define CY_AS_MAX_USB_DESCRIPTOR_SIZE (128)
+
+/*****************************************************************************
+ * West Bridge Types
+ ****************************************************************************/
+
+
+/* Summary
+ This data structure is the data passed via the evdata paramater on a usb event
+ callback for the inquiry request.
+
+ Description
+ When a SCSI inquiry request arrives via the USB connection and the P Port has asked
+ to receive inquiry requests, this request is forwarded to the client via the USB
+ callback. This callback is called twice, once before the inquiry data is forwarded
+ to the host (CyAsEventUsbInquiryBefore) and once after the inquiry has been sent to the
+ USB host (CyAsEventUsbInquiryAfter). The evdata parameter is a pointer to this data
+ structure.
+
+ *CyAsEventUsbInquiryBefore*
+ If the client just wishes to see the inquiry request and associated data, then a simple
+ return from the callback will forward the inquiry response to the USB host. If the
+ client wishes to change the data returned to the USB host, the updated parameter must
+ be set to CyTrue and the memory area address by the data parameter should be updated.
+ The data pointer can be changed to point to a new memory area and the length field
+ changed to change the amount of data returned from the inquiry request. Note that the
+ data area pointed to by the data parameter must remain valid and the contents must
+ remain consistent until after the CyAsEventUsbInquiryAfter event has occurred. THE LENGTH
+ MUST BE LESS THAN 192 BYTES OR THE CUSTOM INQUIRY RESPONSE WILL NOT BE RETURNED. If the
+ length is too long, the default inquiry response will be returned.
+
+ *CyAsEventUsbInquiryAfter*
+ If the client needs to free any data, this event signals that the data associated with
+ the inquiry is no longer needed.
+
+ See Also
+ * CyAsUsbEventCallback
+ * CyAsUsbRegisterCallback
+*/
+typedef struct CyAsUsbInquiryData
+{
+ CyAsBusNumber_t bus ; /* The bus for the event */
+ uint32_t device ; /* The device the event */
+ uint8_t evpd ; /* The EVPD bit from the SCSI INQUIRY request */
+ uint8_t codepage ; /* The codepage in the inquiry request */
+ CyBool updated ; /* This bool must be set to CyTrue indicate that the inquiry
+ data was changed */
+ uint16_t length ; /* The length of the data */
+ void *data ; /* The inquiry data */
+} CyAsUsbInquiryData ;
+
+
+/* Summary
+ This data structure is the data passed via the evdata parameter on a usb event
+ callback for the unknown mass storage request.
+
+ Description
+ When a SCSI request is made that the mass storage firmware in West Bridge does not
+ know how to process, this request is passed to the processor for handling via
+ the usb callback. This data structure is used to pass the request and the
+ associated response. The user may set the status to indicate the status of the
+ request. The status value is the bCSWStatus value from the USB mass storage
+ Command Status Wrapper (0 = command passed, 1 = command failed). If the status
+ is set to command failed (1), the sense information should be set as well. For
+ more information about sense information, see the USB mass storage specification
+ as well as the SCSI specifications for block devices. By default the status is
+ initialized to 1 (failure) with a sense information of 05h/20h/00h which
+ indicates INVALID COMMAND.
+*/
+typedef struct CyAsUsbUnknownCommandData
+{
+ CyAsBusNumber_t bus ; /* The bus for the event */
+ uint32_t device ; /* The device for the event */
+ uint16_t reqlen ; /* The length of the requst (should be 16 bytes) */
+ void *request ; /* The request */
+
+ uint8_t status ; /* The returned status value for the command */
+ uint8_t key ; /* If status is failed, the sense key */
+ uint8_t asc ; /* If status is failed, the additional sense code */
+ uint8_t ascq ; /* If status if failed, the additional sense code qualifier */
+} CyAsUsbUnknownCommandData ;
+
+
+/* Summary
+ This data structure is the data passed via the evdata paramater on a usb event
+ callback for the start/stop request.
+
+ Description
+ When a SCSI start stop request arrives via the USB connection and the P Port has asked
+
+ See Also
+ * CyAsUsbEventCallback
+ * CyAsUsbRegisterCallback
+*/
+typedef struct CyAsUsbStartStopData
+{
+ CyAsBusNumber_t bus ; /* The bus for the event */
+ uint32_t device ; /* The device for the event */
+ CyBool start ; /* CyTrue means start request, CyFalse means stop request */
+ CyBool loej ; /* CyTrue means LoEj bit set, otherwise false */
+} CyAsUsbStartStopData ;
+
+/* Summary
+ This data type is used to indicate which mass storage devices are enumerated.
+
+ Description
+
+ See Also
+ * CyAsUsbEnumControl
+ * CyAsUsbSetEnumConfig
+*/
+typedef enum CyAsUsbMassStorageEnum
+{
+ CyAsUsbNandEnum = 0x01,
+ CyAsUsbSDEnum = 0x02,
+ CyAsUsbMMCEnum = 0x04,
+ CyAsUsbCEATAEnum = 0x08
+} CyAsUsbMassStorageEnum ;
+
+/* Summary
+ This data type specifies the type of descriptor to transfer to the West Bridge device
+
+ Description
+ During enumeration, if West Bridge is handling enumeration, the West Bridge device needs to USB descriptors
+ to complete the enumeration. The function CyAsUsbSetDescriptor() is used to transfer the descriptors
+ to the West Bridge device. This type is an argument to that function and specifies which descriptor
+ is being transferred.
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * CyAsUsbGetDescriptor
+*/
+typedef enum CyAsUsbDescType
+{
+ CyAsUsbDescDevice = 1, /* A device descriptor - See USB 2.0 specification Chapter 9 */
+ CyAsUsbDescDeviceQual = 2, /* A device descriptor qualifier - See USB 2.0 specification Chapter 9 */
+ CyAsUsbDescFSConfiguration = 3, /* A configuration descriptor for FS operation - See USB 2.0 specification Chapter 9 */
+ CyAsUsbDescHSConfiguration = 4, /* A configuration descriptor for HS operation - See USB 2.0 specification Chapter 9 */
+ CyAsUsbDescString = 5
+} CyAsUsbDescType ;
+
+/* Summary
+ This type specifies the direction of an endpoint
+
+ Description
+ This type is used when configuring the endpoint hardware to specify the direction
+ of the endpoint.
+
+ See Also
+ * CyAsUsbEndPointConfig
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbGetEndPointConfig
+*/
+typedef enum CyAsUsbEndPointDir
+{
+ CyAsUsbIn = 0, /* The endpoint direction is IN (West Bridge -> USB Host) */
+ CyAsUsbOut = 1, /* The endpoint direction is OUT (USB Host -> West Bridge) */
+ CyAsUsbInOut = 2 /* The endpoint direction is IN/OUT (valid only for EP 0 & 1) */
+} CyAsUsbEndPointDir ;
+
+/* Summary
+ This type specifies the type of an endpoint
+
+ Description
+ This type is used when configuring the endpoint hardware to specify the type of
+ endpoint.
+
+ See Also
+ * CyAsUsbEndPointConfig
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbGetEndPointConfig
+*/
+typedef enum CyAsUsbEndPointType
+{
+ CyAsUsbControl,
+ CyAsUsbIso,
+ CyAsUsbBulk,
+ CyAsUsbInt
+} CyAsUsbEndPointType ;
+
+/* Summary
+ This type is a structure used to indicate the top level configuration of the USB stack
+
+ Description
+ In order to configure the USB stack, the CyAsUsbSetEnumConfig() function is called to indicate
+ how mass storage is to be handled, the specific number of interfaces to be supported if
+ West Bridge is handling enumeration, and the end points of specifi interest. This structure
+ contains this information.
+
+ See Also
+ * CyAsUsbSetConfig
+ * CyAsUsbGetConfig
+ * <LINK Enumeration Model>
+*/
+typedef struct CyAsUsbEnumControl
+{
+ CyBool devices_to_enumerate[CY_AS_MAX_BUSES][CY_AS_MAX_STORAGE_DEVICES];
+ /* Designate which devices on which buses to enumerate */
+ CyBool antioch_enumeration ; /* If true, West Bridge will control enumeration. If this is false the
+ P port controls enumeration. If the P Port is controlling
+ enumeration, traffic will be received via endpoint zero. */
+ uint8_t mass_storage_interface ; /* This is the interface # to use for the mass storage interface,
+ if mass storage is enumerated. If mass storage is not enumerated
+ this value should be zero. */
+ uint8_t mtp_interface ; /* This is the interface # to use for the MTP interface,
+ if MTP is enumerated. If MTP is not enumerated
+ this value should be zero. */
+ CyBool mass_storage_callbacks ; /* If true, Inquiry, START/STOP, and unknown mass storage
+ requests cause a callback to occur for handling by the
+ baseband processor. */
+} CyAsUsbEnumControl ;
+
+
+/* Summary
+ This structure is used to configure a single endpoint
+
+ Description
+ This data structure contains all of the information required to configure the West Bridge hardware
+ associated with a given endpoint.
+
+ See Also
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbGetEndPointConfig
+*/
+typedef struct CyAsUsbEndPointConfig
+{
+ CyBool enabled ; /* If true, this endpoint is enabled */
+ CyAsUsbEndPointDir dir ; /* The direction of this endpoint */
+ CyAsUsbEndPointType type ; /* The type of endpoint */
+ CyAsEndPointNumber_t physical ; /* The physical endpoint #, 1, 2, 3, 4 */
+ uint16_t size ; /* The size of the endpoint in bytes */
+} CyAsUsbEndPointConfig ;
+
+/* Summary
+ List of partition enumeration combinations that can be selected on a partitioned
+ storage device.
+
+ Description
+ West Bridge firmware supports creating upto two partitions on mass storage
+ devices connected to West Bridge. When there are two partitions on a device,
+ the user can choose which of these partitions should be made visible to a USB
+ host through the mass storage interface. This enumeration lists the various
+ enumeration selections that can be made.
+
+ See Also
+ * CyAsStorageCreatePPartition
+ * CyAsStorageRemovePPartition
+ * CyAsUsbSelectMSPartitions
+ */
+typedef enum CyAsUsbMSType_t {
+ CyAsUsbMSUnit0 = 0, /* Enumerate only partition 0 as CD (autorun) device */
+ CyAsUsbMSUnit1, /* Enumerate only partition 1 as MS device (default setting) */
+ CyAsUsbMSBoth /* Enumerate both units */
+} CyAsUsbMSType_t ;
+
+/* Summary
+ This type specifies the type of USB event that has occurred
+
+ Description
+ This type is used in the USB event callback function to indicate the type of USB event
+ that has occurred. The callback function includes both this reasons for the callback
+ and a data parameter associated with the reason. The data parameter is used in a reason
+ specific way and is documented below with each reason.
+
+ See Also
+ * CyAsUsbIoCallback
+*/
+typedef enum CyAsUsbEvent
+{
+ CyAsEventUsbSuspend, /* This event is sent when West Bridge is put into the suspend
+ state by the USB host. The data parameter is not used and
+ will be zero. */
+ CyAsEventUsbResume, /* This event is sent when West Bridge is taken out of the
+ suspend state by the USB host. The data parameter is not
+ used and will be zero. */
+ CyAsEventUsbReset, /* This event is sent when a USB reset request is received
+ by the West Bridge device. The data parameter is not used and
+ will be zero. */
+ CyAsEventUsbSetConfig, /* This event is sent when a USB set configuration request is made.
+ The data parameter is a pointer to a uint16_t that contains the
+ configuration number. The configuration number may be zero to
+ indicate an unconfigure operation. */
+ CyAsEventUsbSpeedChange, /* This event is sent when the USB connection changes speed. This is
+ generally a transition from full speed to high speed. The parameter
+ to this event is a pointer to uint16_t that gives the speed of the
+ USB connection. Zero indicates full speed, one indicates high speed */
+ CyAsEventUsbSetupPacket, /* This event is sent when a setup packet is received. The data parameter
+ is a pointer to the eight bytes of setup data. */
+ CyAsEventUsbStatusPacket, /* This event is sent when a status packet is received. The data
+ parameter is not used. */
+ CyAsEventUsbInquiryBefore, /* This event is sent when mass storage receives an inquiry
+ request and we have asked to see these requests. */
+ CyAsEventUsbInquiryAfter, /* This event is sent when mass storage has finished processing an
+ inquiry request and any data associated with the request is no longer
+ required. */
+ CyAsEventUsbStartStop, /* This event is sent when mass storage receives a start/stop request and
+ we have asked to see these requests */
+ CyAsEventUsbClearFeature, /* This event is sent when a Clear Feature request is received. The data
+ parameter is the endpoint number. */
+ CyAsEventUsbUnknownStorage, /* This event is sent when mass storage receives a request that is not known
+ and we have asked to see these requests */
+ CyAsEventUsbMSCProgress /* This event is sent when the read/write activity on the USB mass
+ storage has crossed a pre-set level */
+} CyAsUsbEvent;
+
+/* Summary
+ This type is the type of a callback function that is called when a USB event occurs
+
+ Description
+ At times West Bridge needs to inform the P port processor of events that have
+ occurred. These events are asynchronous to the thread of control on the P
+ port processor and as such are generally delivered via a callback function that
+ is called as part of an interrupt handler. This type defines the type of function
+ that must be provided as a callback function for USB events.
+
+ See Also
+ * CyAsUsbEvent
+*/
+typedef void (*CyAsUsbEventCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsUsbEvent ev, /* The event type being reported */
+ void * evdata /* The data assocaited with the event being reported */
+) ;
+
+
+/* Summary
+ This type is the callback function called after an asynchronous USB read/write operation
+
+ Description
+ This function type defines a callback function that is called at the completion of any
+ asynchronous read or write operation.
+
+ See Also
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+ * CY_AS_ERROR_CANCELED
+*/
+typedef void (*CyAsUsbIoCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsEndPointNumber_t ep, /* The endpoint that has completed an operation */
+ uint32_t count, /* THe amount of data transferred to/from USB */
+ void * buffer, /* The data buffer for the operation */
+ CyAsReturnStatus_t status /* The error status of the operation */
+) ;
+
+/* Summary
+ This type is the callback function called after asynchronous API functions have completed.
+
+ Description
+ When calling API functions from callback routines (interrupt handlers usually) the async version of
+ these functions must be used. This callback is called when an asynchronous API function has completed.
+*/
+typedef void (*CyAsUsbFunctionCallback)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsReturnStatus_t status, /* The error status of the operation */
+ uint32_t client /* A client supplied 32 bit tag */
+) ;
+
+
+/*****************************************************************************
+ * West Bridge Functions
+ ****************************************************************************/
+
+/* Summary
+ This function starts the USB stack
+
+ Description
+ This function initializes the West Bridge USB software stack if it has not yet been stared.
+ This initializes any required data structures and powers up any USB specific portions of
+ the West Bridge hardware. If the stack had already been started, the USB stack reference count
+ is incremented.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ This function cannot be called from any type of West Bridge callback.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_SUCCESS - the stack initialized and is ready for use
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+
+ See Also
+ * CyAsUsbStop
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbStart(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function stops the USB stack
+
+ Description
+ This function decrements the reference count for the USB stack and if this count
+ is zero, the USB stack is shut down. The shutdown frees all resources associated
+ with the USB stack.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ While all resources associated with the USB stack will be freed is a shutdown occurs,
+ resources associated with underlying layers of the software will not be freed if they
+ are shared by the storage stack and the storage stack is active. Specifically the DMA manager,
+ the interrupt manager, and the West Bridge communications module are all shared by both the
+ USB stack and the storage stack.
+
+ Returns
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+
+ See Also
+ * CyAsUsbStart
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbStop(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function registers a callback function to be called when an asynchronous USB event occurs
+
+ Description
+ When asynchronous USB events occur, a callback function can be called to alert the calling program. This
+ functions allows the calling program to register a callback.
+
+ * Valid In Asynchronous Callback: YES
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbRegisterCallback(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEventCallback callback /* The function to call */
+ ) ;
+
+
+/* Summary
+ This function connects the West Bridge device D+ and D- signals physically to the USB host.
+
+ Description
+ The West Bridge device has the ability to programmatically disconnect the USB pins on the device
+ from the USB host. This feature allows for re-enumeration of the West Bridge device as a different
+ device when necessary. This function connects the D+ and D- signal physically to the USB host
+ if they have been previously disconnnected.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+
+ See Also
+ * CyAsUsbDisconnect
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbConnect(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function disconnects the West Bridge device D+ and D- signals physically from the USB host.
+
+ Description
+ The West Bridge device has the ability to programmatically disconnect the USB pins on the device
+ from the USB host. This feature allows for re-enumeration of the West Bridge device as a different
+ device when necessary. This function disconnects the D+ and D- signal physically from the USB host
+ if they have been previously connected.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+
+ See Also
+ * CyAsUsbConnect
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbDisconnect(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function configures the USB stack
+
+ Description
+ This function is used to configure the USB stack. It is used to indicate which endpoints are going to
+ be used, and how to deal with the mass storage USB device within West Bridge.
+
+ * Valid In Asynchronous Callback: Yes (if cb supplied)
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+
+ See Also
+ * CyAsUsbGetEnumConfig
+ * CyAsUsbEnumControl
+ */
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetEnumConfig(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEnumControl * config_p, /* The USB configuration information */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function retreives the current configuration of the USB stack
+
+ Description
+ This function sends a request to West Bridge to retreive the current configuration
+
+ * Valid In Asynchronous Callback: Yes (if cb supplied)
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+
+ See Also
+ * CyAsUsbSetConfig
+ * CyAsUsbConfig
+ */
+EXTERN CyAsReturnStatus_t
+CyAsUsbGetEnumConfig(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEnumControl* config_p, /* The return value for USB congifuration information */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function sets the USB descriptor
+
+ Description
+ This function is used to set the various descriptors assocaited with the USB enumeration
+ process. This function should only be called when the West Bridge enumeration model is selected.
+ Descriptors set using this function can be cleared by stopping the USB stack, or by calling
+ the CyAsUsbClearDescriptors function.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ These descriptors are described in the USB 2.0 specification, Chapter 9.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_DESCRIPTOR - the descriptor passed is not valid
+ * CY_AS_ERROR_BAD_INDEX - a bad index was given for the type of descriptor given
+ * CY_AS_ERROR_BAD_ENUMERATION_MODE - this function cannot be called if the P port processor doing enumeration
+
+ See Also
+ * CyAsUsbGetDescriptor
+ * CyAsUsbClearDescriptors
+ * <LINK Enumeration Model>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetDescriptor(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbDescType type, /* The type of descriptor */
+ uint8_t index, /* Only valid for string descriptors */
+ void * desc_p, /* The descriptor to be transferred */
+ uint16_t length, /* The length of the descriptor in bytes */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function clears all user descriptors stored on the West Bridge.
+
+ Description
+ This function is used to clear all descriptors that were previously
+ stored on the West Bridge through CyAsUsbSetDescriptor calls, and go back
+ to the default descriptor setup in the firmware. This function should
+ only be called when the Antioch enumeration model is selected.
+
+ * Valid In Asynchronous Callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - all descriptors cleared successfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_BAD_ENUMERATION_MODE - this function cannot be called if the P port processor is doing enumeration
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * <LINK Enumeration Model>
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbClearDescriptors(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+/* Summary
+ This structure contains the descriptor buffer to be filled by CyAsUsbGetDescriptor API.
+
+ Description
+ This data structure the buffer to hold the descriptor data, and an in/out parameter ti indicate the
+ lenght of the buffer and descriptor data in bytes.
+
+ See Also
+ * CyAsUsbGetDescriptor
+*/
+typedef struct CyAsGetDescriptorData
+{
+ void * desc_p; /* The buffer to hold the returned descriptor */
+ uint32_t length; /* This is an input and output parameter. Before the code this pointer
+ points to a uint32_t that contains the length of the buffer. After
+ the call, this value contains the amount of data actually returned. */
+
+} CyAsGetDescriptorData ;
+
+/* Summary
+ This function retreives a given descriptor from the West Bridge device
+
+ Description
+ This function retreives a USB descriptor from the West Bridge device. This function should only be called when the
+ West Bridge enumeration model is selected.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Notes
+ These descriptors are described in the USB 2.0 specification, Chapter 9.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_BAD_INDEX - a bad index was given for the type of descriptor given
+ * CY_AS_ERROR_BAD_ENUMERATION_MODE - this function cannot be called if the P port processor doing enumeration
+
+ See Also
+ * CyAsUsbSetDescriptor
+ * <LINK Enumeration Model>
+*/
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbGetDescriptor(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbDescType type, /* The type of descriptor */
+ uint8_t index, /* Index for string descriptor */
+ CyAsGetDescriptorData * data, /* Parameters and return value for the get descriptor call */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function sets the configuration of the physical endpoints into one of the
+ twelve supported configuration
+
+ Description
+ USB endpoints are mapped onto one of four physical endpoints in the device. Therefore
+ USB endpoints are known as logical endpoints and these logical endpoints are mapped to
+ one of four physical endpoints. In support of these four physical endpoints there is
+ four kilo-bytes of buffer spaces that can be used as buffers for these physical endpoints.
+ This 4K of buffer space can be configured in one of twelve ways. This function sets the
+ buffer configuration for the physical endpoints.
+
+ * Config 1: PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (2 * 512), PEP4 (2 * 512)
+ * Config 2: PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (4 * 512), PEP4 (N/A)
+ * Config 3: PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (2 * 1024), PEP4(N/A)
+ * Config 4: PEP1 (4 * 512), PEP2 (N/A), PEP3 (2 * 512), PEP4 (2 * 512)
+ * Config 5: PEP1 (4 * 512), PEP2 (N/A), PEP3 (4 * 512), PEP4 (N/A)
+ * Config 6: PEP1 (4 * 512), PEP2 (N/A), PEP3 (2 * 1024), PEP4 (N/A)
+ * Config 7: PEP1 (2 * 1024), PEP2 (N/A), PEP3 (2 * 512), PEP4 (2 * 512)
+ * Config 8: PEP1 (2 * 1024), PEP2 (N/A), PEP3 (4 * 512), PEP4 (N/A)
+ * Config 9: PEP1 (2 * 1024), PEP2 (N/A), PEP3 (2 * 1024), PEP4 (N/A)
+ * Config 10: PEP1 (3 * 512), PEP2 (N/A), PEP3 (3 * 512), PEP4 (2 * 512)
+ * Config 11: PEP1 (3 * 1024), PEP2 (N/A), PEP3 (N/A), PEP4 (2 * 512)
+ * Config 12: PEP1 (4 * 1024), PEP2 (N/A), PEP3 (N/A), PEP4 (N/A)
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_CONFIGURATION - the configuration given is not between 1 and 12
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetPhysicalConfiguration(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ uint8_t config /* The physical endpoint configuration number */
+ ) ;
+
+/* Summary
+ This function sets the hardware configuration for a given endpoint
+
+ Description
+ This function sets the hardware configuration for a given endpoint. This is the method to set the
+ direction of the endpoint, the type of endpoint, the size of the endpoint buffer, and the buffering
+ style for the endpoint.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ Add documentation about endpoint configuration limitations
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+ * CY_AS_ERROR_INVALID_CONFIGURATION - the endpoint configuration given is not valid
+ * CY_AS_ERROR_ENDPOINT_CONFIG_NOT_SET - the physical endpoint configuration is not set
+
+ See Also
+ * CyAsUsbGetEndPointConfig
+ * CyAsUsbEndPointConfig
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetEndPointConfig(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsUsbEndPointConfig * config_p /* The configuration information for the endpoint */
+ ) ;
+
+/* Summary
+ This function retreives the hardware configuration for a given endpoint
+
+ Description
+ This function gets the hardware configuration for the given endpoint. This include information about
+ the direction of the endpoint, the type of endpoint, the size of the endpoint buffer, and the buffering
+ style for the endpoint.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+
+ See Also
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbEndPointConfig
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbGetEndPointConfig(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest*/
+ CyAsUsbEndPointConfig * config_p /* The return value containing the endpoint config information */
+ ) ;
+
+/* Summary
+ This function commits the configuration information that has previously been set.
+
+ Description
+ The initialization process involves calling CyAsUsbSetEnumConfig() and CyAsUsbSetEndPointConfig(). These
+ functions do not actually send the configuration information to the West Bridge device. Instead, these
+ functions store away the configuration information and this CyAsUsbCommitConfig() actually finds the
+ best hardware configuration based on the requested endpoint configuration and sends thsi optimal
+ confiuration down to the West Bridge device.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - a configuration was found and sent to West Bridge
+ * CY_AS_ERROR_NOT_CONFIGURED - the West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - the firmware has not been loaded into West Bridge
+ * CY_AS_ERROR_INVALID_CONFIGURATION - the configuration requested is not possible
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+
+ See Also
+ * CyAsUsbSetEndPointConfig
+ * CyAsUsbSetEnumConfig
+*/
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbCommitConfig(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function reads data from a USB endpoint.
+
+ Description
+ This function reads data from an OUT. This function blocks until the read is complete.
+ If this is a packet read, a single received USB packet will complete the read. If this
+ is not a packet read, this function will block until all of the data requested has been
+ recevied.
+
+ * Valid In Asynchronous Callback: NO
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+
+ See Also
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteData
+ * CyAsUsbWriteDataAsync
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbReadData(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyBool pktread, /* If CyTrue, this is a packet read */
+ uint32_t dsize, /* The amount of data to read */
+ uint32_t * dataread, /* The amount of data read */
+ void * data /* The buffer to hold the data read */
+ ) ;
+
+/* Summary
+ This function reads data from a USB endpoint
+
+ Description
+ This function reads data from an OUT endpoint. This function will return immediately and
+ the callback provided will be called when the read is complete. If this is a packet read,
+ then the callback will be called on the next received packet. If this is not a packet read,
+ the callback will be called when the requested data is received.
+
+ * Valid In Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbWriteData
+ * CyAsUsbWriteDataAsync
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbReadDataAsync(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyBool pktread, /* If CyTrue, this is a packet read */
+ uint32_t dsize, /* The amount of data to read */
+ void * data, /* The buffer for storing the data */
+ CyAsUsbIoCallback callback /* The callback function to call when the data is read */
+ ) ;
+
+/* Summary
+ This function writes data to a USB endpoint
+
+ Description
+ This function writes data to an IN endpoint data buffer. Multiple USB packets may be sent
+ until all data requested has been sent. This function blocks until all of the data has been sent.
+
+ * Valid In Asynchronous Callback: NO
+
+ Notes
+ Calling this function with a dsize of zero will result in a zero length packet transmitted to the
+ USB host.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteDataAsync
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbWriteData(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint to write data to */
+ uint32_t dsize, /* The size of the data to write */
+ void * data /* The data buffer */
+ ) ;
+
+/* Summary
+ This function writes data to a USB endpoint
+
+ Description
+ This function writes data to an IN endpoint data buffer. This function returns immediately
+ and when the write completes, or if an error occurs, the callback function is called to indicate
+ completion of the write operation.
+
+ * Valid In Asynchronous Callback: YES
+
+ Notes
+ Calling this function with a dsize of zero will result in a zero length packet transmitted to the
+ USB host.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint parameter is invalid
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteData
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbWriteDataAsync(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint to write data to */
+ uint32_t dsize, /* The size of the data */
+ void * data, /* The buffer containing the data */
+ CyBool spacket, /* If true, send a short packet to terminate data */
+ CyAsUsbIoCallback callback /* The callback to call when the data is written */
+ ) ;
+
+/* Summary
+ This function aborts an outstanding asynchronous operation on a given endpoint
+
+ Description
+ This function aborts any outstanding operation that is pending on the given
+ endpoint.
+
+ * Valid In Asynchronous Callback: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - this module was shut down sucessfully
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_ASYNC_NOT_PENDING - no asynchronous USB operation was pending
+
+ See Also
+ * CyAsUsbReadData
+ * CyAsUsbReadDataAsync
+ * CyAsUsbWriteData
+ * CyAsUsbWriteDataAsync
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbCancelAsync(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep /* The endpoint of interest */
+ ) ;
+
+/* Summary
+ This function sets a stall condition on a given endpoint
+
+ Description
+ This function sets a stall condition on the given endpoint. If the callback function
+ is not zero, the function is executed asynchronously and the callback is called when
+ the function is completed. If the callback function is zero, this function executes
+ synchronously and will not return until the function has completed.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK (only if no cb supplied)
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbGetStall
+ * CyAsUsbClearStall
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetStall(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+) ;
+
+/* Summary
+ This function clears a stall condition on a given endpoint
+
+ Description
+ This function clears a stall condition on the given endpoint. If the callback function
+ is not zero, the function is executed asynchronously and the callback is called when
+ the function is completed. If the callback function is zero, this function executes
+ synchronously and will not return until the function has completed.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK (only if no cb supplied)
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbGetStall
+ * CyAsUsbSetStall
+*/
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbClearStall(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+
+/* Summary
+ This function returns the stall status for a given endpoint
+
+ Description
+ This function returns the stall status for a given endpoint
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbGetStall
+ * CyAsUsbSetStall
+ * CyAsUsbClearStall
+*/
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbGetStall(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyBool * stall_p, /* The return value for the stall state */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function sets a NAK condition on a given endpoint
+
+ Description
+ This function sets a NAK condition on the given endpoint. If the callback function
+ is not zero, the function is executed asynchronously and the callback is called when
+ the function is completed. If the callback function is zero, this function executes
+ synchronously and will not return until the function has completed.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK (only if no cb supplied)
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbGetNak
+ * CyAsUsbClearNak
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetNak(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+) ;
+
+/* Summary
+ This function clears a NAK condition on a given endpoint
+
+ Description
+ This function clears a NAK condition on the given endpoint. If the callback function
+ is not zero, the function is executed asynchronously and the callback is called when
+ the function is completed. If the callback function is zero, this function executes
+ synchronously and will not return until the function has completed.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK (only if no cb supplied)
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbGetNak
+ * CyAsUsbSetNak
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbClearNak(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function returns the NAK status for a given endpoint
+
+ Description
+ This function returns the NAK status for a given endpoint
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given was invalid, or was not configured as an OUT endpoint
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+
+ See Also
+ * CyAsUsbSetNak
+ * CyAsUsbClearNak
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbGetNak(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyBool * nak_p, /* The return value for the stall state */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+) ;
+
+/* Summary
+ This function triggers a USB remote wakeup from the Processor API
+
+ Description
+ When there is a Suspend condition on the USB bus, this function programmatically takes the USB bus out of thi suspend state.
+
+ * Valid In Asynchronous Callback: YES (if cb supplied)
+ * Nestable: YES
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE
+ * CY_AS_ERROR_INVALID_IN_CALLBACK
+ * CY_AS_ERROR_OUT_OF_MEMORY
+ * CY_AS_ERROR_INVALID_RESPONSE
+ * CY_AS_ERROR_NOT_IN_SUSPEND
+
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSignalRemoteWakeup(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ This function sets the threshold levels for mass storage progress reports from the West Bridge.
+
+ Description
+ The West Bridge firmware can be configured to track the amount of read/write activity on
+ the mass storage device, and send progress reports when the activity level has crossed a
+ threshold level. This function sets the threshold levels for the progress reports.
+ Set wr_sectors and rd_sectors to 0, if the progress reports are to be turned off.
+
+ * Valid In Asynchronous Callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the function succeeded
+ * CY_AS_ERROR_NOT_RUNNING - the USB stack is not running
+ * CY_AS_ERROR_TIMEOUT - a timeout occurred communicating with the West Bridge device
+ * CY_AS_ERROR_INVALID_HANDLE - Bad handle
+ * CY_AS_ERROR_INVALID_IN_CALLBACK - Synchronous call made while in callback
+ * CY_AS_ERROR_OUT_OF_MEMORY - Failed allocating memory for request processing
+ * CY_AS_ERROR_NOT_SUPPORTED - Firmware version does not support mass storage progress tracking
+ * CY_AS_ERROR_INVALID_RESPONSE - Unexpected response from Firmware
+
+ See Also
+ * CyAsUsbMSCProgressData
+ * CyAsEventUsbMSCProgress
+*/
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetMSReportThreshold(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ uint32_t wr_sectors, /* Number of sectors written before report is sent */
+ uint32_t rd_sectors, /* Number of sectors read before report is sent */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+/* Summary
+ Specify which of the partitions on a partitioned mass storage device should be made visible to
+ USB.
+
+ Description
+ West Bridge firmware supports the creation of upto two partitions on mass storage devices
+ connected to the West Bridge device. When there are two partitions on a device, the user
+ can choose which of these partitions should be made visible to the USB host through the
+ USB mass storage interface. This function allows the user to configure the partitions that
+ should be enumerated. At least one partition should be selected through this API. If neither
+ partition needs to be enumerated, use CyAsUsbSetEnumConfig to control this.
+
+ * Valid in Asynchronous callback: Yes (if cb supplied)
+ * Nestable: Yes
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - operation completed successfully
+ * CY_AS_ERROR_INVALID_HANDLE - invalid handle to the West Bridge device
+ * CY_AS_ERROR_NOT_CONFIGURED - West Bridge device has not been configured
+ * CY_AS_ERROR_NO_FIRMWARE - no firmware running on West Bridge device
+ * CY_AS_ERROR_NOT_RUNNING - USB stack has not been started
+ * CY_AS_ERROR_IN_SUSPEND - West Bridge device is in suspend mode
+ * CY_AS_ERROR_INVALID_CALL_SEQUENCE - this API has to be called before CyAsUsbSetEnumConfig
+ * CY_AS_ERROR_OUT_OF_MEMORY - failed to get memory to process the request
+ * CY_AS_ERROR_NO_SUCH_UNIT - Storage device addressed has not been partitioned
+ * CY_AS_ERROR_NOT_SUPPORTED - operation is not supported by active device/firmware.
+
+ See Also
+ * CyAsStorageCreatePPartition
+ * CyAsStorageRemovePPartition
+ * CyAsUsbMsType_t
+ */
+EXTERN CyAsReturnStatus_t
+CyAsUsbSelectMSPartitions (
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsBusNumber_t bus, /* Bus index of the device being addressed */
+ uint32_t device, /* Device id of the device being addressed */
+ CyAsUsbMSType_t type, /* Selection of partitions to be enumerated */
+ CyAsFunctionCallback cb, /* The callback, if async call */
+ uint32_t client /* Client supplied data */
+ );
+
+/* For supporting deprecated functions */
+#include "cyasusb_dep.h"
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASUSB_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasusb_dep.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,175 @@
+/* Cypress West Bridge API header file (cyasusb_dep.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/*
+ * This header will contain Antioch specific declaration
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility.
+ */
+
+#ifndef __INCLUDED_CYASUSB_DEP_H__
+#define __INCLUDED_CYASUSB_DEP_H__
+
+#ifndef __doxygen__
+
+/*
+ This data structure is the data passed via the evdata paramater on a usb event
+ callback for the inquiry request.
+*/
+
+typedef struct CyAsUsbInquiryData_dep
+{
+ CyAsMediaType media ; /* The media for the event */
+ uint8_t evpd ; /* The EVPD bit from the SCSI INQUIRY request */
+ uint8_t codepage ; /* The codepage in the inquiry request */
+ CyBool updated ; /* This bool must be set to CyTrue indicate that the inquiry
+ data was changed */
+ uint16_t length ; /* The length of the data */
+ void *data ; /* The inquiry data */
+} CyAsUsbInquiryData_dep ;
+
+
+typedef struct CyAsUsbUnknownCommandData_dep
+{
+ CyAsMediaType media ; /* The media for the event */
+ uint16_t reqlen ; /* The length of the requst (should be 16 bytes) */
+ void *request ; /* The request */
+
+ uint8_t status ; /* The returned status value for the command */
+ uint8_t key ; /* If status is failed, the sense key */
+ uint8_t asc ; /* If status is failed, the additional sense code */
+ uint8_t ascq ; /* If status if failed, the additional sense code qualifier */
+} CyAsUsbUnknownCommandData_dep ;
+
+
+typedef struct CyAsUsbStartStopData_dep
+{
+ CyAsMediaType media ; /* The media type for the event */
+ CyBool start ; /* CyTrue means start request, CyFalse means stop request */
+ CyBool loej ; /* CyTrue means LoEj bit set, otherwise false */
+} CyAsUsbStartStopData_dep ;
+
+
+typedef struct CyAsUsbEnumControl_dep
+{
+ uint8_t enum_mass_storage ; /* The bits in this member determine which mass storage devices
+ are enumerated. See CyAsUsbMassStorageEnum for more details. */
+ CyBool antioch_enumeration ; /* If true, West Bridge will control enumeration. If this is false the
+ Pport controls enumeration. If the P Port is controlling
+ enumeration, traffic will be received via endpoint zero. */
+ uint8_t mass_storage_interface ;/* This is the interface # to use for the mass storage interface,
+ if mass storage is enumerated. If mass storage is not enumerated
+ this value should be zero. */
+ CyBool mass_storage_callbacks ; /* If true, Inquiry, START/STOP, and unknown mass storage
+ requests cause a callback to occur for handling by the
+ baseband processor. */
+} CyAsUsbEnumControl_dep ;
+
+
+typedef void (*CyAsUsbEventCallback_dep)(
+ CyAsDeviceHandle handle, /* Handle to the device to configure */
+ CyAsUsbEvent ev, /* The event type being reported */
+ void * evdata /* The data assocaited with the event being reported */
+) ;
+
+
+
+/* Register Callback api */
+EXTERN CyAsReturnStatus_t
+CyAsUsbRegisterCallback_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEventCallback_dep callback /* The function to call */
+ ) ;
+
+
+extern CyAsReturnStatus_t
+CyAsUsbSetEnumConfig_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEnumControl_dep * config_p, /* The USB configuration information */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+
+extern CyAsReturnStatus_t
+CyAsUsbGetEnumConfig_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbEnumControl_dep* config_p, /* The return value for USB congifuration information */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+extern CyAsReturnStatus_t
+CyAsUsbGetDescriptor_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsUsbDescType type, /* The type of descriptor */
+ uint8_t index, /* Index for string descriptor */
+ void * desc_p, /* The buffer to hold the returned descriptor */
+ uint32_t * length_p /* This is an input and output parameter. Before the code this pointer
+ points to a uint32_t that contains the length of the buffer. After
+ the call, this value contains the amount of data actually returned. */
+ ) ;
+
+extern CyAsReturnStatus_t
+CyAsUsbSetStall_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsUsbFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbClearStall_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsUsbFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbSetNak_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsUsbFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbClearNak_dep(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsEndPointNumber_t ep, /* The endpoint of interest */
+ CyAsUsbFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+EXTERN CyAsReturnStatus_t
+CyAsUsbSelectMSPartitions_dep (
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsUsbMSType_t type,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ ) ;
+
+#endif /*__doxygen*/
+
+#endif /*__INCLUDED_CYANSTORAGE_DEP_H__*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/include/cyasusbdescs.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,267 @@
+#ifndef USBDESCS_H
+#define USBDESCS_H
+
+#include <cyastoria.h>
+#include <cyasmtp.h>
+
+char* UsbStrings[] =
+{
+ "Cypress Semiconductor", /* Manufacturer (device) - index 1 */
+#ifdef DEBUG_ZERO
+ #ifdef DEBUG_MSC
+ "Astoria MSC Device Symbian", /* 2 */
+ #else
+ "Astoria MTP Device Symbian", /* 2 */
+ #endif
+#else
+ "Astoria TMTP Device Symbian", /* 2 */
+#endif
+ "2222222222", /* 3 */
+ "Loopback Configuration", /* 4 */
+ "Loopback Interface" /* 5 */
+} ;
+
+CyCh9DeviceQualifierDesc device_qualifier =
+{
+ sizeof(CyCh9DeviceQualifierDesc),
+ CY_CH9_GD_DEVICE_QUALIFIER, /* DEVICE QUALIFIER TYPE */
+ 0x200, /* USB VERSION */
+ 0x00, /* DEVICE CLASS */
+ 0x00, /* DEVICE SUBCLASS */
+ 0x00, /* PROTOCOL */
+ 64, /* EP0 PACKET SIZE */
+ 1, /* NUMBER OF CONFIGURATIONS */
+ 0
+} ;
+
+/*
+* This is the basic device descriptor for this West Bridge test bench. This descriptor is returned
+* by this software for P port based enumeration.
+*/
+CyCh9DeviceDesc pport_device_desc =
+{
+ sizeof(CyCh9DeviceDesc),
+ CY_CH9_GD_DEVICE, /* DESCRIPTOR TYPE */
+ 0x200, /* USB VERSION */
+ 0x00, /* DEVICE CLASS */
+ 0x00, /* DEVICE SUBCLASS */
+ 0x00, /* PROTOCOL */
+ 64, /* EP0 packet size */
+#ifdef DEBUG_ZERO
+ 0x2,
+ 0x0,
+#else
+ 0x5, /* CYPRESS VENDOR ID */
+ 0x5, /* West Bridge (MADEUP) for composite device */
+#endif
+ 0x2, /* DEVICE VERSION */
+ 0x01, /* STRING ID FOR MANUF. */
+ 0x02, /* STRING ID FOR PRODUCT */
+ 0x03, /* STRING ID FOR SERIAL NUMBER */
+ 0x01 /* NUMBER OF CONFIGURATIONS */
+} ;
+
+CyCh9ConfigurationDesc ZeroDesc =
+{
+ sizeof(CyCh9ConfigurationDesc), /* Descriptor Length */
+ CY_CH9_GD_CONFIGURATION, /* Descriptor Type */
+ sizeof(CyCh9ConfigurationDesc),
+ 0, /* Number of Interfaces */
+ 1, /* Configuration Number */
+ 0, /* Configuration String */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration Attributes */
+ 50 /* Power Requirements */
+} ;
+
+#ifndef DEBUG_ZERO
+CyCh9ConfigurationDesc ConfigHSDesc =
+{
+ sizeof(CyCh9ConfigurationDesc), /* Descriptor Length */
+ CY_CH9_GD_CONFIGURATION, /* Descriptor Type */
+ sizeof(CyCh9ConfigurationDesc),
+ 0,
+ 1, /* Configuration Number */
+ 0, /* Configuration String */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration attributes */
+ 50 /* Power requirements */
+} ;
+
+CyCh9ConfigurationDesc ConfigFSDesc =
+{
+ sizeof(CyCh9ConfigurationDesc), /* Descriptor Length */
+ CY_CH9_GD_CONFIGURATION, /* Descriptor Type */
+ sizeof(CyCh9ConfigurationDesc),
+ 0,
+ 1, /* Configuration Number */
+ 0, /* Configuration String */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration attributes */
+ 50 /* Power requirements */
+} ;
+#else
+
+
+#ifdef DEBUG_MSC
+
+CyCh9ConfigurationDesc ConfigHSDesc =
+{
+ sizeof(CyCh9ConfigurationDesc), /* Descriptor Length */
+ CY_CH9_GD_CONFIGURATION, /* Descriptor Type */
+ sizeof(CyCh9ConfigurationDesc),
+ 0,
+ 1, /* Configuration Number */
+ 0, /* Configuration String */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration attributes */
+ 50 /* Power requirements */
+} ;
+
+CyCh9ConfigurationDesc ConfigFSDesc =
+{
+ sizeof(CyCh9ConfigurationDesc), /* Descriptor Length */
+ CY_CH9_GD_CONFIGURATION, /* Descriptor Type */
+ sizeof(CyCh9ConfigurationDesc),
+ 0,
+ 1, /* Configuration Number */
+ 0, /* Configuration String */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration attributes */
+ 50 /* Power requirements */
+} ;
+
+#else
+
+#pragma pack(push,1)
+typedef struct MyConfigDesc
+{
+ CyCh9ConfigurationDesc m_config ;
+ CyCh9InterfaceDesc m_interface ;
+ /*nxz-debug-z CyCh9EndpointDesc m_endpoints[2] ;*/
+ CyCh9EndpointDesc m_endpoints[3] ;
+
+} MyConfigDesc ;
+#pragma pack(pop)
+
+static MyConfigDesc ConfigFSDesc =
+{
+ /*Configuration Descriptor*/
+ {
+ sizeof(CyCh9ConfigurationDesc), /* Desc Length */
+ CY_CH9_GD_CONFIGURATION, /* Desc Type */
+ /* nxz-debug-z sizeof(CyCh9ConfigurationDesc)+ sizeof(CyCh9InterfaceDesc) + 2 * sizeof(CyCh9EndpointDesc),*/
+ sizeof(CyCh9ConfigurationDesc)+ sizeof(CyCh9InterfaceDesc) + 3 * sizeof(CyCh9EndpointDesc),
+ 1, /* Num of Interface */
+ 1, /* Configuration Value */
+ 251, /* Configuration */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7|CY_CH9_CONFIG_ATTR_SELF_POWERED, /* Configuration Attributes */
+ 50
+ }
+ ,
+ /* Interface Descriptor */
+ {
+ sizeof(CyCh9InterfaceDesc), /* Desc Length */
+ CY_CH9_GD_INTERFACE, /* Desc Type */
+ 0, /* Interface Num */
+ 0, /* Alternate Interface */
+ /*nxz-debug-z 2,*/ /* Number of Endpoints */
+ 3, /* Number of Endpoints */
+ 0xff, /* IF class */
+ 0x00, /* IF sub-class */
+ 0x00, /* IF protocol */
+ 251 /* IF string */
+ }
+ ,
+ {
+ /* EP3_OUT */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_OUT, 3),
+ CY_CH9_ENDPOINT_ATTR_BULK,
+ 64,
+ 255
+ },
+ /* EP5_IN */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_IN, 5),
+ CY_CH9_ENDPOINT_ATTR_BULK,
+ 64,
+ 255
+ },
+ /* nxz-debug-z EP7_INT */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_IN, 7),
+ CY_CH9_ENDPOINT_ATTR_INTERRUPT,
+ 64,
+ 0
+ }
+
+ }
+};
+
+static MyConfigDesc ConfigHSDesc =
+{
+ /*Configuration Descriptor*/
+ {
+ sizeof(CyCh9ConfigurationDesc), /* Desc Length */
+ CY_CH9_GD_CONFIGURATION, /* Desc Type */
+ /*nxz-debug-z sizeof(CyCh9ConfigurationDesc)+ sizeof(CyCh9InterfaceDesc) + 2 * sizeof(CyCh9EndpointDesc),*/
+ sizeof(CyCh9ConfigurationDesc)+ sizeof(CyCh9InterfaceDesc) + 3 * sizeof(CyCh9EndpointDesc),
+ 1, /* Num of Interface */
+ 1, /* Configuration Value */
+ 251, /* Configuration */
+ CY_CH9_CONFIG_ATTR_RESERVED_BIT7, /* Configuration Attributes */
+ 50
+ }
+ ,
+ /* Interface Descriptor */
+ {
+ sizeof(CyCh9InterfaceDesc), /* Desc Length */
+ CY_CH9_GD_INTERFACE, /* Desc Type */
+ 0, /* Interface Num */
+ 0, /* Alternate Interface */
+ /*nxz-debug-z2, */ /* Number of Endpoints */
+ 3, /* Number of Endpoints */
+ 0xff, /* IF class */
+ 0x00, /* IF sub-class */
+ 0x00, /* IF protocol */
+ 251 /* IF string */
+ }
+ ,
+ {
+ /* EP3_OUT */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_OUT, 3),
+ CY_CH9_ENDPOINT_ATTR_BULK,
+ 512,
+ 0
+ },
+ /* EP5_IN */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_IN, 5),
+ CY_CH9_ENDPOINT_ATTR_BULK,
+ 512,
+ 0
+ },
+ /* nxz-debug-z EP7_INT */
+ {
+ sizeof(CyCh9EndpointDesc), /* Desc Length */
+ CY_CH9_GD_ENDPOINT, /* Desc Type */
+ CY_CH9_MK_EP_ADDR(CY_CH9_ENDPOINT_DIR_IN, 7),
+ CY_CH9_ENDPOINT_ATTR_INTERRUPT,
+ 64,
+ 0
+ }
+ }
+};
+#endif
+#endif /*DEBUG_ZERO*/
+
+#endif
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyascast.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,36 @@
+/* Cypress West Bridge API header file (cyasdevice.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASCAST_H_
+#define _INCLUDED_CYASCAST_H_
+
+#ifndef __doxygen__
+#define CyCastInt2UInt16(v) ((uint16_t)(v))
+#if 0 /*nxz*/
+#ifdef _DEBUG
+#define CyCastInt2UInt16(v) (CyAsHalAssert(v < 65536), (uint16_t)(v))
+#else /* _DEBUG */
+#define CyCastInt2UInt16(v) ((uint16_t)(v))
+#endif /* _DEBUG */
+#endif
+
+#endif /* __doxygen__ */
+#endif /* _INCLUDED_CYASCAST_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasdevice.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,756 @@
+/* Cypress West Bridge API header file (cyasdevice.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef __INCLUDED_CYASDEVICE_H__
+#define __INCLUDED_CYASDEVICE_H__
+
+#include "cyashal.h"
+#include "cyasprotocol.h"
+#include "cyasusb.h"
+#include "cyasstorage.h"
+#include "cyasmtp.h"
+#include "cyas_cplus_start.h"
+
+/*****************************************************************************
+ * West Bridge Constants
+ ****************************************************************************/
+
+/* The endpoints used by West Bridge for the P port to S port path */
+#define CY_AS_P2S_WRITE_ENDPOINT (0x04)
+#define CY_AS_P2S_READ_ENDPOINT (0x08)
+
+/* The endpoint to use for firmware download */
+#define CY_AS_FIRMWARE_ENDPOINT (0x02)
+
+/* The maximum size of the firmware image West Bridge can accept */
+#define CY_AS_MAXIMUM_FIRMWARE_SIZE (24 * 1024)
+
+/* The maximum size of a write for EP0 and EP1 */
+#define CY_AS_EP0_MAX_WRITE_SIZE (128)
+#define CY_AS_EP1_MAX_WRITE_SIZE (64)
+
+/* The bitfields for the device state value */
+#define CY_AS_DEVICE_STATE_PIN_STANDBY (0x00000001) /* The device is in StandBy mode */
+#define CY_AS_DEVICE_STATE_CONFIGURED (0x00000002) /* The device has been configured */
+#define CY_AS_DEVICE_STATE_FIRMWARE_LOADED (0x00000004) /* The firmware has been loaded into the device */
+#define CY_AS_DEVICE_STATE_LOWLEVEL_MODULE (0x00000008) /* The interrupt module has been initialized */
+#define CY_AS_DEVICE_STATE_DMA_MODULE (0x00000010) /* The DMA module has been initialized */
+#define CY_AS_DEVICE_STATE_INTR_MODULE (0x00000020) /* The interrupt module has been initialized */
+#define CY_AS_DEVICE_STATE_STORAGE_MODULE (0x00000040) /* The storage module has been initialized */
+#define CY_AS_DEVICE_STATE_USB_MODULE (0x00000080) /* The USB module has been initialized */
+#define CY_AS_DEVICE_STATE_STORAGE_SCSIMSG (0x00000100) /* If set, the API wants SCSI messages */
+#define CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING (0x00000200) /* If set, an ASYNC storage operation is pending */
+#define CY_AS_DEVICE_STATE_USB_CONNECTED (0x00000400) /* If set, the USB port is connected */
+#define CY_AS_DEVICE_STATE_USB_HIGHSPEED (0x00000800) /* If set and USB is connected, it is high speed */
+#define CY_AS_DEVICE_STATE_IN_CALLBACK (0x00001000) /* If set, we are in a callback */
+#define CY_AS_DEVICE_STATE_IN_SETUP_PACKET (0x00004000) /* If set, we are processing a setup packet */
+#define CY_AS_DEVICE_STATE_REGISTER_STANDBY (0x00008000) /* The device was placed in standby via register */
+#define CY_AS_DEVICE_STATE_CRYSTAL (0x00010000) /* If set, the device is using a crystal */
+#define CY_AS_DEVICE_STATE_WAKING (0x00020000) /* If set, wakeup has been called */
+#define CY_AS_DEVICE_STATE_EP0_STALLED (0x00040000) /* If set, EP0 has been stalled. */
+#define CY_AS_DEVICE_STATE_SUSPEND (0x00080000) /* If set, device is in suspend mode. */
+#define CY_AS_DEVICE_STATE_RESETP (0x00100000) /* If set, device is a reset is pending. */
+#define CY_AS_DEVICE_STATE_STANDP (0x00200000) /* If set, device is a standby is pending. */
+#define CY_AS_DEVICE_STATE_SSSP (0x00400000) /* If set, device has a storage start or stop pending. */
+#define CY_AS_DEVICE_STATE_USSP (0x00800000) /* If set, device has a usb start or stop pending. */
+#define CY_AS_DEVICE_STATE_MSSP (0x01000000) /* If set, device has a mtp start or stop pending. */
+
+
+/* The bitfields for the endpoint state value */
+#define CY_AS_DMA_ENDPOINT_STATE_ENABLED (0x0001) /* DMA requests are accepted into the queue */
+#define CY_AS_DMA_ENDPOINT_STATE_SLEEPING (0x0002) /* The endpoint has a sleeping client, waiting on a queue drain */
+#define CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING (0x0004) /* The DMA backend to hardware is running */
+#define CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT (0x0008) /* There is an outstanding DMA entry deployed to the HAL */
+#define CY_AS_DMA_ENDPOINT_STATE_DIRECTION (0x0010) /* 0 = OUT (West Bridge -> P Port), 1 = IN (P Port -> West Bridge) */
+
+/* The state values for the request list */
+#define CY_AS_REQUEST_LIST_STATE_MASK (0x0f) /* Mask for getting the state information */
+#define CY_AS_REQUEST_LIST_STATE_QUEUED (0x00) /* The request is queued, nothing further */
+#define CY_AS_REQUEST_LIST_STATE_WAITING (0x01) /* The request is sent, waiting for response */
+#define CY_AS_REQUEST_LIST_STATE_RECEIVED (0x02) /* The response has been received, processing reponse */
+#define CY_AS_REQUEST_LIST_STATE_CANCELING (0x03) /* The request/response is being canceled */
+#define CY_AS_REQUEST_LIST_STATE_SYNC (0x80) /* The request is synchronous */
+
+/* The flag values for a LL RequestResponse */
+#define CY_AS_REQUEST_RESPONSE_DELAY_ACK (0x01) /* This request requires an ACK to be sent after it is completed */
+#define CY_AS_REQUEST_RESPONSE_EX (0x02) /* This request originated from a version V1.1 function call */
+#define CY_AS_REQUEST_RESPONSE_MS (0x04) /* This request originated from a version V1.2 function call */
+
+
+#define CY_AS_DEVICE_HANDLE_SIGNATURE (0x01211219)
+
+/*
+ * This macro returns the endpoint pointer given the device pointer and an endpoint number
+ */
+#define CY_AS_NUM_EP(dev_p, num) ((dev_p)->endp[(num)])
+
+/*****************************************************************************
+ * West Bridge Data Structures
+ ****************************************************************************/
+
+typedef struct CyAsDevice CyAsDevice ;
+
+/* Summary
+ This type defines a callback function that will be called on completion of a DMA operation.
+
+ Description
+ This function definition is for a function that is called when the DMA operation is complete. This
+ function is called with the endpoint number, operation type, buffer pointer and size.
+
+ See Also
+ * CyAsDmaOper
+ * CyAsDmaQueueWrite
+ */
+typedef void (*CyAsDmaCallback)(
+ CyAsDevice * dev_p, /* The device that completed DMA */
+ CyAsEndPointNumber_t ep, /* The endpoint that completed DMA */
+ void * mem_p, /* The pointer to the buffer that completed DMA */
+ uint32_t size, /* The amount of data transferred */
+ CyAsReturnStatus_t error /* The error code for this DMA xfer */
+ ) ;
+
+/* Summary
+ This structure defines a DMA request that is queued
+
+ Description
+ This structure contains the information about a DMA request that is queued and is to
+ be sent when possible.
+*/
+typedef struct CyAsDmaQueueEntry
+{
+ void * buf_p ; /* Pointer to memory buffer for this request */
+ uint32_t size ; /* Size of the memory buffer for DMA operation */
+ uint32_t offset ; /* Offset into memory buffer for next DMA operation */
+ CyBool packet ; /* If TRUE and IN request */
+ CyBool readreq ; /* If TRUE, this is a read request */
+ CyAsDmaCallback cb ; /* Callback function for when DMA is complete */
+ struct CyAsDmaQueueEntry * next_p ; /* Pointer to next entry in queue */
+} CyAsDmaQueueEntry ;
+
+/* Summary
+ This structure defines the endpoint data for a given
+
+ Description
+ This structure defines all of the information required to manage DMA for a given
+ endpoint.
+*/
+typedef struct CyAsDmaEndPoint
+{
+ CyAsEndPointNumber_t ep ; /* The endpoint number */
+ uint8_t state ; /* The state of this endpoint */
+ uint16_t maxhwdata ; /* The maximum amount of data accepted in a packet by the hw */
+ uint32_t maxhaldata ; /* The maximum amount of data accepted by the HAL layer */
+ CyAsDmaQueueEntry * queue_p ; /* The queue for DMA operations */
+ CyAsDmaQueueEntry * last_p ; /* The last entry in the DMA queue */
+ CyAsHalSleepChannel channel ; /* This sleep channel is used to wait while the DMA queue drains for a given endpoint */
+} CyAsDmaEndPoint ;
+
+#define CyAsEndPointNumberIsUsb(n) ((n) != 2 && (n) != 4 && (n) != 6 && (n) != 8)
+#define CyAsEndPointNumberIsStorage(n) ((n) == 2 || (n) == 4 || (n) == 6 || (n) == 8)
+
+#define CyAsDmaEndPointIsEnabled(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_ENABLED)
+#define CyAsDmaEndPointEnable(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_ENABLED)
+#define CyAsDmaEndPointDisable(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_ENABLED)
+
+#define CyAsDmaEndPointIsSleeping(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
+#define CyAsDmaEndPointSetSleepState(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
+#define CyAsDmaEndPointSetWakeState(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_SLEEPING)
+
+#define CyAsDmaEndPointIsRunning(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
+#define CyAsDmaEndPointSetRunning(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
+#define CyAsDmaEndPointSetStopped(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DMA_RUNNING)
+
+#define CyAsDmaEndPointInTransit(ep) ((ep)->state & CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
+#define CyAsDmaEndPointSetInTransit(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
+#define CyAsDmaEndPointClearInTransit(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_IN_TRANSIT)
+
+#define CyAsDmaEndPointIsDirectionIn(ep) (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
+#define CyAsDmaEndPointIsDirectionOut(ep) (((ep)->state & CY_AS_DMA_ENDPOINT_STATE_DIRECTION) == 0)
+#define CyAsDmaEndPointSetDirectionIn(ep) ((ep)->state |= CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
+#define CyAsDmaEndPointSetDirectionOut(ep) ((ep)->state &= ~CY_AS_DMA_ENDPOINT_STATE_DIRECTION)
+
+#define CyAsDmaEndPointIsUsb(p) CyAsEndPointNumberIsUsb((p)->ep)
+#define CyAsDmaEndPointIsStorage(p) CyAsEndPointNumberIsStorage((p)->ep)
+
+typedef struct CyAsLLRequestResponse
+{
+ uint16_t box0 ; /* The mbox[0] contents - see low level comm section of API doc */
+ uint16_t stored ; /* The amount of data stored in this request/response in bytes */
+ uint16_t length ; /* Length of this request in words */
+ uint16_t flags ; /* Additional status information about the request */
+ uint16_t data[1] ; /* Note: This is over indexed and contains the request/response data */
+} CyAsLLRequestResponse ;
+
+/*
+ * The callback function for responses
+ */
+typedef void (*CyAsResponseCallback)(
+ CyAsDevice * dev_p, /* The device that had the response */
+ uint8_t context, /* The context receiving a response */
+ CyAsLLRequestResponse * rqt, /* The request data */
+ CyAsLLRequestResponse * resp, /* The response data */
+ CyAsReturnStatus_t status /* The status of the request */
+ ) ;
+
+typedef struct CyAsLLRequestListNode
+{
+ CyAsLLRequestResponse * rqt ; /* The request to send */
+ CyAsLLRequestResponse * resp ; /* The associated response for the request */
+ uint16_t length ; /* Length of the response */
+ CyAsResponseCallback callback ; /* The callback to call when done */
+ uint8_t state ; /* The state of the request */
+ struct CyAsLLRequestListNode * next ; /* The next request in the list */
+} CyAsLLRequestListNode ;
+
+#define CyAsRequestGetNodeState(node_p) ((node_p)->state & CY_AS_REQUEST_LIST_STATE_MASK)
+#define CyAsRequestSetNodeState(node_p, st) ((node_p)->state = ((node_p)->state & ~CY_AS_REQUEST_LIST_STATE_MASK) | (st))
+
+#define CyAsRequestNodeIsSync(node_p) ((node_p)->state & CY_AS_REQUEST_LIST_STATE_SYNC)
+#define CyAsRequestNodeSetSync(node_p) ((node_p)->state |= CY_AS_REQUEST_LIST_STATE_SYNC)
+#define CyAsRequestNodeClearSync(node_p) ((node_p)->state &= ~CY_AS_REQUEST_LIST_STATE_SYNC)
+
+#ifndef __doxygen__
+typedef enum CyAsCBNodeType
+{
+ CYAS_INVALID,
+ CYAS_USB_FUNC_CB,
+ CYAS_USB_IO_CB,
+ CYAS_STORAGE_IO_CB,
+ CYAS_FUNC_CB
+} CyAsCBNodeType ;
+
+typedef struct CyAsFuncCBNode
+{
+ CyAsCBNodeType nodeType ;
+ CyAsFunctionCallback cb_p ;
+ uint32_t client_data ;
+ /*CyAsFunctCBType dataType ; nxz */
+ uint32_t dataType ;
+ void* data ;
+ struct CyAsFuncCBNode * next_p ;
+} CyAsFuncCBNode;
+
+extern CyAsFuncCBNode*
+CyAsCreateFuncCBNodeData(CyAsFunctionCallback cb, uint32_t client, CyAsFunctCBType type, void* data) ;
+
+extern CyAsFuncCBNode*
+CyAsCreateFuncCBNode(CyAsFunctionCallback cb, uint32_t client) ;
+
+extern void
+CyAsDestroyFuncCBNode(CyAsFuncCBNode* node) ;
+
+typedef struct CyAsMTPFuncCBNode
+{
+ CyAsCBNodeType type ;
+ CyAsMTPFunctionCallback cb_p ;
+ uint32_t client_data;
+ struct CyAsMTPFuncCBNode * next_p ;
+} CyAsMTPFuncCBNode;
+
+extern CyAsMTPFuncCBNode*
+CyAsCreateMTPFuncCBNode(CyAsMTPFunctionCallback cb, uint32_t client) ;
+
+extern void
+CyAsDestroyMTPFuncCBNode(CyAsMTPFuncCBNode* node) ;
+
+typedef struct CyAsUsbFuncCBNode
+{
+ CyAsCBNodeType type ;
+ CyAsUsbFunctionCallback cb_p ;
+ uint32_t client_data;
+ struct CyAsUsbFuncCBNode * next_p ;
+} CyAsUsbFuncCBNode;
+
+extern CyAsUsbFuncCBNode*
+CyAsCreateUsbFuncCBNode(CyAsUsbFunctionCallback cb, uint32_t client) ;
+
+extern void
+CyAsDestroyUsbFuncCBNode(CyAsUsbFuncCBNode* node) ;
+
+typedef struct CyAsUsbIoCBNode
+{
+ CyAsCBNodeType type ;
+ CyAsUsbIoCallback cb_p ;
+ struct CyAsUsbIoCBNode * next_p ;
+} CyAsUsbIoCBNode;
+
+extern CyAsUsbIoCBNode*
+CyAsCreateUsbIoCBNode(CyAsUsbIoCallback cb) ;
+
+extern void
+CyAsDestroyUsbIoCBNode(CyAsUsbIoCBNode* node) ;
+
+typedef struct CyAsStorageIoCBNode
+{
+ CyAsCBNodeType type ;
+ CyAsStorageCallback cb_p ;
+ CyAsMediaType media ; /* The media for the currently outstanding async storage request */
+ uint32_t device_index ; /* The device index for the currently outstanding async storage request */
+ uint32_t unit ; /* The unit index for the currently outstanding async storage request */
+ uint32_t block_addr ; /* The block address for the currently outstanding async storage request */
+ CyAsOperType oper ; /* The operation for the currently outstanding async storage request */
+ CyAsLLRequestResponse* req_p ;
+ CyAsLLRequestResponse* reply_p ;
+ struct CyAsStorageIoCBNode* next_p ;
+} CyAsStorageIoCBNode;
+
+extern CyAsStorageIoCBNode*
+CyAsCreateStorageIoCBNode(CyAsStorageCallback cb, CyAsMediaType media, uint32_t device_index,
+ uint32_t unit, uint32_t block_addr, CyAsOperType oper,
+ CyAsLLRequestResponse* req_p, CyAsLLRequestResponse* reply_p) ;
+
+extern void
+CyAsDestroyStorageIoCBNode(CyAsStorageIoCBNode* node) ;
+
+typedef struct CyAsCBQueue
+{
+ void * head_p;
+ void * tail_p;
+ uint32_t count ;
+ CyAsCBNodeType type ;
+} CyAsCBQueue ;
+
+extern CyAsCBQueue *
+CyAsCreateCBQueue(CyAsCBNodeType type) ;
+
+extern void
+CyAsDestroyCBQueue(CyAsCBQueue* queue) ;
+
+/* Allocates a new CyAsCBNode */
+extern void
+CyAsInsertCBNode(CyAsCBQueue * queue_p, void* cbnode) ;
+
+/* Removes the first CyAsCBNode from the queue and frees it */
+extern void
+CyAsRemoveCBNode(CyAsCBQueue * queue_p) ;
+
+/* Remove the last CyAsCBNode from the queue and frees it */
+extern void
+CyAsRemoveCBTailNode(CyAsCBQueue *queue_p) ;
+
+/* Removes and frees all pending callbacks */
+extern void
+CyAsClearCBQueue(CyAsCBQueue * queue_p) ;
+
+extern CyAsReturnStatus_t
+CyAsMiscSendRequest(CyAsDevice* dev_p,
+ CyAsFunctionCallback cb,
+ uint32_t client,
+ CyAsFunctCBType type,
+ void* data,
+ CyAsCBQueue* queue,
+ uint16_t req_type,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsResponseCallback rcb) ;
+
+extern void
+CyAsMiscCancelExRequests(CyAsDevice* dev_p) ;
+
+/* Summary
+ Free all memory allocated by and zero all structures initialized
+ by CyAsUsbStart.
+ */
+extern void
+CyAsUsbCleanup (
+ CyAsDevice *dev_p) ;
+
+/* Summary
+ Free all memory allocated and zero all structures initialized
+ by CyAsStorageStart.
+ */
+extern void
+CyAsStorageCleanup (
+ CyAsDevice *dev_p) ;
+#endif
+
+/* Summary
+ This structure defines the data structure to support a given command context
+
+ Description
+ All commands send to the West Bridge device via the mailbox registers are sent via a context.
+ Each context is independent and there can be a parallel stream of requests and responses on
+ each context. This structure is used to manage a single context.
+*/
+typedef struct CyAsContext
+{
+ uint8_t number ; /* The context number for this context */
+ CyAsHalSleepChannel channel ; /* This sleep channel is used to sleep while waiting on a response from the
+ West Bridge device for a request. */
+ CyAsLLRequestResponse * req_p ; /* The buffer for received requests */
+ uint16_t request_length ; /* The length of the request being received */
+ CyAsResponseCallback request_callback ; /* The callback for the next request received */
+
+ CyAsLLRequestListNode * request_queue_p ; /* A list of low level requests to go to the firmware */
+ CyAsLLRequestListNode * last_node_p ; /* The list node in the request queue */
+
+ uint16_t queue_index ; /* Index upto which data is stored. */
+ uint16_t rqt_index ; /* Index to the next request in the queue. */
+ uint16_t data_queue[128] ; /* Queue of data stored */
+
+} CyAsContext ;
+
+#define CyAsContextIsWaiting(ctxt) ((ctxt)->state & CY_AS_CTXT_STATE_WAITING_RESPONSE)
+#define CyAsContextSetWaiting(ctxt) ((ctxt)->state |= CY_AS_CTXT_STATE_WAITING_RESPONSE)
+#define CyAsContextClearWaiting(ctxt) ((ctxt)->state &= ~CY_AS_CTXT_STATE_WAITING_RESPONSE)
+
+
+
+/* Summary
+ This data structure stores SDIO function parameters for a SDIO card
+
+ Description
+*/
+typedef struct CyAsSDIODevice
+{
+ uint8_t function_init_map; /* Keeps track of IO functions initialized*/
+ uint8_t function_suspended_map;
+ CyAsSDIOCard card; /* Function 0 (Card Common) properties*/
+ CyAsSDIOFunc function[7]; /* Function 1-7 (Mapped to array element 0-6) properties.*/
+
+}CyAsSDIODevice;
+
+/* Summary
+Macros to access the SDIO card properties
+*/
+//GetFunction Code
+#define CyAsSdioGetFunctionCode(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].function_code
+
+//Get Function Extended Code
+#define CyAsSdioGetFunctionExtCode(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].extended_func_code
+
+//Get Function Product Serial number
+#define CyAsSdioGetFunctionPSN(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].card_psn
+
+//Get Function Block Size
+#define CyAsSdioGetFunctionBlocksize(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].blocksize
+
+//Get Function Max Block Size
+#define CyAsSdioGetFunctionMaxBlocksize(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].maxblocksize
+
+//Get Function CSA support
+#define CyAsSdioGetFunctionCsaSupport(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1].csa_bits
+
+//Get Function Wakeup Support
+#define CyAsSdioGetFunctionWakeupSupport(handle,bus,i) ((CyAsDevice *)handle)->sdiocard[bus].function[i-1]. wakeup_support
+
+#define CyAsSdioSetFunctionBlockSize(handle,bus,i,blocksize) (((CyAsDevice *)handle)->sdiocard[bus].function[i-1].blocksize = blocksize)
+
+//Get Number of funtions on card
+#define CyAsSdioGetCardNumFunctions(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.num_functions
+
+//Check if memory is present on the card
+#define CyAsSdioGetCardMemPresent(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.memory_present
+
+//Get Card manufaturer ID
+#define CyAsSdioGetCardManfId(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.manufacturer_Id
+
+//Get Card manufacturer Information
+#define CyAsSdioGetCardManfInfo(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.manufacturer_info
+
+//Get Card Block Size
+#define CyAsSdioGetCardBlocksize(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.blocksize
+
+//Get Card max Block Size
+#define CyAsSdioGetCardMaxBlocksize(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.maxblocksize
+
+//Get SDIO version supported by card
+#define CyAsSdioGetCardSDIOVersion(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.sdio_version
+
+//Get Card capabillity register
+#define CyAsSdioGetCardCapability(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].card.card_capability
+
+//Get function initialization map
+#define CyAsSdioGetFunctionInitMap(handle,bus) ((CyAsDevice *)handle)->sdiocard[bus].function_init_map
+
+//Check if function i has been initialized
+#define CyAsSdioCheckFunctionInitialized(handle,bus,i) (((CyAsSdioGetFunctionInitMap(handle,bus))& (0x01<<i))?1:0)
+
+//Set the Card functio 0 block size
+#define CyAsSdioSetCardBlockSize(handle,bus,blocksize) (((CyAsDevice *)handle)->sdiocard[bus].card.blocksize = blocksize)
+
+//Check if the Card supports Bus suspend.
+#define CyAsSdioCheckSupportBusSuspend(handle,bus) ((CyAsSdioGetCardCapability(handle,bus) & CY_SDIO_SBS)?1:0)
+
+//Check if a fuction is in suspended state
+#define CyAsSdioCheckFunctionSuspended(handle,bus,i) ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map & (0x01<<i))?1:0)
+
+//Set a function state to suspended
+#define CyAsSdioSetFunctionSuspended(handle,bus,i) ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map) |= (0x01<<i))
+
+//Clear a function suspended state
+#define CyAsSdioClearFunctionSuspended(handle,bus,i) ((((CyAsDevice *)handle)->sdiocard[bus].function_suspended_map) &= (~(0x01<<i)))
+
+/* Summary
+ This data structure represents a single device.
+
+ Description
+*/
+struct CyAsDevice
+{
+ /* General stuff */
+ uint32_t sig ; /* A signature to insure we have a valid handle */
+ uint16_t silicon_id ; /* The ID of the silicon */
+ struct CyAsDevice * next_p ; /* Pointer to the next device */
+ CyAsHalDeviceTag tag ; /* This is the client specific tag for this device */
+ uint32_t state ; /* This contains various state information about the device */
+ CyBool use_int_drq ; /* Flag indicating whether INT# pin is used for DRQ */
+
+ /* DMA related */
+ CyAsDmaEndPoint * endp[16] ; /* The endpoint pointers associated with this device */
+ CyAsDmaQueueEntry * dma_freelist_p ; /* List of queue entries that can be used for xfers */
+
+ /* Low level comm related */
+ CyAsContext * context[CY_RQT_CONTEXT_COUNT] ; /* The contexts available in this device */
+ CyAsReturnStatus_t ll_error ; /* The low level error returned from sending an async request */
+ CyBool ll_sending_rqt ; /* A request is currently being sent to West Bridge. */
+ CyBool ll_abort_curr_rqt ; /* The current mailbox request should be aborted. */
+ CyBool ll_queued_data ; /* Indicates that the LL layer has queued mailbox data. */
+
+ /* MISC API related */
+ CyAsMiscEventCallback misc_event_cb ; /* Misc callback */
+
+ /* Storage Related */
+ uint32_t storage_count ; /* The reference count for the Storage API */
+ CyAsStorageEventCallback_dep storage_event_cb ; /* Callback for storage events */
+ CyAsStorageEventCallback storage_event_cb_ms ; /* V1.2+ callback for storage events */
+ CyAsReturnStatus_t storage_error ; /* The error for a sleeping storage operation */
+ CyBool storage_wait ; /* Flag indicating that the storage stack is waiting for an operation */
+ CyAsLLRequestResponse * storage_rw_req_p ; /* Request used for storage read/writes. */
+ CyAsLLRequestResponse * storage_rw_resp_p ; /* Response used for storage read/writes. */
+ CyAsStorageCallback_dep storage_cb ; /* The storage callback */
+ CyAsStorageCallback storage_cb_ms ; /* The V1.2+ storage callback */
+ CyAsBusNumber_t storage_bus_index ; /* The bus index for the currently outstanding async storage request */
+ uint32_t storage_device_index ; /* The device index for the currently outstanding async storage request */
+ uint32_t storage_unit ; /* The unit index for the currently outstanding async storage request */
+ uint32_t storage_block_addr ; /* The block address for the currently outstanding async storage request */
+ CyAsOperType storage_oper ; /* The operation for the currently outstanding async storage request */
+ CyAsEndPointNumber_t storage_read_endpoint ; /* The endpoint used to read Storage data */
+ CyAsEndPointNumber_t storage_write_endpoint ; /* The endpoint used to write endpoint data */
+ CyAsDeviceDesc storage_device_info[CY_AS_MAX_BUSES][CY_AS_MAX_STORAGE_DEVICES] ;
+ /* The information on each device on each bus */
+
+ /* USB Related */
+ uint16_t epasync ; /* This conatins the endpoint async state */
+ uint32_t usb_count ; /* The reference count for the USB API */
+ uint8_t usb_phy_config ; /* The physical endpoint configuration */
+ CyAsCBQueue * usb_func_cbs ; /* The callbacks for async func calls */
+ CyAsUsbEndPointConfig usb_config[16] ; /* Endpoint configuration information */
+ CyAsUsbEventCallback_dep usb_event_cb ; /* The USB callback */
+ CyAsUsbEventCallback usb_event_cb_ms ; /* The V1.2+ USB callback */
+ CyAsReturnStatus_t usb_error ; /* The error for a sleeping usb operation */
+ CyAsUsbIoCallback usb_cb[16] ; /* The USB callback for a pending storage operation */
+ void * usb_pending_buffer ; /* The buffer pending from a USB operation */
+ uint32_t usb_pending_size ; /* The size of the buffer pending from a USB operation */
+ CyBool usb_spacket[16] ; /* If true, send a short packet */
+ uint32_t usb_actual_cnt ; /* The amount of data actually xferred */
+ uint8_t usb_ep1cfg[2] ; /* EP1OUT and EP1IN config register contents */
+ uint16_t usb_lepcfg[10] ; /* LEP config register contents */
+ uint16_t usb_pepcfg[4] ; /* PEP config register contents */
+ uint8_t * usb_ep_data ; /* Buffer for EP0 and EP1 data sent via mailboxes */
+ uint32_t usb_delay_ack_count ; /* Used to track how many ack requests are pending */
+ uint32_t usb_max_tx_size ; /* Maximum transfer size for USB endpoints. */
+
+ CyAsLLRequestResponse * usb_ep0_dma_req ; /* Request for sending EP0 data to West Bridge */
+ CyAsLLRequestResponse * usb_ep0_dma_resp ; /* Response for EP0 data sent to West Bridge */
+ CyAsLLRequestResponse * usb_ep1_dma_req ; /* Request for sending EP1 data to West Bridge */
+ CyAsLLRequestResponse * usb_ep1_dma_resp ; /* Response for EP1 data sent to West Bridge */
+
+ CyAsLLRequestResponse * usb_ep0_dma_req_save ;
+ CyAsLLRequestResponse * usb_ep0_dma_resp_save ;
+
+ /* MTP Related */
+ uint32_t mtp_count ; /* The reference count for the MTP API */
+ CyAsMTPEventCallback mtp_event_cb ; /* The MTP event callback supplied by the client */
+ CyAsMTPBlockTable* mtp_blk_tbl ; /* The current block table to be transfered */
+
+ CyAsCBQueue * func_cbs_mtp ;
+ CyAsCBQueue * func_cbs_usb ;
+ CyAsCBQueue * func_cbs_stor ;
+ CyAsCBQueue * func_cbs_misc ;
+ CyAsCBQueue * func_cbs_res ;
+
+ CyAsUsbEvent usb_last_event ; /* The last USB event that was received */
+ uint8_t media_supported[CY_AS_MAX_BUSES] ; /* Types of storage media supported by the firmware */
+
+ CyAsSDIODevice sdiocard[CY_AS_MAX_BUSES]; /* SDIO card parameters*/
+ CyBool is_mtp_firmware ; /* if true, MTP enabled Firmware. */
+ CyBool is_mtp_data_pending ; /* if true, mailbox message has come already */
+ CyBool mtp_turbo_active ; /* True between the time an Init was called and the complete event is generated */
+ uint16_t mtp_data_len ; /* mbox reported EP 2 data len */
+ CyAsReturnStatus_t mtp_error ; /* The error for mtp EP4 write operation */
+ CyAsFunctionCallback mtp_cb ; /* mtp send/get operation callback */
+ uint32_t mtp_client ; /* mtp send/get operation client id */
+ CyAsFunctCBType mtp_op ; /* mtp operation type. To be used in callback */
+
+ CyBool is_storage_only_mode ; /* Firmware is running in P2S only mode. */
+ uint32_t stby_int_mask ; /* Interrupt mask value during device standby. */
+} ;
+
+#define CyAsDeviceIsConfigured(dp) ((dp)->state & CY_AS_DEVICE_STATE_CONFIGURED)
+#define CyAsDeviceSetConfigured(dp) ((dp)->state |= CY_AS_DEVICE_STATE_CONFIGURED)
+#define CyAsDeviceSetUnconfigured(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_CONFIGURED)
+
+#define CyAsDeviceIsDmaRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_DMA_MODULE)
+#define CyAsDeviceSetDmaRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_DMA_MODULE)
+#define CyAsDeviceSetDmaStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_DMA_MODULE)
+
+#define CyAsDeviceIsLowLevelRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+#define CyAsDeviceSetLowLevelRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+#define CyAsDeviceSetLowLevelStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_LOWLEVEL_MODULE)
+
+#define CyAsDeviceIsIntrRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_INTR_MODULE)
+#define CyAsDeviceSetIntrRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_INTR_MODULE)
+#define CyAsDeviceSetIntrStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_INTR_MODULE)
+
+#define CyAsDeviceIsFirmwareLoaded(dp) ((dp)->state & CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+#define CyAsDeviceSetFirmwareLoaded(dp) ((dp)->state |= CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+#define CyAsDeviceSetFirmwareNotLoaded(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_FIRMWARE_LOADED)
+
+#define CyAsDeviceIsStorageRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_MODULE)
+#define CyAsDeviceSetStorageRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_MODULE)
+#define CyAsDeviceSetStorageStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_MODULE)
+
+#define CyAsDeviceIsUsbRunning(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_MODULE)
+#define CyAsDeviceSetUsbRunning(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_MODULE)
+#define CyAsDeviceSetUsbStopped(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_MODULE)
+
+#define CyAsDeviceWantsScsiMessages(dp) (((dp)->state & CY_AS_DEVICE_STATE_STORAGE_SCSIMSG) ? CyTrue : CyFalse)
+#define CyAsDeviceSetScsiMessages(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
+#define CyAsDeviceClearScsiMessages(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_SCSIMSG)
+
+#define CyAsDeviceIsStorageAsyncPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+#define CyAsDeviceSetStorageAsyncPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+#define CyAsDeviceClearStorageAsyncPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STORAGE_ASYNC_PENDING)
+
+#define CyAsDeviceIsUsbConnected(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_CONNECTED)
+#define CyAsDeviceSetUsbConnected(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_CONNECTED)
+#define CyAsDeviceClearUsbConnected(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_CONNECTED)
+
+#define CyAsDeviceIsUsbHighSpeed(dp) ((dp)->state & CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+#define CyAsDeviceSetUsbHighSpeed(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+#define CyAsDeviceClearUsbHighSpeed(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USB_HIGHSPEED)
+
+#define CyAsDeviceIsInCallback(dp) ((dp)->state & CY_AS_DEVICE_STATE_IN_CALLBACK)
+#define CyAsDeviceSetInCallback(dp) ((dp)->state |= CY_AS_DEVICE_STATE_IN_CALLBACK)
+#define CyAsDeviceClearInCallback(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_CALLBACK)
+
+#define CyAsDeviceIsSetupIOPerformed(dp) ((dp)->state & CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+#define CyAsDeviceSetSetupIOPerformed(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+#define CyAsDeviceClearSetupIOPerformed(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SETUP_IO_PERFORMED)
+
+#define CyAsDeviceIsAckDelayed(dp) ((dp)->usb_delay_ack_count > 0)
+#define CyAsDeviceSetAckDelayed(dp) ((dp)->usb_delay_ack_count++)
+#define CyAsDeviceRemAckDelayed(dp) ((dp)->usb_delay_ack_count--)
+#define CyAsDeviceClearAckDelayed(dp) ((dp)->usb_delay_ack_count = 0)
+
+#define CyAsDeviceIsSetupPacket(dp) ((dp)->state & CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+#define CyAsDeviceSetSetupPacket(dp) ((dp)->state |= CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+#define CyAsDeviceClearSetupPacket(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_IN_SETUP_PACKET)
+
+#define CyAsDeviceIsEp0Stalled(dp) ((dp)->state & CY_AS_DEVICE_STATE_EP0_STALLED)
+#define CyAsDeviceSetEp0Stalled(dp) ((dp)->state |= CY_AS_DEVICE_STATE_EP0_STALLED)
+#define CyAsDeviceClearEp0Stalled(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_EP0_STALLED)
+
+#define CyAsDeviceIsRegisterStandby(dp) ((dp)->state & CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+#define CyAsDeviceSetRegisterStandby(dp) ((dp)->state |= CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+#define CyAsDeviceClearRegisterStandby(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_REGISTER_STANDBY)
+
+#define CyAsDeviceIsPinStandby(dp) ((dp)->state & CY_AS_DEVICE_STATE_PIN_STANDBY)
+#define CyAsDeviceSetPinStandby(dp) ((dp)->state |= CY_AS_DEVICE_STATE_PIN_STANDBY)
+#define CyAsDeviceClearPinStandby(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_PIN_STANDBY)
+
+#define CyAsDeviceIsCrystal(dp) ((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL)
+#define CyAsDeviceIsExternalClock(dp) (!((dp)->state & CY_AS_DEVICE_STATE_CRYSTAL))
+#define CyAsDeviceSetCrystal(dp) ((dp)->state |= CY_AS_DEVICE_STATE_CRYSTAL)
+#define CyAsDeviceSetExternalClock(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_CRYSTAL)
+
+#define CyAsDeviceIsWaking(dp) ((dp)->state & CY_AS_DEVICE_STATE_WAKING)
+#define CyAsDeviceSetWaking(dp) ((dp)->state |= CY_AS_DEVICE_STATE_WAKING)
+#define CyAsDeviceClearWaking(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_WAKING)
+
+#define CyAsDeviceIsInSuspendMode(dp) ((dp)->state & CY_AS_DEVICE_STATE_SUSPEND)
+#define CyAsDeviceSetSuspendMode(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SUSPEND)
+#define CyAsDeviceClearSuspendMode(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SUSPEND)
+
+#define CyAsDeviceIsResetPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_RESETP)
+#define CyAsDeviceSetResetPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_RESETP)
+#define CyAsDeviceClearResetPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_RESETP)
+
+#define CyAsDeviceIsStandbyPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_STANDP)
+#define CyAsDeviceSetStandbyPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_STANDP)
+#define CyAsDeviceClearStandbyPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_STANDP)
+
+#define CyAsDeviceIsSSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_SSSP)
+#define CyAsDeviceSetSSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_SSSP)
+#define CyAsDeviceClearSSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_SSSP)
+
+#define CyAsDeviceIsUSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_USSP)
+#define CyAsDeviceSetUSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_USSP)
+#define CyAsDeviceClearUSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_USSP)
+
+#define CyAsDeviceIsMSSPending(dp) ((dp)->state & CY_AS_DEVICE_STATE_MSSP)
+#define CyAsDeviceSetMSSPending(dp) ((dp)->state |= CY_AS_DEVICE_STATE_MSSP)
+#define CyAsDeviceClearMSSPending(dp) ((dp)->state &= ~CY_AS_DEVICE_STATE_MSSP)
+
+#define CyAsDeviceIsUsbAsyncPending(dp, ep) ((dp)->epasync & (1 << ep))
+#define CyAsDeviceSetUsbAsyncPending(dp, ep) ((dp)->epasync |= (1 << ep))
+#define CyAsDeviceClearUsbAsyncPending(dp, ep) ((dp)->epasync &= ~(1 << ep))
+
+#define CyAsDeviceIsNandStorageSupported(dp) ((dp)->media_supported[0] & 1)
+
+/* Macros to check the type of West Bridge device. */
+#define CyAsDeviceIsAstoriaDev(dp) (((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE) || \
+ ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE))
+#define CyAsDeviceIsAntiochDev(dp) ((dp)->silicon_id == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE)
+
+#ifdef CY_AS_LOG_SUPPORT
+extern void CyAsLogDebugMessage(int value, const char *msg) ;
+#else
+#define CyAsLogDebugMessage(value, msg)
+#endif
+
+/* Summary
+ This function finds the device object given the HAL tag
+
+ Description
+ The user associats a device TAG with each West Bridge device created. This tag is passed from the
+ API functions to and HAL functions that need to ID a specific West Bridge device. This tag is also
+ passed in from the user back into the API via interrupt functions. This function allows the API
+ to find the device structure associated with a given tag.
+
+ Notes
+ This function does a simple linear search for the device based on the TAG. This function is
+ called each time an West Bridge interrupt handler is called. Therefore this works fine for a small
+ number of West Bridge devices (e.g. less than five). Anything more than this and this methodology
+ will need to be updated.
+
+ Returns
+ Pointer to a CyAsDevice associated with the tag
+*/
+extern CyAsDevice *
+CyAsDeviceFindFromTag(
+ CyAsHalDeviceTag tag
+ ) ;
+
+#include "cyas_cplus_end.h"
+
+#endif /* __INCLUDED_CYASDEVICE_H__ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasdma.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1054 @@
+/* Cypress West Bridge API source file (cyasdma.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasdma.h"
+#include "cyaslowlevel.h"
+#include "cyaserr.h"
+#include "cyasregs.h"
+
+/*
+ * Add the DMA queue entry to the free list to be re-used later
+ */
+static void
+CyAsDmaAddRequestToFreeQueue(CyAsDevice *dev_p, CyAsDmaQueueEntry *req_p)
+{
+ uint32_t imask ;
+ imask = CyAsHalDisableInterrupts() ;
+
+ req_p->next_p = dev_p->dma_freelist_p ;
+ dev_p->dma_freelist_p = req_p ;
+
+ CyAsHalEnableInterrupts(imask) ;
+}
+
+/*
+ * Get a DMA queue entry from the free list.
+ */
+static CyAsDmaQueueEntry *
+CyAsDmaGetDmaQueueEntry(CyAsDevice *dev_p)
+{
+ CyAsDmaQueueEntry *req_p ;
+ uint32_t imask ;
+
+ CyAsHalAssert(dev_p->dma_freelist_p != 0) ;
+
+ imask = CyAsHalDisableInterrupts() ;
+ req_p = dev_p->dma_freelist_p ;
+ dev_p->dma_freelist_p = req_p->next_p ;
+ CyAsHalEnableInterrupts(imask) ;
+
+ return req_p ;
+}
+
+/*
+ * Set the maximum size that the West Bridge hardware can handle in a single DMA operation. This size
+ * may change for the P <-> U endpoints as a function of the endpoint type and whether we are running
+ * at full speed or high speed.
+ */
+CyAsReturnStatus_t
+CyAsDmaSetMaxDmaSize(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, uint32_t size)
+{
+ /* In MTP mode, EP2 is allowed to have all max sizes. */
+ if ((!dev_p->is_mtp_firmware) || (ep != 0x02))
+ {
+ if (size < 64 || size > 1024)
+ return CY_AS_ERROR_INVALID_SIZE ;
+ }
+
+ CY_AS_NUM_EP(dev_p, ep)->maxhwdata = (uint16_t)size ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+ * The callback for requests sent to West Bridge to relay endpoint data. Endpoint
+ * data for EP0 and EP1 are sent using mailbox requests. This is the callback that
+ * is called when a response to a mailbox request to send data is received.
+ */
+static void
+CyAsDmaRequestCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *resp_p,
+ CyAsReturnStatus_t ret)
+{
+ uint16_t v ;
+ uint16_t datacnt ;
+ CyAsEndPointNumber_t ep ;
+
+ (void)context ;
+
+ CyAsLogDebugMessage(5, "CyAsDmaRequestCallback called") ;
+
+ /*
+ * Extract the return code from the firmware
+ */
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp_p) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(resp_p, 0) ;
+ }
+
+ /*
+ * Extract the endpoint number and the transferred byte count
+ * from the request.
+ */
+ v = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ ep = (CyAsEndPointNumber_t)((v >> 13) & 0x01) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ /*
+ * If the firmware returns success, all of the data requested was
+ * transferred. There are no partial transfers.
+ */
+ datacnt = v & 0x3FF ;
+ }
+ else
+ {
+ /*
+ * If the firmware returned an error, no data was transferred.
+ */
+ datacnt = 0 ;
+ }
+
+ /*
+ * Queue the request and response data structures for use with the
+ * next EP0 or EP1 request.
+ */
+ if (ep == 0)
+ {
+ dev_p->usb_ep0_dma_req = req_p ;
+ dev_p->usb_ep0_dma_resp = resp_p ;
+ }
+ else
+ {
+ dev_p->usb_ep1_dma_req = req_p ;
+ dev_p->usb_ep1_dma_resp = resp_p ;
+ }
+
+ /*
+ * Call the DMA complete function so we can signal that this portion of the
+ * transfer has completed. If the low level request was canceled, we do not
+ * need to signal the completed function as the only way a cancel can happen
+ * is via the DMA cancel function.
+ */
+ if (ret != CY_AS_ERROR_CANCELED)
+ CyAsDmaCompletedCallback(dev_p->tag, ep, datacnt, ret) ;
+}
+
+/*
+ * Set the DRQ mask register for the given endpoint number. If state is
+ * CyTrue, the DRQ interrupt for the given endpoint is enabled, otherwise
+ * it is disabled.
+ */
+static void
+CyAsDmaSetDrq(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, CyBool state)
+{
+ uint16_t mask ;
+ uint16_t v ;
+ uint32_t intval ;
+
+ /*
+ * There are not DRQ register bits for EP0 and EP1
+ */
+ if (ep == 0 || ep == 1)
+ return ;
+
+ /*
+ * Disable interrupts while we do this to be sure the state of the
+ * DRQ mask register is always well defined.
+ */
+ intval = CyAsHalDisableInterrupts() ;
+
+ /*
+ * Set the DRQ bit to the given state for the ep given
+ */
+ mask = (1 << ep) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_DRQ_MASK) ;
+
+ if (state)
+ v |= mask ;
+ else
+ v &= ~mask ;
+
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_DRQ_MASK, v) ;
+ CyAsHalEnableInterrupts(intval) ;
+}
+
+/*
+* Send the next DMA request for the endpoint given
+*/
+static void
+CyAsDmaSendNextDmaRequest(CyAsDevice *dev_p, CyAsDmaEndPoint *ep_p)
+{
+ uint32_t datacnt ;
+ void *buf_p ;
+ CyAsDmaQueueEntry *dma_p ;
+
+ CyAsLogDebugMessage(6, "CyAsDmaSendNextDmaRequest called") ;
+
+ /* If the queue is empty, nothing to do */
+ dma_p = ep_p->queue_p ;
+ if (dma_p == 0)
+ {
+ /*
+ * There are not pending DMA requests for this endpoint. Disable
+ * the DRQ mask bits to insure no interrupts will be triggered by this
+ * endpoint until someone is interested in the data.
+ */
+ CyAsDmaSetDrq(dev_p, ep_p->ep, CyFalse) ;
+ return ;
+ }
+
+ CyAsDmaEndPointSetRunning(ep_p) ;
+
+ /*
+ * Get the number of words that still need to be xferred in
+ * this request.
+ */
+ datacnt = dma_p->size - dma_p->offset ;
+ CyAsHalAssert(datacnt >= 0) ;
+
+ /*
+ * The HAL layer should never limit the size of the transfer to
+ * something less than the maxhwdata otherwise, the data will be
+ * sent in packets that are not correct in size.
+ */
+ CyAsHalAssert(ep_p->maxhaldata == CY_AS_DMA_MAX_SIZE_HW_SIZE || ep_p->maxhaldata >= ep_p->maxhwdata) ;
+
+ /*
+ * Update the number of words that need to be xferred yet
+ * based on the limits of the HAL layer.
+ */
+ if (ep_p->maxhaldata == CY_AS_DMA_MAX_SIZE_HW_SIZE)
+ {
+ if (datacnt > ep_p->maxhwdata)
+ datacnt = ep_p->maxhwdata ;
+ }
+ else
+ {
+ if (datacnt > ep_p->maxhaldata)
+ datacnt = ep_p->maxhaldata ;
+ }
+
+ /*
+ * Find a pointer to the data that needs to be transferred
+ */
+ buf_p = (((char *)dma_p->buf_p) + dma_p->offset);
+
+ /*
+ * Mark a request in transit
+ */
+ CyAsDmaEndPointSetInTransit(ep_p) ;
+
+ if (ep_p->ep == 0 || ep_p->ep == 1)
+ {
+ /*
+ * If this is a WRITE request on EP0 and EP1, we write the data via an EP_DATA request
+ * to West Bridge via the mailbox registers. If this is a READ request, we do nothing and the data will
+ * arrive via an EP_DATA request from West Bridge. In the request handler for the USB context we will pass
+ * the data back into the DMA module.
+ */
+ if (dma_p->readreq == CyFalse)
+ {
+ uint16_t v ;
+ uint16_t len ;
+ CyAsLLRequestResponse *resp_p ;
+ CyAsLLRequestResponse *req_p ;
+ CyAsReturnStatus_t ret ;
+
+ len = (uint16_t)(datacnt / 2) ;
+ if (datacnt % 2)
+ len++ ;
+
+ len++ ;
+
+ if (ep_p->ep == 0)
+ {
+ req_p = dev_p->usb_ep0_dma_req ;
+ resp_p = dev_p->usb_ep0_dma_resp ;
+ dev_p->usb_ep0_dma_req = 0 ;
+ dev_p->usb_ep0_dma_resp = 0 ;
+ }
+ else
+ {
+ req_p = dev_p->usb_ep1_dma_req ;
+ resp_p = dev_p->usb_ep1_dma_resp ;
+ dev_p->usb_ep1_dma_req = 0 ;
+ dev_p->usb_ep1_dma_resp = 0 ;
+ }
+
+ CyAsHalAssert(req_p != 0) ;
+ CyAsHalAssert(resp_p != 0) ;
+ CyAsHalAssert(len <= 64) ;
+
+ CyAsLLInitRequest(req_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, len) ;
+
+ v = (uint16_t)(datacnt | (ep_p->ep << 13) | (1 << 14)) ;
+ if (dma_p->offset == 0)
+ v |= (1 << 12) ; /* Set the first packet bit */
+ if (dma_p->offset + datacnt == dma_p->size)
+ v |= (1 << 11) ; /* Set the last packet bit */
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, v) ;
+ CyAsLLRequestResponse_Pack(req_p, 1, datacnt, buf_p) ;
+
+ CyAsLLInitResponse(resp_p, 1) ;
+
+ ret = CyAsLLSendRequest(dev_p, req_p, resp_p, CyFalse, CyAsDmaRequestCallback) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ CyAsLogDebugMessage(5, "+++ Send EP 0/1 data via mailbox registers") ;
+ else
+ CyAsLogDebugMessage(5, "+++ Error Sending EP 0/1 data via mailbox registers - CY_AS_ERROR_TIMEOUT") ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsDmaCompletedCallback(dev_p->tag, ep_p->ep, 0, ret) ;
+ }
+ }
+ else
+ {
+ /*
+ * This is a DMA request on an endpoint that is accessible via the P port. Ask the
+ * HAL DMA capabilities to perform this. The amount of data sent is limited by the
+ * HAL max size as well as what we need to send. If the ep_p->maxhaldata is set to
+ * a value larger than the endpoint buffer size, then we will pass more than a single
+ * buffer worth of data to the HAL layer and expect the HAL layer to divide the data
+ * into packets. The last parameter here (ep_p->maxhwdata) gives the packet size for
+ * the data so the HAL layer knows what the packet size should be.
+ */
+ if (CyAsDmaEndPointIsDirectionIn(ep_p))
+ CyAsHalDmaSetupWrite(dev_p->tag, ep_p->ep, buf_p, datacnt, ep_p->maxhwdata) ;
+ else
+ CyAsHalDmaSetupRead(dev_p->tag, ep_p->ep, buf_p, datacnt, ep_p->maxhwdata) ;
+
+ /*
+ * The DRQ interrupt for this endpoint should be enabled so that the data
+ * transfer progresses at interrupt time.
+ */
+ CyAsDmaSetDrq(dev_p, ep_p->ep, CyTrue) ;
+ }
+}
+
+/*
+ * This function is called when the HAL layer has completed the last requested DMA
+ * operation. This function sends/receives the next batch of data associated with the
+ * current DMA request, or it is is complete, moves to the next DMA request.
+ */
+void
+CyAsDmaCompletedCallback(CyAsHalDeviceTag tag, CyAsEndPointNumber_t ep, uint32_t cnt, CyAsReturnStatus_t status)
+{
+ uint32_t mask ;
+ CyAsDmaQueueEntry *req_p ;
+ CyAsDmaEndPoint *ep_p ;
+ CyAsDevice *dev_p = CyAsDeviceFindFromTag(tag) ;
+
+ /* Make sure the HAL layer gave us good parameters */
+ CyAsHalAssert(dev_p != 0) ;
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+ CyAsHalAssert(ep < 16) ;
+
+
+ /* Get the endpoint ptr */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+ CyAsHalAssert(ep_p->queue_p != 0) ;
+
+ /* Get a pointer to the current entry in the queue */
+ mask = CyAsHalDisableInterrupts() ;
+ req_p = ep_p->queue_p ;
+
+ /* Update the offset to reflect the data actually received or sent */
+ req_p->offset += cnt ;
+
+ /*
+ * If we are still sending/receiving the current packet, send/receive the next chunk
+ * Basically we keep going if we have not sent/received enough data, and we are not doing
+ * a packet operation, and the last packet sent or received was a full sized packet. In
+ * other words, when we are NOT doing a packet operation, a less than full size packet
+ * (a short packet) will terminate the operation.
+ *
+ * Note: If this is EP1 request and the request has timed out, it means the buffer is not free.
+ * We have to resend the data.
+ *
+ * Note: For the MTP data transfers, the DMA transfer for the next packet can only be started
+ * asynchronously, after a firmware event notifies that the device is ready.
+ */
+ if (((req_p->offset != req_p->size) && (req_p->packet == CyFalse) && ((cnt == ep_p->maxhaldata) ||
+ ((cnt == ep_p->maxhwdata) && ((ep != CY_AS_MTP_READ_ENDPOINT) || (cnt == dev_p->usb_max_tx_size)))))
+ || ((ep == 1) && (status == CY_AS_ERROR_TIMEOUT)))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+
+ /*
+ * And send the request again to send the next block of data. Special handling for
+ * MTP transfers on EPs 2 and 6. The SendNextRequest will be processed based on the
+ * event sent by the firmware.
+ */
+ if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (
+ (ep == CY_AS_MTP_READ_ENDPOINT) && (!CyAsDmaEndPointIsDirectionIn (ep_p))))
+ CyAsDmaEndPointSetStopped(ep_p) ;
+ else
+ CyAsDmaSendNextDmaRequest(dev_p, ep_p) ;
+ }
+ else
+ {
+ /*
+ * We get here if ...
+ * we have sent or received all of the data
+ * or
+ * we are doing a packet operation
+ * or
+ * we receive a short packet
+ */
+
+ /*
+ * Remove this entry from the DMA queue for this endpoint.
+ */
+ CyAsDmaEndPointClearInTransit(ep_p) ;
+ ep_p->queue_p = req_p->next_p ;
+ if (ep_p->last_p == req_p)
+ {
+ /*
+ * We have removed the last packet from the DMA queue, disable the
+ * interrupt associated with this interrupt.
+ */
+ ep_p->last_p = 0 ;
+ CyAsHalEnableInterrupts(mask) ;
+ CyAsDmaSetDrq(dev_p, ep, CyFalse) ;
+ }
+ else
+ CyAsHalEnableInterrupts(mask) ;
+
+ if (req_p->cb)
+ {
+ /*
+ * If the request has a callback associated with it, call the callback
+ * to tell the interested party that this DMA request has completed.
+ *
+ * Note, we set the InCallback bit to insure that we cannot recursively
+ * call an API function that is synchronous only from a callback.
+ */
+ CyAsDeviceSetInCallback(dev_p) ;
+ (*req_p->cb)(dev_p, ep, req_p->buf_p, req_p->offset, status) ;
+ CyAsDeviceClearInCallback(dev_p) ;
+ }
+
+ /*
+ * We are done with this request, put it on the freelist to be
+ * reused at a later time.
+ */
+ CyAsDmaAddRequestToFreeQueue(dev_p, req_p) ;
+
+ if (ep_p->queue_p == 0)
+ {
+ /*
+ * If the endpoint is out of DMA entries, set it the endpoint as
+ * stopped.
+ */
+ CyAsDmaEndPointSetStopped(ep_p) ;
+
+ /*
+ * The DMA queue is empty, wake any task waiting on the QUEUE to
+ * drain.
+ */
+ if (CyAsDmaEndPointIsSleeping(ep_p))
+ {
+ CyAsDmaEndPointSetWakeState(ep_p) ;
+ CyAsHalWake(&ep_p->channel) ;
+ }
+ }
+ else
+ {
+ /*
+ * If the queued operation is a MTP transfer, wait until firmware event
+ * before sending down the next DMA request.
+ */
+ if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (
+ (ep == CY_AS_MTP_READ_ENDPOINT) && (!CyAsDmaEndPointIsDirectionIn (ep_p))))
+ CyAsDmaEndPointSetStopped(ep_p) ;
+ else
+ CyAsDmaSendNextDmaRequest(dev_p, ep_p) ;
+ }
+ }
+}
+
+/*
+* This function is used to kick start DMA on a given channel. If DMA is already running
+* on the given endpoint, nothing happens. If DMA is not running, the first entry is pulled
+* from the DMA queue and sent/recevied to/from the West Bridge device.
+*/
+CyAsReturnStatus_t
+CyAsDmaKickStart(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)
+{
+ CyAsDmaEndPoint *ep_p ;
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ /* We are already running */
+ if (CyAsDmaEndPointIsRunning(ep_p))
+ return CY_AS_ERROR_SUCCESS ;
+
+ CyAsDmaSendNextDmaRequest(dev_p, ep_p);
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+ * This function stops the given endpoint. Stopping and endpoint cancels
+ * any pending DMA operations and frees all resources associated with the
+ * given endpoint.
+ */
+static CyAsReturnStatus_t
+CyAsDmaStopEndPoint(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDmaEndPoint *ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ /*
+ * Cancel any pending DMA requests associated with this endpoint. This
+ * cancels any DMA requests at the HAL layer as well as dequeues any request
+ * that is currently pending.
+ */
+ ret = CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /*
+ * Destroy the sleep channel
+ */
+ if (!CyAsHalDestroySleepChannel(&ep_p->channel) && ret == CY_AS_ERROR_SUCCESS)
+ ret = CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED ;
+
+ /*
+ * Free the memory associated with this endpoint
+ */
+ CyAsHalFree(ep_p) ;
+
+ /*
+ * Set the data structure ptr to something sane since the
+ * previous pointer is now free.
+ */
+ dev_p->endp[ep] = 0 ;
+
+ return ret ;
+}
+
+/*
+ * This method stops the USB stack. This is an internal function that does
+ * all of the work of destroying the USB stack without the protections that
+ * we provide to the API (i.e. stopping at stack that is not running).
+ */
+static CyAsReturnStatus_t
+CyAsDmaStopInternal(CyAsDevice *dev_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsReturnStatus_t lret ;
+ CyAsEndPointNumber_t i ;
+
+ /*
+ * Stop all of the endpoints. This cancels all DMA requests, and
+ * frees all resources associated with each endpoint.
+ */
+ for(i = 0 ; i < sizeof(dev_p->endp)/(sizeof(dev_p->endp[0])) ; i++)
+ {
+ lret = CyAsDmaStopEndPoint(dev_p, i) ;
+ if (lret != CY_AS_ERROR_SUCCESS && ret == CY_AS_ERROR_SUCCESS)
+ ret = lret ;
+ }
+
+ /*
+ * Now, free the list of DMA requests structures that we use to manage
+ * DMA requests.
+ */
+ while (dev_p->dma_freelist_p)
+ {
+ CyAsDmaQueueEntry *req_p ;
+ uint32_t imask = CyAsHalDisableInterrupts() ;
+
+ req_p = dev_p->dma_freelist_p ;
+ dev_p->dma_freelist_p = req_p->next_p ;
+
+ CyAsHalEnableInterrupts(imask) ;
+
+ CyAsHalFree(req_p) ;
+ }
+
+ CyAsLLDestroyRequest(dev_p, dev_p->usb_ep0_dma_req) ;
+ CyAsLLDestroyRequest(dev_p, dev_p->usb_ep1_dma_req) ;
+ CyAsLLDestroyResponse(dev_p, dev_p->usb_ep0_dma_resp) ;
+ CyAsLLDestroyResponse(dev_p, dev_p->usb_ep1_dma_resp) ;
+
+ return ret ;
+}
+
+
+/*
+ * CyAsDmaStop()
+ *
+ * This function shuts down the DMA module. All resources associated with the DMA module
+ * will be freed. This routine is the API stop function. It insures that we are stopping
+ * a stack that is actually running and then calls the internal function to do the work.
+ */
+CyAsReturnStatus_t
+CyAsDmaStop(CyAsDevice *dev_p)
+{
+ CyAsReturnStatus_t ret ;
+
+ ret = CyAsDmaStopInternal(dev_p) ;
+ CyAsDeviceSetDmaStopped(dev_p) ;
+
+ return ret ;
+}
+
+/*
+ * CyAsDmaStart()
+ *
+ * This function intializes the DMA module to insure it is up and running.
+ */
+CyAsReturnStatus_t
+CyAsDmaStart(CyAsDevice *dev_p)
+{
+ CyAsEndPointNumber_t i ;
+ uint16_t cnt ;
+
+ if (CyAsDeviceIsDmaRunning(dev_p))
+ return CY_AS_ERROR_ALREADY_RUNNING ;
+
+ /*
+ * Pre-allocate DMA Queue structures to be used in the interrupt context
+ */
+ for(cnt = 0 ; cnt < 32 ; cnt++)
+ {
+ CyAsDmaQueueEntry *entry_p = (CyAsDmaQueueEntry *)CyAsHalAlloc(sizeof(CyAsDmaQueueEntry)) ;
+ if (entry_p == 0)
+ {
+ CyAsDmaStopInternal(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ CyAsDmaAddRequestToFreeQueue(dev_p, entry_p) ;
+ }
+
+ /*
+ * Pre-allocate the DMA requests for sending EP0 and EP1 data to West Bridge
+ */
+ dev_p->usb_ep0_dma_req = CyAsLLCreateRequest(dev_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, 64) ;
+ dev_p->usb_ep1_dma_req = CyAsLLCreateRequest(dev_p, CY_RQT_USB_EP_DATA, CY_RQT_USB_RQT_CONTEXT, 64) ;
+ if (dev_p->usb_ep0_dma_req == 0 || dev_p->usb_ep1_dma_req == 0)
+ {
+ CyAsDmaStopInternal(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ dev_p->usb_ep0_dma_req_save = dev_p->usb_ep0_dma_req ;
+
+ dev_p->usb_ep0_dma_resp = CyAsLLCreateResponse(dev_p, 1) ;
+ dev_p->usb_ep1_dma_resp = CyAsLLCreateResponse(dev_p, 1) ;
+ if (dev_p->usb_ep0_dma_resp == 0 || dev_p->usb_ep1_dma_resp == 0)
+ {
+ CyAsDmaStopInternal(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ dev_p->usb_ep0_dma_resp_save = dev_p->usb_ep0_dma_resp ;
+
+ /*
+ * Set the dev_p->endp to all zeros to insure cleanup is possible if
+ * an error occurs during initialization.
+ */
+ CyAsHalMemSet(dev_p->endp, 0, sizeof(dev_p->endp)) ;
+
+ /*
+ * Now, iterate through each of the endpoints and initialize each
+ * one.
+ */
+ for(i = 0 ; i < sizeof(dev_p->endp)/sizeof(dev_p->endp[0]) ; i++)
+ {
+ dev_p->endp[i] = (CyAsDmaEndPoint *)CyAsHalAlloc(sizeof(CyAsDmaEndPoint)) ;
+ if (dev_p->endp[i] == 0)
+ {
+ CyAsDmaStopInternal(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ CyAsHalMemSet(dev_p->endp[i], 0, sizeof(CyAsDmaEndPoint)) ;
+
+ dev_p->endp[i]->ep = i ;
+ dev_p->endp[i]->queue_p = 0 ;
+ dev_p->endp[i]->last_p = 0 ;
+
+ CyAsDmaSetDrq(dev_p, i, CyFalse) ;
+
+ if (!CyAsHalCreateSleepChannel(&dev_p->endp[i]->channel))
+ return CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED ;
+ }
+
+ /*
+ * Tell the HAL layer who to call when the HAL layer completes a DMA request
+ */
+ CyAsHalDmaRegisterCallback(dev_p->tag, CyAsDmaCompletedCallback) ;
+
+ /*
+ * Mark DMA as up and running on this device
+ */
+ CyAsDeviceSetDmaRunning(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* Wait for all entries in the DMA queue associated the given endpoint to be drained. This
+* function will not return until all the DMA data has been transferred.
+*/
+CyAsReturnStatus_t
+CyAsDmaDrainQueue(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, CyBool kickstart)
+{
+ CyAsDmaEndPoint *ep_p ;
+ int loopcount = 1000 ;
+ uint32_t mask ;
+
+ /*
+ * Make sure the endpoint is valid
+ */
+ if (ep >= sizeof(dev_p->endp)/sizeof(dev_p->endp[0]))
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ /*
+ * If the endpoint is empty of traffic, we return
+ * with success immediately
+ */
+ mask = CyAsHalDisableInterrupts() ;
+ if (ep_p->queue_p == 0)
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_SUCCESS ;
+ }
+ else
+ {
+ /*
+ * Add 10 seconds to the time out value for each 64 KB segment
+ * of data to be transferred.
+ */
+ if (ep_p->queue_p->size > 0x10000)
+ loopcount += ((ep_p->queue_p->size / 0x10000) * 1000) ;
+ }
+ CyAsHalEnableInterrupts(mask) ;
+
+ /* If we are already sleeping on this endpoint, it is an error */
+ if (CyAsDmaEndPointIsSleeping(ep_p))
+ return CY_AS_ERROR_NESTED_SLEEP ;
+
+ /*
+ * We disable the endpoint while the queue drains to
+ * prevent any additional requests from being queued while we are waiting
+ */
+ CyAsDmaEnableEndPoint(dev_p, ep, CyFalse, CyAsDirectionDontChange) ;
+
+ if (kickstart)
+ {
+ /*
+ * Now, kick start the DMA if necessary
+ */
+ CyAsDmaKickStart(dev_p, ep) ;
+ }
+
+ /*
+ * Check one last time before we begin sleeping to see if the
+ * queue is drained.
+ */
+ if (ep_p->queue_p == 0)
+ {
+ CyAsDmaEnableEndPoint(dev_p, ep, CyTrue, CyAsDirectionDontChange) ;
+ return CY_AS_ERROR_SUCCESS ;
+ }
+
+ while (loopcount-- > 0)
+ {
+ /*
+ * Sleep for 10 ms maximum (per loop) while waiting for the transfer
+ * to complete.
+ */
+ CyAsDmaEndPointSetSleepState(ep_p) ;
+ CyAsHalSleepOn(&ep_p->channel, 10) ;
+
+ /* If we timed out, the sleep bit will still be set */
+ CyAsDmaEndPointSetWakeState(ep_p) ;
+
+ /* Check the queue to see if is drained */
+ if (ep_p->queue_p == 0)
+ {
+ /*
+ * Clear the endpoint running and in transit flags for the endpoint,
+ * now that its DMA queue is empty.
+ */
+ CyAsDmaEndPointClearInTransit(ep_p) ;
+ CyAsDmaEndPointSetStopped(ep_p) ;
+
+ CyAsDmaEnableEndPoint(dev_p, ep, CyTrue, CyAsDirectionDontChange) ;
+ return CY_AS_ERROR_SUCCESS ;
+ }
+ }
+
+ /*
+ * The DMA operation that has timed out can be cancelled, so that later
+ * operations on this queue can proceed.
+ */
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_TIMEOUT) ;
+ CyAsDmaEnableEndPoint(dev_p, ep, CyTrue, CyAsDirectionDontChange) ;
+ return CY_AS_ERROR_TIMEOUT ;
+}
+
+/*
+* This function queues a write request in the DMA queue for a given endpoint. The direction of the
+* entry will be inferred from the endpoint direction.
+*/
+CyAsReturnStatus_t
+CyAsDmaQueueRequest(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *mem_p, uint32_t size, CyBool pkt, CyBool readreq, CyAsDmaCallback cb)
+{
+ uint32_t mask ;
+ CyAsDmaQueueEntry *entry_p ;
+ CyAsDmaEndPoint *ep_p ;
+
+ /*
+ * Make sure the endpoint is valid
+ */
+ if (ep >= sizeof(dev_p->endp)/sizeof(dev_p->endp[0]))
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ if (!CyAsDmaEndPointIsEnabled(ep_p))
+ return CY_AS_ERROR_ENDPOINT_DISABLED ;
+
+ entry_p = CyAsDmaGetDmaQueueEntry(dev_p) ;
+
+ entry_p->buf_p = mem_p ;
+ entry_p->cb = cb ;
+ entry_p->size = size ;
+ entry_p->offset = 0 ;
+ entry_p->packet = pkt ;
+ entry_p->readreq = readreq ;
+
+ mask = CyAsHalDisableInterrupts() ;
+ entry_p->next_p = 0 ;
+ if (ep_p->last_p)
+ ep_p->last_p->next_p = entry_p ;
+ ep_p->last_p = entry_p ;
+ if (ep_p->queue_p == 0)
+ ep_p->queue_p = entry_p ;
+ CyAsHalEnableInterrupts(mask) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* This function enables or disables and endpoint for DMA queueing. If an endpoint is disabled, any queued
+* requests continue to be processed, but no new requests can be queued.
+*/
+CyAsReturnStatus_t
+CyAsDmaEnableEndPoint(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, CyBool enable, CyAsDmaDirection dir)
+{
+ CyAsDmaEndPoint *ep_p ;
+
+ /*
+ * Make sure the endpoint is valid
+ */
+ if (ep >= sizeof(dev_p->endp)/sizeof(dev_p->endp[0]))
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ if (dir == CyAsDirectionOut)
+ CyAsDmaEndPointSetDirectionOut(ep_p) ;
+ else if (dir == CyAsDirectionIn)
+ CyAsDmaEndPointSetDirectionIn(ep_p) ;
+
+ /*
+ * Get the maximum size of data buffer the HAL layer can accept. This is used when
+ * the DMA module is sending DMA requests to the HAL. The DMA module will never send
+ * down a request that is greater than this value.
+ *
+ * For EP0 and EP1, we can send no more than 64 bytes of data at one time as this is the
+ * maximum size of a packet that can be sent via these endpoints.
+ */
+ if (ep == 0 || ep == 1)
+ ep_p->maxhaldata = 64 ;
+ else
+ ep_p->maxhaldata = CyAsHalDmaMaxRequestSize(dev_p->tag, ep) ;
+
+ if (enable)
+ CyAsDmaEndPointEnable(ep_p) ;
+ else
+ CyAsDmaEndPointDisable(ep_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+ * This function cancels any DMA operations pending with the HAL layer as well
+ * as any DMA operation queued on the endpoint.
+ */
+CyAsReturnStatus_t
+CyAsDmaCancel(
+ CyAsDevice *dev_p,
+ CyAsEndPointNumber_t ep,
+ CyAsReturnStatus_t err)
+{
+ uint32_t mask ;
+ CyAsDmaEndPoint *ep_p ;
+ CyAsDmaQueueEntry *entry_p ;
+ CyBool epstate ;
+
+ /*
+ * Make sure the endpoint is valid
+ */
+ if (ep >= sizeof(dev_p->endp)/sizeof(dev_p->endp[0]))
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ if (ep_p)
+ {
+ /* Remember the state of the endpoint */
+ epstate = CyAsDmaEndPointIsEnabled(ep_p) ;
+
+ /*
+ * Disable the endpoint so no more DMA packets can be
+ * queued.
+ */
+ CyAsDmaEnableEndPoint(dev_p, ep, CyFalse, CyAsDirectionDontChange) ;
+
+ /*
+ * Don't allow any interrupts from this endpoint while we get the
+ * most current request off of the queue.
+ */
+ CyAsDmaSetDrq(dev_p, ep, CyFalse) ;
+
+ /*
+ * Cancel any pending request queued in the HAL layer
+ */
+ if (CyAsDmaEndPointInTransit(ep_p))
+ CyAsHalDmaCancelRequest(dev_p->tag, ep_p->ep) ;
+
+ /*
+ * Shutdown the DMA for this endpoint so no more data is transferred
+ */
+ CyAsDmaEndPointSetStopped(ep_p) ;
+
+ /*
+ * Mark the endpoint as not in transit, because we are going to consume
+ * any queued requests
+ */
+ CyAsDmaEndPointClearInTransit(ep_p) ;
+
+ /*
+ * Now, remove each entry in the queue and call the associated callback
+ * stating that the request was canceled.
+ */
+ ep_p->last_p = 0 ;
+ while (ep_p->queue_p != 0)
+ {
+ /* Disable interrupts to manipulate the queue */
+ mask = CyAsHalDisableInterrupts() ;
+
+ /* Remove an entry from the queue */
+ entry_p = ep_p->queue_p ;
+ ep_p->queue_p = entry_p->next_p ;
+
+ /* Ok, the queue has been updated, we can turn interrupts back on */
+ CyAsHalEnableInterrupts(mask) ;
+
+ /* Call the callback indicating we have canceled the DMA */
+ if (entry_p->cb)
+ entry_p->cb(dev_p, ep, entry_p->buf_p, entry_p->size, err) ;
+
+ CyAsDmaAddRequestToFreeQueue(dev_p, entry_p) ;
+ }
+
+ if (ep == 0 || ep == 1)
+ {
+ /*
+ * If this endpoint is zero or one, we need to clear the queue of any pending
+ * CY_RQT_USB_EP_DATA requests as these are pending requests to send data to
+ * the West Bridge device.
+ */
+ CyAsLLRemoveEpDataRequests(dev_p, ep) ;
+ }
+
+ if (epstate)
+ {
+ /*
+ * The endpoint started out enabled, so we re-enable the endpoint here.
+ */
+ CyAsDmaEnableEndPoint(dev_p, ep, CyTrue, CyAsDirectionDontChange) ;
+ }
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsDmaReceivedData(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, uint32_t dsize, void *data)
+{
+ CyAsDmaQueueEntry *dma_p ;
+ uint8_t *src_p, *dest_p ;
+ CyAsDmaEndPoint *ep_p ;
+ uint32_t xfersize ;
+
+ /*
+ * Make sure the endpoint is valid
+ */
+ if (ep != 0 && ep != 1)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+ dma_p = ep_p->queue_p ;
+ if (dma_p == 0)
+ return CY_AS_ERROR_SUCCESS ;
+
+ /*
+ * If the data received exceeds the size of the DMA buffer, clip the data to the size
+ * of the buffer. This can lead to loosing some data, but is not different than doing
+ * non-packet reads on the other endpoints.
+ */
+ if (dsize > dma_p->size - dma_p->offset)
+ dsize = dma_p->size - dma_p->offset ;
+
+ /*
+ * Copy the data from the request packet to the DMA buffer for the endpoint
+ */
+ src_p = (uint8_t *)data ;
+ dest_p = ((uint8_t *)(dma_p->buf_p)) + dma_p->offset ;
+ xfersize = dsize ;
+ while (xfersize-- > 0)
+ *dest_p++ = *src_p++ ;
+
+ /* Signal the DMA module that we have received data for this EP request */
+ CyAsDmaCompletedCallback(dev_p->tag, ep, dsize, CY_AS_ERROR_SUCCESS) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasdma.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,312 @@
+/* Cypress West Bridge API header file (cyasdma.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASDMA_H_
+#define _INCLUDED_CYASDMA_H_
+
+#include "cyashal.h"
+#include "cyasdevice.h"
+
+#include "cyas_cplus_start.h"
+
+
+/*@@DMA Overview
+ This module manages the DMA operations to/from the West Bridge device. The
+ DMA module maintains a DMA queue for each endpoint so multiple DMA requests
+ may be queued and they will complete at some future time.
+
+ The DMA module must be started before it can be used. It is started by
+ calling CyAsDmaStart(). This function intializes all of the endpoint
+ data structures.
+
+ In order to perform DMA on a particular endpoint, the endpoint must be
+ enabled by calling CyAsDmaEnableEndPoint(). In addition to enabling or
+ disabling the endpoint, this function also sets the direction for a
+ given endpoint. Direction is given in USB terms. For P port to West Bridge
+ traffic, the endpoint is a CyAsDirectionIn endpoint. For West Bridge to P
+ port traffic, the endpoint is a CyAsDirectionOut endpoint.
+
+ Once DMA is started and an endpoint is enabled, DMA requests are issued by
+ calling CyAsDmaQueueRequest(). This function queue either a DMA read or
+ DMA write request. The callback associated with the request is called once
+ the request has been fulfilled.
+
+ See Also
+ * CyAsDmaStart
+ * CyAsDmaEnableEndPoint
+ * CyAsDmaDirection
+ * CyAsDmaQueueRequest
+ */
+
+/*****************************************************************************
+ * West Bridge Constants
+ ****************************************************************************/
+#define CY_AS_DMA_MAX_SIZE_HW_SIZE (0xffffffff)
+
+/*****************************************************************************
+ * West Bridge Data Structures
+ ****************************************************************************/
+
+/* Summary
+ This type specifies the direction of an endpoint to the CyAsDmaEnableEndPoint function.
+
+ Description
+ When an endpoint is enabled, the direction of the endpoint can also be set.
+ This type is used to specify the endpoint type. Note that the direction is specified in
+ USB terms. Therefore, if the DMA is from the P port to West Bridge, the direction is IN.
+
+ See Also
+ * CyAsDmaEnableEndPoint
+*/
+typedef enum CyAsDmaDirection
+{
+ CyAsDirectionIn = 0, /* Set the endpoint to type IN (P -> West Bridge) */
+ CyAsDirectionOut = 1, /* Set the endpoint to type OUT (West Bridge -> P) */
+ CyAsDirectionInOut = 2, /* Only valid for EP 0 */
+ CyAsDirectionDontChange = 3 /* Do no change the endpoint type */
+} CyAsDmaDirection ;
+
+/*****************************************************************************
+ * West Bridge Functions
+ ****************************************************************************/
+
+/* Summary
+ Initialize the DMA module and ready the module for receiving data
+
+ Description
+ This function initializes the DMA module by initializing all of the endpoint data
+ structures associated with the device given. This function also register a DMA
+ complete callback with the HAL DMA code. This callback is called whenever the
+ HAL DMA subsystem completes a requested DMA operation.
+
+ Returns
+ CY_AS_ERROR_SUCCESS - the module initialized sucessfully
+ CY_AS_ERROR_OUT_OF_MEMORY - memory allocation failed during initialization
+ CY_AS_ERROR_ALREADY_RUNNING - the DMA module was already running
+
+ See Also
+ * CyAsDmaStop
+*/
+extern CyAsReturnStatus_t
+CyAsDmaStart(
+ CyAsDevice * dev_p /* The device to start */
+ ) ;
+
+/* Summary
+ Shutdown the DMA module
+
+ Description
+ This function shuts down the DMA module for this device by canceling any DMA requests
+ associated with each endpoint and then freeing the resources associated with each DMA
+ endpoint.
+
+ Returns
+ CY_AS_ERROR_SUCCESS - the module shutdown sucessfully
+ CY_AS_ERROR_NOT_RUNNING - the DMA module was not running
+
+ See Also
+ * CyAsDmaStart
+ * CyAsDmaCancel
+*/
+extern CyAsReturnStatus_t
+CyAsDmaStop(
+ CyAsDevice * dev_p /* The device to stop */
+ ) ;
+
+/* Summary
+ This function cancels all outstanding DMA requests on a given endpoint
+
+ Description
+ This function cancels any DMA requests outstanding on a given endpoint by
+ disabling the transfer of DMA requests from the queue to the HAL layer and
+ then removing any pending DMA requests from the queue. The callback associated
+ with any DMA requests that are being removed is called with an error code of
+ CY_AS_ERROR_CANCELED.
+
+ Notes
+ If a request has already been sent to the HAL layer it will be completed and
+ not canceled. Only requests that have not been sent to the HAL layer will be
+ canceled.
+
+ Returns
+ CY_AS_ERROR_SUCCESS - the traffic on the endpoint is canceled sucessfully
+
+ See Also
+*/
+extern CyAsReturnStatus_t
+CyAsDmaCancel(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint to cancel */
+ CyAsReturnStatus_t err
+ ) ;
+
+/* Summary
+ This function enables a single endpoint for DMA operations
+
+ Description
+ In order to enable the queuing of DMA requests on a given endpoint, the endpoint
+ must be enabled for DMA. This function enables a given endpoint. In addition, this
+ function sets the direction of the DMA operation.
+
+ Returns
+ * CY_AS_ERROR_INVALID_ENDPOINT - invalid endpoint number
+ * CY_AS_ERROR_SUCCESS - endpoint was enabled or disabled successfully
+
+ See Also
+ * CyAsDmaQueueRequest
+*/
+extern CyAsReturnStatus_t
+CyAsDmaEnableEndPoint(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint to enable or disable */
+ CyBool enable, /* CyTrue to enable, CyFalse to disable */
+ CyAsDmaDirection dir /* The direction of the endpoint */
+ ) ;
+
+/* Summary
+ This function queue a DMA request for a given endpoint
+
+ Description
+ When an West Bridge API module wishes to do a DMA operation, this function is called on the
+ associated endpoint to queue a DMA request. When the DMA request has been fulfilled, the
+ callback associated with the DMA operation is called.
+
+ Notes
+ The buffer associated with the DMA request, must remain valid until after the callback
+ function is calld.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the DMA operation was queued successfully
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint number was invalid
+ * CY_AS_ERROR_ENDPOINT_DISABLED - the endpoint was disabled
+ * CY_AS_ERROR_OUT_OF_MEMORY - out of memory processing the request
+
+ See Also
+ * CyAsDmaEnableEndPoint
+ * CyAsDmaCancel
+*/
+extern CyAsReturnStatus_t
+CyAsDmaQueueRequest(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint to receive a new request */
+ void * mem_p, /* The memory buffer for the DMA request - must be valid until after the callback has been called */
+ uint32_t size, /* The size of the DMA request in bytes */
+ CyBool packet, /* If true and a DMA read request, return the next packet regardless of size */
+ CyBool readreq, /* If true, this is a read request, otherwise it is a write request */
+ CyAsDmaCallback cb /* The callback to call when the DMA request is complete, either successfully or via an error */
+ ) ;
+
+/* Summary
+ This function waits until all DMA requests on a given endpoint have been processed and then return
+
+ Description
+ There are times when a module in the West Bridge API needs to wait until the DMA operations have been
+ queued. This function sleeps until all DMA requests have been fulfilled and only then returns to the caller.
+
+ Notes
+ I don't think we will need a list of sleeping clients to support multiple parallel client modules
+ sleeping on a single endpoint, but if we do instead of having a single sleep channel in the endpoint, each
+ client will have to supply a sleep channel and we will have to maintain a list of sleep channels to wake.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the queue has drained sucessfully
+ * CY_AS_ERROR_INVALID_ENDPOINT - the endpoint given is not valid
+ * CY_AS_ERROR_NESTED_SLEEP - CyAsDmaQueueRequest() was requested on an endpoint where CyAsDmaQueueRequest was already called
+*/
+extern CyAsReturnStatus_t
+CyAsDmaDrainQueue(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint to drain */
+ CyBool kickstart /* If CyTrue, call kickstart to start the DMA process,
+ If CyFalse, West Bridge will start the DMA process */
+ ) ;
+
+/* Summary
+ Sets the maximum amount of data West Bridge can accept in a single DMA Operation for the given endpoint
+
+ Description
+ Depending on the configuration of the West Bridge device endpoint, the amount of data that can be
+ accepted varies. This function sets the maximum amount of data West Bridge can accept in a single
+ DMA operation. The value is stored with the endpoint and passed to the HAL layer in the
+ CyAsHalDmaSetupWrite() and CyAsHalDmaSetupRead() functoins.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the value was set sucessfully
+ * CY_AS_ERROR_INVALID_SIZE - the size value was not valid
+*/
+extern CyAsReturnStatus_t
+CyAsDmaSetMaxDmaSize(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint to change */
+ uint32_t size /* The max size of this endpoint in bytes */
+ ) ;
+
+/* Summary
+ This function starts the DMA process on a given channel.
+
+ Description
+ When transferring data from the P port processor to West Bridge, the DMA operation must be initiated
+ P Port software for the first transfer. Subsequent transferrs will be handled at the interrupt level.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+*/
+extern CyAsReturnStatus_t
+CyAsDmaKickStart(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep /* The endpoint to change */
+ ) ;
+
+/* Summary
+ This function receives endpoint data from a request.
+
+ Description
+ For endpoint 0 and 1 the endpoint data is transferred from the West Bridge device to the DMA via a lowlevel
+ requests (via the mailbox registers).
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+*/
+extern CyAsReturnStatus_t
+CyAsDmaReceivedData(
+ CyAsDevice * dev_p, /* The device of interest */
+ CyAsEndPointNumber_t ep, /* The endpoint that received data */
+ uint32_t dsize, /* The data size */
+ void * data /* The data buffer */
+ );
+
+/* Summary
+ This function is called when the DMA operation on an endpoint has been completed.
+
+ Returns
+ * void
+ */
+extern void
+CyAsDmaCompletedCallback (
+ CyAsHalDeviceTag tag, /* Tag to HAL completing the DMA operation. */
+ CyAsEndPointNumber_t ep, /* Endpoint on which DMA has been completed. */
+ uint32_t length, /* Length of data received. */
+ CyAsReturnStatus_t status /* Status of DMA operation. */
+ ) ;
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASDMA_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasintr.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,141 @@
+/* Cypress West Bridge API source file (cyasintr.c)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasdevice.h"
+#include "cyasregs.h"
+#include "cyaserr.h"
+
+extern void CyAsMailBoxInterruptHandler(CyAsDevice *) ;
+
+void
+CyAsMcuInterruptHandler(CyAsDevice *dev_p)
+{
+ /* Read and clear the interrupt. */
+ uint16_t v ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_MCU_STAT) ;
+ v = v ;
+}
+
+void
+CyAsPowerManagementInterruptHandler(CyAsDevice *dev_p)
+{
+ uint16_t v ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_PWR_MAGT_STAT) ;
+ v = v ;
+}
+
+void
+CyAsPllLockLossInterruptHandler(CyAsDevice *dev_p)
+{
+ uint16_t v ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_PLL_LOCK_LOSS_STAT) ;
+ v = v ;
+}
+
+uint32_t CyAsIntrStart(CyAsDevice *dev_p, CyBool dmaintr)
+{
+ uint16_t v ;
+
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ if (CyAsDeviceIsIntrRunning(dev_p) != 0)
+ return CY_AS_ERROR_ALREADY_RUNNING ;
+
+ v = CY_AS_MEM_P0_INT_MASK_REG_MMCUINT |
+ CY_AS_MEM_P0_INT_MASK_REG_MMBINT |
+ CY_AS_MEM_P0_INT_MASK_REG_MPMINT ;
+
+ if (dmaintr)
+ v |= CY_AS_MEM_P0_INT_MASK_REG_MDRQINT ;
+
+ /* Enable the interrupts of interest */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, v) ;
+
+ /* Mark the interrupt module as initialized */
+ CyAsDeviceSetIntrRunning(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+uint32_t CyAsIntrStop(CyAsDevice *dev_p)
+{
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ if (CyAsDeviceIsIntrRunning(dev_p) == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_INT_MASK_REG, 0) ;
+ CyAsDeviceSetIntrStopped(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+void CyAsIntrServiceInterrupt(CyAsHalDeviceTag tag)
+{
+ uint16_t v ;
+ CyAsDevice *dev_p ;
+
+ dev_p = CyAsDeviceFindFromTag(tag) ;
+
+ /*
+ Only power management interrupts can occur before the Antioch API setup is complete.
+ If this is a PM interrupt, handle it here; otherwise output a warning message.
+ */
+ if (dev_p == 0)
+ {
+ v = CyAsHalReadRegister(tag, CY_AS_MEM_P0_INTR_REG) ;
+ if (v == CY_AS_MEM_P0_INTR_REG_PMINT)
+ {
+ /* Read the PWR_MAGT_STAT register to clear this interrupt. */
+ v = CyAsHalReadRegister(tag, CY_AS_MEM_PWR_MAGT_STAT) ;
+ }
+ else
+ ;//CyAsHalPrintMessage("Stray Antioch interrupt detected, tag not associated with any created device.") ;
+ return ;
+ }
+
+ /* Make sure we got a valid object from CyAsDeviceFindFromTag */
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_INTR_REG) ;
+
+ if (v & CY_AS_MEM_P0_INTR_REG_MCUINT)
+ CyAsMcuInterruptHandler(dev_p) ;
+
+ if (v & CY_AS_MEM_P0_INTR_REG_PMINT)
+ CyAsPowerManagementInterruptHandler(dev_p) ;
+
+ if (v & CY_AS_MEM_P0_INTR_REG_PLLLOCKINT)
+ CyAsPllLockLossInterruptHandler(dev_p) ;
+
+ /* If the interrupt module is not running, no mailbox interrupts are expected
+ * from the Antioch. */
+ if (CyAsDeviceIsIntrRunning(dev_p) == 0)
+ return ;
+
+ if (v & CY_AS_MEM_P0_INTR_REG_MBINT)
+ CyAsMailBoxInterruptHandler(dev_p) ;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasintr.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,92 @@
+/* Cypress West Bridge API header file (cyasintr.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASINTR_H_
+#define _INCLUDED_CYASINTR_H_
+
+#include "cyasdevice.h"
+
+#include "cyas_cplus_start.h"
+
+/* Summary
+ Initialize the interrupt manager module
+
+ Description
+ This function is called to initialize the interrupt module. This module enables interrupts
+ as well as servies West Bridge related interrupts by determining the source of the interrupt and
+ calling the appropriate handler function.
+
+ Notes
+ If the dmaintr parameter is TRUE, the initialization code initializes the interrupt mask to
+ have the DMA related interrupt enabled via the general purpose interrupt. However, the interrupt
+ service function assumes that the DMA interrupt is handled by the HAL layer before the interrupt
+ module handler function is called.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the interrupt module was initialized correctly
+ * CY_AS_ERROR_ALREADY_RUNNING - the interrupt module was already started
+
+ See Also
+ * CyAsIntrStop
+ * CyAsServiceInterrupt
+*/
+extern CyAsReturnStatus_t
+CyAsIntrStart(
+ CyAsDevice * dev_p, /* Device being initialized */
+ CyBool dmaintr /* If true, enable the DMA interrupt through the INT signal */
+ ) ;
+
+/* Summary
+ Stop the interrupt manager module
+
+ Description
+ This function stops the interrupt module and masks all interrupts from the West Bridge device.
+
+ Returns
+ * CY_AS_ERROR_SUCCESS - the interrupt module was stopped sucessfully
+ * CY_AS_ERROR_NOT_RUNNING - the interrupt module was not running
+
+ See Also
+ * CyAsIntrStart
+ * CyAsServiceInterrupt
+*/
+extern CyAsReturnStatus_t
+CyAsIntrStop(
+ CyAsDevice * dev_p /* Device bein stopped */
+ ) ;
+
+
+/* Summary
+ The interrupt service routine for West Bridge
+
+ Description
+ When an interrupt is detected, this function is called to service the West Bridge interrupt. It is safe
+ and efficient for this function to be called when no West Bridge interrupt has occurred. This function
+ will determine it is not an West Bridge interrupt quickly and return.
+*/
+extern void CyAsIntrServiceInterrupt(
+ CyAsHalDeviceTag tag /* The USER supplied tag for this device */
+ ) ;
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASINTR_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyaslep2pep.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,337 @@
+/* Cypress West Bridge API source file (cyasusb.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasusb.h"
+#include "cyaserr.h"
+#include "cyaslowlevel.h"
+#include "cyasdma.h"
+
+typedef enum CyAsPhysicalEndpointState
+{
+ CyAsEPFree,
+ CyAsEPIn,
+ CyAsEPOut,
+ CyAsEPIsoIn,
+ CyAsEPIsoOut
+} CyAsPhysicalEndpointState;
+
+
+/*
+* This map is used to map an index between 1 and 10 to a logical endpoint number. This
+* is used to map LEP register indexes into actual EP numbers.
+*/
+static CyAsEndPointNumber_t EndPointMap[] = { 3, 5, 7, 9, 10, 11, 12, 13, 14, 15 } ;
+
+#define CY_AS_EPCFG_1024 (1 << 3)
+#define CY_AS_EPCFG_DBL (0x02)
+#define CY_AS_EPCFG_TRIPLE (0x03)
+#define CY_AS_EPCFG_QUAD (0x00)
+
+/*
+ * NB: This table contains the register values for PEP1 and PEP3. PEP2 and PEP4 only
+ * have a bit to change the direction of the PEP and therefre are not represented
+ * in this table.
+ */
+static uint8_t PepRegisterValues[12][4] =
+{
+ /* Bit 1:0 buffering, 0 = quad, 2 = double, 3 = triple */
+ /* Bit 3 size, 0 = 512, 1 = 1024 */
+ {
+ CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_DBL,
+ }, /* Config 1 - PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (2 * 512), PEP4 (2 * 512) */
+ {
+ CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_QUAD,
+ }, /* Config 2 - PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (4 * 512), PEP4 (N/A) */
+ {
+ CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_DBL | CY_AS_EPCFG_1024,
+ }, /* Config 3 - PEP1 (2 * 512), PEP2 (2 * 512), PEP3 (2 * 1024), PEP4(N/A) */
+ {
+ CY_AS_EPCFG_QUAD,
+ CY_AS_EPCFG_DBL,
+ }, /* Config 4 - PEP1 (4 * 512), PEP2 (N/A), PEP3 (2 * 512), PEP4 (2 * 512) */
+ {
+ CY_AS_EPCFG_QUAD,
+ CY_AS_EPCFG_QUAD,
+ }, /* Config 5 - PEP1 (4 * 512), PEP2 (N/A), PEP3 (4 * 512), PEP4 (N/A) */
+ {
+ CY_AS_EPCFG_QUAD,
+ CY_AS_EPCFG_1024 | CY_AS_EPCFG_DBL,
+ }, /* Config 6 - PEP1 (4 * 512), PEP2 (N/A), PEP3 (2 * 1024), PEP4 (N/A) */
+ {
+ CY_AS_EPCFG_1024 | CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_DBL,
+ }, /* Config 7 - PEP1 (2 * 1024), PEP2 (N/A), PEP3 (2 * 512), PEP4 (2 * 512) */
+ {
+ CY_AS_EPCFG_1024 | CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_QUAD,
+ }, /* Config 8 - PEP1 (2 * 1024), PEP2 (N/A), PEP3 (4 * 512), PEP4 (N/A) */
+ {
+ CY_AS_EPCFG_1024 | CY_AS_EPCFG_DBL,
+ CY_AS_EPCFG_1024 | CY_AS_EPCFG_DBL,
+ }, /* Config 9 - PEP1 (2 * 1024), PEP2 (N/A), PEP3 (2 * 1024), PEP4 (N/A)*/
+ {
+ CY_AS_EPCFG_TRIPLE,
+ CY_AS_EPCFG_TRIPLE,
+ }, /* Config 10 - PEP1 (3 * 512), PEP2 (N/A), PEP3 (3 * 512), PEP4 (2 * 512)*/
+ {
+ CY_AS_EPCFG_TRIPLE | CY_AS_EPCFG_1024,
+ CY_AS_EPCFG_DBL,
+ }, /* Config 11 - PEP1 (3 * 1024), PEP2 (N/A), PEP3 (N/A), PEP4 (2 * 512) */
+ {
+ CY_AS_EPCFG_QUAD | CY_AS_EPCFG_1024,
+ CY_AS_EPCFG_DBL,
+ }, /* Config 12 - PEP1 (4 * 1024), PEP2 (N/A), PEP3 (N/A), PEP4 (N/A) */
+} ;
+
+static CyAsReturnStatus_t
+FindEndpointDirections(CyAsDevice *dev_p, CyAsPhysicalEndpointState epstate[4])
+{
+ int i ;
+ CyAsPhysicalEndpointState desired ;
+
+ /*
+ * Note, there is no error checking here becuase ISO error checking happens when
+ * the API is called.
+ */
+ for(i = 0 ; i < 10 ; i++)
+ {
+ int epno = EndPointMap[i] ;
+ if (dev_p->usb_config[epno].enabled)
+ {
+ int pep = dev_p->usb_config[epno].physical ;
+ if (dev_p->usb_config[epno].type == CyAsUsbIso)
+ {
+ /*
+ * Marking this as an ISO endpoint, removes the physical EP from consideration when
+ * mapping the remaining EPs.
+ */
+ if (dev_p->usb_config[epno].dir == CyAsUsbIn)
+ desired = CyAsEPIsoIn ;
+ else
+ desired = CyAsEPIsoOut ;
+ }
+ else
+ {
+ if (dev_p->usb_config[epno].dir == CyAsUsbIn)
+ desired = CyAsEPIn ;
+ else
+ desired = CyAsEPOut ;
+ }
+
+ /* NB: Note the API calls insure that an ISO endpoint has a physical and logical
+ * EP number that are the same, therefore this condition is not enforced here.
+ */
+ if (epstate[pep - 1] != CyAsEPFree && epstate[pep - 1] != desired)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ epstate[pep - 1] = desired ;
+ }
+ }
+
+ /*
+ * Create the EP1 config values directly.
+ * Both EP1OUT and EP1IN are invalid by default.
+ */
+ dev_p->usb_ep1cfg[0] = 0 ;
+ dev_p->usb_ep1cfg[1] = 0 ;
+ if (dev_p->usb_config[1].enabled)
+ {
+ if ((dev_p->usb_config[1].dir == CyAsUsbOut) || (dev_p->usb_config[1].dir == CyAsUsbInOut))
+ {
+ /* Set the valid bit and type field. */
+ dev_p->usb_ep1cfg[0] = (1 << 7) ;
+ if (dev_p->usb_config[1].type == CyAsUsbBulk)
+ dev_p->usb_ep1cfg[0] |= (2 << 4) ;
+ else
+ dev_p->usb_ep1cfg[0] |= (3 << 4) ;
+ }
+
+ if ((dev_p->usb_config[1].dir == CyAsUsbIn) || (dev_p->usb_config[1].dir == CyAsUsbInOut))
+ {
+ /* Set the valid bit and type field. */
+ dev_p->usb_ep1cfg[1] = (1 << 7) ;
+ if (dev_p->usb_config[1].type == CyAsUsbBulk)
+ dev_p->usb_ep1cfg[1] |= (2 << 4) ;
+ else
+ dev_p->usb_ep1cfg[1] |= (3 << 4) ;
+ }
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+CreateRegisterSettings(CyAsDevice *dev_p, CyAsPhysicalEndpointState epstate[4])
+{
+ int i ;
+ uint8_t v ;
+
+ for(i = 0 ; i < 4 ; i++)
+ {
+ if (i == 0)
+ dev_p->usb_pepcfg[i] = PepRegisterValues[dev_p->usb_phy_config - 1][0] ; /* Start with the values that specify size */
+ else if (i == 2)
+ dev_p->usb_pepcfg[i] = PepRegisterValues[dev_p->usb_phy_config - 1][1] ; /* Start with the values that specify size */
+ else
+ dev_p->usb_pepcfg[i] = 0 ;
+
+ if (epstate[i] == CyAsEPIsoIn || epstate[i] == CyAsEPIn)
+ dev_p->usb_pepcfg[i] |= (1 << 6) ; /* Adjust direction if it is in */
+ }
+
+ /* Configure the logical EP registers */
+ for(i = 0 ; i < 10 ; i++)
+ {
+ int val ;
+ int epnum = EndPointMap[i] ;
+
+ v = 0x10 ; /* PEP 1, Bulk Endpoint, EP not valid */
+ if (dev_p->usb_config[epnum].enabled)
+ {
+ v |= (1 << 7) ; /* Enabled */
+
+ val = dev_p->usb_config[epnum].physical - 1 ;
+ CyAsHalAssert(val >= 0 && val <= 3) ;
+ v |= (val << 5) ;
+
+ switch(dev_p->usb_config[epnum].type)
+ {
+ case CyAsUsbBulk:
+ val = 2 ;
+ break ;
+ case CyAsUsbInt:
+ val = 3 ;
+ break ;
+ case CyAsUsbIso:
+ val = 1 ;
+ break ;
+ default:
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+ v |= (val << 3) ;
+ }
+
+ dev_p->usb_lepcfg[i] = v ;
+ }
+}
+
+
+CyAsReturnStatus_t
+CyAsUsbMapLogical2Physical(CyAsDevice *dev_p)
+{
+ CyAsReturnStatus_t ret ;
+
+ /* Physical EPs 3 5 7 9 respectively in the array */
+ CyAsPhysicalEndpointState epstate[4] = { CyAsEPFree, CyAsEPFree, CyAsEPFree, CyAsEPFree } ;
+
+ /* Find the direction for the endpoints */
+ ret = FindEndpointDirections(dev_p, epstate) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /*
+ * Now create the register settings based on the given assigned of logical EPs to
+ * physical endpoints.
+ */
+ CreateRegisterSettings(dev_p, epstate) ;
+
+ return ret ;
+}
+
+static uint16_t
+GetMaxDmaSize(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)
+{
+ uint16_t size = dev_p->usb_config[ep].size ;
+
+ if (size == 0)
+ {
+ switch(dev_p->usb_config[ep].type)
+ {
+ case CyAsUsbControl:
+ size = 64 ;
+ break ;
+
+ case CyAsUsbBulk:
+ size = CyAsDeviceIsUsbHighSpeed(dev_p) ? 512 : 64 ;
+ break ;
+
+ case CyAsUsbInt:
+ size = CyAsDeviceIsUsbHighSpeed(dev_p) ? 1024 : 64 ;
+ break ;
+
+ case CyAsUsbIso:
+ size = CyAsDeviceIsUsbHighSpeed(dev_p) ? 1024 : 1023 ;
+ break ;
+ }
+ }
+
+ return size ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetDmaSizes(CyAsDevice *dev_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint32_t i ;
+
+ for(i = 0 ; i < 10 ; i++)
+ {
+ CyAsUsbEndPointConfig *config_p = &dev_p->usb_config[EndPointMap[i]] ;
+ if (config_p->enabled)
+ {
+ ret = CyAsDmaSetMaxDmaSize(dev_p, EndPointMap[i], GetMaxDmaSize(dev_p, EndPointMap[i])) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ break ;
+ }
+ }
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetupDma(CyAsDevice *dev_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint32_t i ;
+
+ for(i = 0 ; i < 10 ; i++)
+ {
+ CyAsUsbEndPointConfig *config_p = &dev_p->usb_config[EndPointMap[i]] ;
+ if (config_p->enabled)
+ {
+ /* Map the endpoint direction to the DMA direction */
+ CyAsDmaDirection dir = CyAsDirectionOut ;
+ if (config_p->dir == CyAsUsbIn)
+ dir = CyAsDirectionIn ;
+
+ ret = CyAsDmaEnableEndPoint(dev_p, EndPointMap[i], CyTrue, dir) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ break ;
+ }
+ }
+
+ return ret ;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyaslep2pep.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,36 @@
+/* Cypress West Bridge API header file (cyaslep2pep.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASLEP2PEP_H_
+#define _INCLUDED_CYASLEP2PEP_H_
+
+#include "cyasdevice.h"
+
+extern CyAsReturnStatus_t
+CyAsUsbMapLogical2Physical(CyAsDevice *dev_p) ;
+
+extern CyAsReturnStatus_t
+CyAsUsbSetupDma(CyAsDevice *dev_p) ;
+
+extern CyAsReturnStatus_t
+CyAsUsbSetDmaSizes(CyAsDevice *dev_p) ;
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyaslowlevel.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1207 @@
+/* Cypress West Bridge API source file (cyaslowlevel.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyascast.h"
+#include "cyasdevice.h"
+#include "cyaslowlevel.h"
+#include "cyasintr.h"
+#include "cyaserr.h"
+#include "cyasregs.h"
+
+static const uint32_t CyAsLowLevelTimeoutCount = 65536 * 4 ;
+
+/* Forward declaration */
+static CyAsReturnStatus_t CyAsSendOne(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p) ;
+
+/*
+* This array holds the size of the largest request we will ever recevie from
+* the West Bridge device per context. The size is in 16 bit words. Note a size of
+* 0xffff indicates that there will be no requests on this context from West Bridge.
+*/
+static uint16_t MaxRequestLength[CY_RQT_CONTEXT_COUNT] =
+{
+ 8, /* CY_RQT_GENERAL_RQT_CONTEXT - CY_RQT_INITIALIZATION_COMPLETE */
+ 8, /* CY_RQT_RESOURCE_RQT_CONTEXT - none */
+ 8, /* CY_RQT_STORAGE_RQT_CONTEXT - CY_RQT_MEDIA_CHANGED */
+ 128, /* CY_RQT_USB_RQT_CONTEXT - CY_RQT_USB_EVENT */
+ 8 /* CY_RQT_TUR_RQT_CONTEXT - CY_RQT_TURBO_CMD_FROM_HOST */
+} ;
+
+/*
+* For the given context, this function removes the request node at the head of the
+* queue from the context. This is called after all processing has occurred on
+* the given request and response and we are ready to remove this entry from the
+* queue.
+*/
+static void
+CyAsLLRemoveRequestQueueHead(CyAsDevice *dev_p, CyAsContext *ctxt_p)
+{
+ uint32_t mask, state ;
+ CyAsLLRequestListNode *node_p ;
+
+ (void)dev_p ;
+ CyAsHalAssert(ctxt_p->request_queue_p != 0) ;
+
+ mask = CyAsHalDisableInterrupts() ;
+ node_p = ctxt_p->request_queue_p ;
+ ctxt_p->request_queue_p = node_p->next ;
+ CyAsHalEnableInterrupts(mask) ;
+
+ node_p->callback = 0 ;
+ node_p->rqt = 0 ;
+ node_p->resp = 0 ;
+
+ /*
+ * Note that the caller allocates and destroys the request and response. Generally the
+ * destroy happens in the callback for async requests and after the wait returns for
+ * sync. The request and response may not actually be destroyed but may be managed in other
+ * ways as well. It is the responsibilty of the caller to deal with these in any case. The
+ * caller can do this in the request/response callback function.
+ */
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node_p) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+/*
+* For the context given, this function sends the next request to
+* West Bridge via the mailbox register, if the next request is ready to
+* be sent and has not already been sent.
+*/
+static void
+CyAsLLSendNextRequest(CyAsDevice *dev_p, CyAsContext *ctxt_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ /*
+ * ret == ret is equivalent to while (1) but eliminates compiler warnings for
+ * some compilers.
+ */
+ while (ret == ret)
+ {
+ CyAsLLRequestListNode *node_p = ctxt_p->request_queue_p ;
+ if (node_p == 0)
+ break ;
+
+ if (CyAsRequestGetNodeState(node_p) != CY_AS_REQUEST_LIST_STATE_QUEUED)
+ break ;
+
+ CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_WAITING) ;
+ ret = CyAsSendOne(dev_p, node_p->rqt) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ break ;
+ }
+
+ /*
+ * If an error occurs in sending the request, tell the requester
+ * about the error and remove the request from the queue.
+ */
+ CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_RECEIVED) ;
+ node_p->callback(dev_p, ctxt_p->number, node_p->rqt, node_p->resp, ret) ;
+ CyAsLLRemoveRequestQueueHead(dev_p, ctxt_p) ;
+
+ /*
+ * This falls through to the while loop to send the next request since
+ * the previous request did not get sent.
+ */
+ }
+}
+
+/*
+* This method removes an entry from the request queue of a given context. The entry
+* is removed only if it is not in transit.
+*/
+CyAsRemoveRequestResult_t
+CyAsLLRemoveRequest(CyAsDevice *dev_p, CyAsContext *ctxt_p, CyAsLLRequestResponse *req_p, CyBool force)
+{
+ uint32_t imask ;
+ CyAsLLRequestListNode *node_p ;
+ CyAsLLRequestListNode *tmp_p ;
+ uint32_t state ;
+
+ imask = CyAsHalDisableInterrupts() ;
+ if (ctxt_p->request_queue_p != 0 && ctxt_p->request_queue_p->rqt == req_p)
+ {
+ node_p = ctxt_p->request_queue_p ;
+ if ((CyAsRequestGetNodeState(node_p) == CY_AS_REQUEST_LIST_STATE_WAITING) && (!force))
+ {
+ CyAsHalEnableInterrupts(imask) ;
+ return CyAsRemoveRequestInTransit ;
+ }
+
+ ctxt_p->request_queue_p = node_p->next ;
+ }
+ else
+ {
+ tmp_p = ctxt_p->request_queue_p ;
+ while (tmp_p != 0 && tmp_p->next != 0 && tmp_p->next->rqt != req_p)
+ tmp_p = tmp_p->next ;
+
+ if (tmp_p == 0 || tmp_p->next == 0)
+ {
+ CyAsHalEnableInterrupts(imask) ;
+ return CyAsRemoveRequestNotFound ;
+ }
+
+ node_p = tmp_p->next ;
+ tmp_p->next = node_p->next ;
+ }
+
+ if (node_p->callback)
+ node_p->callback(dev_p, ctxt_p->number, node_p->rqt, node_p->resp, CY_AS_ERROR_CANCELED) ;
+
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node_p) ;
+ CyAsHalEnableInterrupts(state) ;
+
+ CyAsHalEnableInterrupts(imask) ;
+ return CyAsRemoveRequestSucessful ;
+}
+
+void
+CyAsLLRemoveAllRequests(CyAsDevice *dev_p, CyAsContext *ctxt_p)
+{
+ CyAsLLRequestListNode *node = ctxt_p->request_queue_p ;
+
+ while(node)
+ {
+ if(CyAsRequestGetNodeState(ctxt_p->request_queue_p) != CY_AS_REQUEST_LIST_STATE_RECEIVED)
+ CyAsLLRemoveRequest(dev_p, ctxt_p, node->rqt, CyTrue) ;
+ node = node->next ;
+ }
+}
+
+static CyBool
+CyAsLLIsInQueue(CyAsContext *ctxt_p, CyAsLLRequestResponse *req_p)
+{
+ uint32_t mask ;
+ CyAsLLRequestListNode *node_p ;
+
+ mask = CyAsHalDisableInterrupts() ;
+ node_p = ctxt_p->request_queue_p ;
+ while (node_p)
+ {
+ if (node_p->rqt == req_p)
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CyTrue ;
+ }
+ node_p = node_p->next ;
+ }
+ CyAsHalEnableInterrupts(mask) ;
+ return CyFalse ;
+}
+
+/*
+* This is the handler for mailbox data when we are trying to send data to the West Bridge firmware. The
+* firmware may be trying to send us data and we need to queue this data to allow the firmware to move
+* forward and be in a state to receive our request. Here we just queue the data and it is processed
+* at a later time by the mailbox interrupt handler.
+*/
+void
+CyAsLLQueueMailboxData(CyAsDevice *dev_p)
+{
+ CyAsContext *ctxt_p ;
+ uint8_t context ;
+ uint16_t data[4] ;
+ int32_t i ;
+
+ /* Read the data from mailbox 0 to determine what to do with the data */
+ for(i = 3 ; i >= 0 ; i--)
+ data[i] = CyAsHalReadRegister(dev_p->tag, CyCastInt2UInt16(CY_AS_MEM_P0_MAILBOX0 + i)) ;
+
+ context = CyAsMboxGetContext(data[0]) ;
+ if (context >= CY_RQT_CONTEXT_COUNT)
+ {
+ CyAsHalPrintMessage("Mailbox request/response received with invalid context value (%d)\n", context) ;
+ return ;
+ }
+
+ ctxt_p = dev_p->context[context] ;
+
+ /*
+ * If we have queued too much data, drop future data.
+ */
+ CyAsHalAssert(ctxt_p->queue_index * sizeof(uint16_t) + sizeof(data) <= sizeof(ctxt_p->data_queue)) ;
+
+ for(i = 0 ; i < 4 ; i++)
+ ctxt_p->data_queue[ctxt_p->queue_index++] = data[i] ;
+
+ CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;
+ dev_p->ll_queued_data = CyTrue ;
+}
+
+void
+CyAsMailBoxProcessData(CyAsDevice *dev_p, uint16_t *data)
+{
+ CyAsContext *ctxt_p ;
+ uint8_t context ;
+ uint16_t *len_p ;
+ CyAsLLRequestResponse *rec_p ;
+ uint8_t st ;
+ uint16_t src, dest ;
+
+ context = CyAsMboxGetContext(data[0]) ;
+ if (context >= CY_RQT_CONTEXT_COUNT)
+ {
+ CyAsHalPrintMessage("Mailbox request/response received with invalid context value (%d)\n", context) ;
+ return ;
+ }
+
+ ctxt_p = dev_p->context[context] ;
+
+ if (CyAsMboxIsRequest(data[0]))
+ {
+ CyAsHalAssert(ctxt_p->req_p != 0) ;
+ rec_p = ctxt_p->req_p ;
+ len_p = &ctxt_p->request_length ;
+
+ }
+ else
+ {
+ if (ctxt_p->request_queue_p == 0 || CyAsRequestGetNodeState(ctxt_p->request_queue_p) != CY_AS_REQUEST_LIST_STATE_WAITING)
+ {
+ CyAsHalPrintMessage("Mailbox response received on context that was not expecting a response\n") ;
+ CyAsHalPrintMessage(" Context: %d\n", context) ;
+ CyAsHalPrintMessage(" Contents: 0x%04x 0x%04x 0x%04x 0x%04x\n", data[0], data[1], data[2], data[3]) ;
+ if (ctxt_p->request_queue_p != 0)
+ CyAsHalPrintMessage(" State: 0x%02x\n", ctxt_p->request_queue_p->state) ;
+ return ;
+ }
+
+ /* Make sure the request has an associated response */
+ CyAsHalAssert(ctxt_p->request_queue_p->resp != 0) ;
+
+ rec_p = ctxt_p->request_queue_p->resp ;
+ len_p = &ctxt_p->request_queue_p->length ;
+ }
+
+ if (rec_p->stored == 0)
+ {
+ /*
+ * This is the first cycle of the response
+ */
+ CyAsLLRequestResponse_SetCode(rec_p, CyAsMboxGetCode(data[0])) ;
+ CyAsLLRequestResponse_SetContext(rec_p, context) ;
+
+ if (CyAsMboxIsLast(data[0]))
+ {
+ /* This is a single cycle response */
+ *len_p = rec_p->length ;
+ st = 1 ;
+ }
+ else
+ {
+ /* Ensure that enough memory has been reserved for the response. */
+ CyAsHalAssert(rec_p->length >= data[1]) ;
+ *len_p = (data[1] < rec_p->length) ? data[1] : rec_p->length ;
+ st = 2 ;
+ }
+ }
+ else
+ st = 1 ;
+
+ /* Trasnfer the data from the mailboxes to the response */
+ while (rec_p->stored < *len_p && st < 4)
+ rec_p->data[rec_p->stored++] = data[st++] ;
+
+ if (CyAsMboxIsLast(data[0]))
+ {
+ /* NB: The call-back that is made below can cause the addition of more data
+ in this queue, thus causing a recursive overflow of the queue. This is prevented
+ by removing the request entry that is currently being passed up from the data
+ queue. If this is done, the queue only needs to be as long as two request
+ entries from West Bridge.
+ */
+ if ((ctxt_p->rqt_index > 0) && (ctxt_p->rqt_index <= ctxt_p->queue_index))
+ {
+ dest = 0 ;
+ src = ctxt_p->rqt_index ;
+
+ while (src < ctxt_p->queue_index)
+ ctxt_p->data_queue[dest++] = ctxt_p->data_queue[src++] ;
+
+ ctxt_p->rqt_index = 0 ;
+ ctxt_p->queue_index = dest ;
+ CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;
+ }
+
+ if (ctxt_p->request_queue_p != 0 && rec_p == ctxt_p->request_queue_p->resp)
+ {
+ /*
+ * If this is the last cycle of the response, call the callback and
+ * reset for the next response.
+ */
+ CyAsLLRequestResponse *resp_p = ctxt_p->request_queue_p->resp ;
+ resp_p->length = ctxt_p->request_queue_p->length ;
+ CyAsRequestSetNodeState(ctxt_p->request_queue_p, CY_AS_REQUEST_LIST_STATE_RECEIVED) ;
+
+ CyAsDeviceSetInCallback(dev_p) ;
+ ctxt_p->request_queue_p->callback(dev_p, context, ctxt_p->request_queue_p->rqt, resp_p, CY_AS_ERROR_SUCCESS) ;
+ CyAsDeviceClearInCallback(dev_p) ;
+
+ CyAsLLRemoveRequestQueueHead(dev_p, ctxt_p) ;
+ CyAsLLSendNextRequest(dev_p, ctxt_p) ;
+ }
+ else
+ {
+ /* Send the request to the appropriate module to handle */
+ CyAsLLRequestResponse *request_p = ctxt_p->req_p ;
+ ctxt_p->req_p = 0 ;
+ if (ctxt_p->request_callback)
+ {
+ CyAsDeviceSetInCallback(dev_p) ;
+ ctxt_p->request_callback(dev_p, context, request_p, 0, CY_AS_ERROR_SUCCESS) ;
+ CyAsDeviceClearInCallback(dev_p) ;
+ }
+ CyAsLLInitRequest(request_p, 0, context, request_p->length) ;
+ ctxt_p->req_p = request_p ;
+ }
+ }
+}
+
+/*
+* This is the handler for processing queued mailbox data
+*/
+void
+CyAsMailBoxQueuedDataHandler(CyAsDevice *dev_p)
+{
+ uint16_t i ;
+
+ /*
+ * If more data gets queued in between our entering this call and the
+ * end of the iteration on all contexts; we should continue processing the
+ * queued data.
+ */
+ while (dev_p->ll_queued_data)
+ {
+ dev_p->ll_queued_data = CyFalse ;
+ for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)
+ {
+ uint16_t offset ;
+ CyAsContext *ctxt_p = dev_p->context[i] ;
+ CyAsHalAssert((ctxt_p->queue_index % 4) == 0) ;
+
+ offset = 0 ;
+ while (offset < ctxt_p->queue_index)
+ {
+ ctxt_p->rqt_index = offset + 4 ;
+ CyAsMailBoxProcessData(dev_p, ctxt_p->data_queue + offset) ;
+ offset = ctxt_p->rqt_index ;
+ }
+ ctxt_p->queue_index = 0 ;
+ }
+ }
+}
+
+/*
+* This is the handler for the mailbox interrupt. This function reads data from the mailbox registers
+* until a complete request or response is received. When a complete request is received, the callback
+* associated with requests on that context is called. When a complete response is recevied, the callback
+* associated with the request that generated the reponse is called.
+*/
+void
+CyAsMailBoxInterruptHandler(CyAsDevice *dev_p)
+{
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ /*
+ * Queue the mailbox data to preserve order for later processing.
+ */
+ CyAsLLQueueMailboxData(dev_p) ;
+
+ /*
+ * Process what was queued and anything that may be pending
+ */
+ CyAsMailBoxQueuedDataHandler(dev_p) ;
+}
+
+CyAsReturnStatus_t
+CyAsLLStart(CyAsDevice *dev_p)
+{
+ uint16_t i ;
+
+ if (CyAsDeviceIsLowLevelRunning(dev_p))
+ return CY_AS_ERROR_ALREADY_RUNNING ;
+
+ dev_p->ll_sending_rqt = CyFalse ;
+ dev_p->ll_abort_curr_rqt = CyFalse ;
+
+ for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)
+ {
+ dev_p->context[i] = (CyAsContext *)CyAsHalAlloc(sizeof(CyAsContext)) ;
+ if (dev_p->context[i] == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ dev_p->context[i]->number = (uint8_t)i ;
+ dev_p->context[i]->request_callback = 0 ;
+ dev_p->context[i]->request_queue_p = 0 ;
+ dev_p->context[i]->last_node_p = 0 ;
+ dev_p->context[i]->req_p = CyAsLLCreateRequest(dev_p, 0, (uint8_t)i, MaxRequestLength[i]) ;
+ dev_p->context[i]->queue_index = 0 ;
+
+ if (!CyAsHalCreateSleepChannel(&dev_p->context[i]->channel))
+ return CY_AS_ERROR_CREATE_SLEEP_CHANNEL_FAILED ;
+ }
+
+ CyAsDeviceSetLowLevelRunning(dev_p) ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* Shutdown the low level communications module. This operation will also cancel any
+* queued low level requests.
+*/
+CyAsReturnStatus_t
+CyAsLLStop(CyAsDevice *dev_p)
+{
+ uint8_t i ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsContext *ctxt_p ;
+ uint32_t mask ;
+
+ for(i = 0 ; i < CY_RQT_CONTEXT_COUNT ; i++)
+ {
+ ctxt_p = dev_p->context[i] ;
+ if (!CyAsHalDestroySleepChannel(&ctxt_p->channel))
+ return CY_AS_ERROR_DESTROY_SLEEP_CHANNEL_FAILED ;
+
+ /*
+ * Now, free any queued requests and assocaited responses
+ */
+ while (ctxt_p->request_queue_p)
+ {
+ uint32_t state ;
+ CyAsLLRequestListNode *node_p = ctxt_p->request_queue_p ;
+
+ /* Mark this pair as in a cancel operation */
+ CyAsRequestSetNodeState(node_p, CY_AS_REQUEST_LIST_STATE_CANCELING) ;
+
+ /* Tell the caller that we are canceling this request */
+ /* NB: The callback is responsible for destroying the request and the
+ response. We cannot count on the contents of these two after
+ calling the callback.
+ */
+ node_p->callback(dev_p, i, node_p->rqt, node_p->resp, CY_AS_ERROR_CANCELED) ;
+
+ /* Remove the pair from the queue */
+ mask = CyAsHalDisableInterrupts() ;
+ ctxt_p->request_queue_p = node_p->next ;
+ CyAsHalEnableInterrupts(mask) ;
+
+ /* Free the list node */
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node_p) ;
+ CyAsHalEnableInterrupts(state) ;
+ }
+
+ CyAsLLDestroyRequest(dev_p, dev_p->context[i]->req_p) ;
+ CyAsHalFree(dev_p->context[i]) ;
+ dev_p->context[i] = 0 ;
+
+ }
+ CyAsDeviceSetLowLevelStopped(dev_p) ;
+
+ return ret ;
+}
+
+void
+CyAsLLInitRequest(CyAsLLRequestResponse *req_p, uint16_t code, uint16_t context, uint16_t length)
+{
+ uint16_t totallen = sizeof(CyAsLLRequestResponse) + (length - 1) * sizeof(uint16_t) ;
+
+ CyAsHalMemSet(req_p, 0, totallen) ;
+ req_p->length = length ;
+ CyAsLLRequestResponse_SetCode(req_p, code) ;
+ CyAsLLRequestResponse_SetContext(req_p, context) ;
+ CyAsLLRequestResponse_SetRequest(req_p) ;
+}
+
+/*
+* Create a new request.
+*/
+CyAsLLRequestResponse *
+CyAsLLCreateRequest(CyAsDevice *dev_p, uint16_t code, uint8_t context, uint16_t length)
+{
+ CyAsLLRequestResponse *req_p ;
+ uint32_t state ;
+ uint16_t totallen = sizeof(CyAsLLRequestResponse) + (length - 1) * sizeof(uint16_t) ;
+
+ (void)dev_p ;
+
+ state = CyAsHalDisableInterrupts() ;
+ req_p = (CyAsLLRequestResponse *)CyAsHalCBAlloc(totallen) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(req_p)
+ CyAsLLInitRequest(req_p, code, context, length) ;
+
+ return req_p ;
+}
+
+/*
+* Destroy a request.
+*/
+void
+CyAsLLDestroyRequest(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ uint32_t state ;
+ (void)dev_p ;
+ (void)req_p ;
+
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(req_p) ;
+ CyAsHalEnableInterrupts(state) ;
+
+}
+
+void
+CyAsLLInitResponse(CyAsLLRequestResponse *req_p, uint16_t length)
+{
+ uint16_t totallen = sizeof(CyAsLLRequestResponse) + (length - 1) * sizeof(uint16_t) ;
+
+ CyAsHalMemSet(req_p, 0, totallen) ;
+ req_p->length = length ;
+ CyAsLLRequestResponse_SetResponse(req_p) ;
+}
+
+/*
+* Create a new response
+*/
+CyAsLLRequestResponse *
+CyAsLLCreateResponse(CyAsDevice *dev_p, uint16_t length)
+{
+ CyAsLLRequestResponse *req_p ;
+ uint32_t state ;
+ uint16_t totallen = sizeof(CyAsLLRequestResponse) + (length - 1) * sizeof(uint16_t) ;
+
+ (void)dev_p ;
+
+ state = CyAsHalDisableInterrupts() ;
+ req_p = (CyAsLLRequestResponse *)CyAsHalCBAlloc(totallen) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(req_p)
+ CyAsLLInitResponse(req_p, length) ;
+
+ return req_p ;
+}
+
+/*
+* Destroy the new response
+*/
+void
+CyAsLLDestroyResponse(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ uint32_t state ;
+ (void)dev_p ;
+ (void)req_p ;
+
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(req_p) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+static uint16_t
+CyAsReadIntrStatus(
+ CyAsDevice *dev_p)
+{
+ uint32_t mask ;
+ CyBool bloop = CyTrue ;
+ uint16_t v = 0, last = 0xffff;
+
+ /*
+ * Before determining if the mailboxes are ready for more data, we first check the
+ * mailbox interrupt to see if we need to receive data. This prevents a dead-lock
+ * condition that can occur when both sides are trying to receive data.
+ */
+ while (last == last)
+ {
+ /*
+ * Disable interrupts to be sure we don't process the mailbox here and have the
+ * interrupt routine try to read this data as well.
+ */
+ mask = CyAsHalDisableInterrupts() ;
+
+ /*
+ * See if there is data to be read.
+ */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_INTR_REG) ;
+ if ((v & CY_AS_MEM_P0_INTR_REG_MBINT) == 0)
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ break ;
+ }
+
+ /*
+ * Queue the mailbox data for later processing. This allows the firmware to move
+ * forward and service the requst from the P port.
+ */
+ CyAsLLQueueMailboxData(dev_p) ;
+
+ /*
+ * Enable interrupts again to service mailbox interrupts appropriately
+ */
+ CyAsHalEnableInterrupts(mask) ;
+ }
+
+ /*
+ * Now, all data is received
+ */
+ last = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD ;
+ while (bloop)
+ {
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD ;
+ if (v == last)
+ break ;
+
+ last = v ;
+ }
+
+ return v ;
+}
+
+/*
+* Send a single request or response using the mail box register. This function does not deal
+* with the internal queues at all, but only sends the request or response across to the firmware
+*/
+static CyAsReturnStatus_t
+CyAsSendOne(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *req_p)
+{
+ int i ;
+ uint16_t mb0, v ;
+ int32_t loopcount ;
+ uint32_t intStat ;
+
+#ifdef _DEBUG
+ if (CyAsLLRequestResponse_IsRequest(req_p))
+ {
+ switch(CyAsLLRequestResponse_GetContext(req_p))
+ {
+ case CY_RQT_GENERAL_RQT_CONTEXT:
+ CyAsHalAssert(req_p->length * 2 + 2 < CY_CTX_GEN_MAX_DATA_SIZE) ;
+ break ;
+
+ case CY_RQT_RESOURCE_RQT_CONTEXT:
+ CyAsHalAssert(req_p->length * 2 + 2 < CY_CTX_RES_MAX_DATA_SIZE) ;
+ break ;
+
+ case CY_RQT_STORAGE_RQT_CONTEXT:
+ CyAsHalAssert(req_p->length * 2 + 2 < CY_CTX_STR_MAX_DATA_SIZE) ;
+ break ;
+
+ case CY_RQT_USB_RQT_CONTEXT:
+ CyAsHalAssert(req_p->length * 2 + 2 < CY_CTX_USB_MAX_DATA_SIZE) ;
+ break ;
+ }
+ }
+#endif
+
+ /* Write the request to the mail box registers */
+ if (req_p->length > 3)
+ {
+ uint16_t length = req_p->length ;
+ int which = 0 ;
+ int st = 1 ;
+
+ dev_p->ll_sending_rqt = CyTrue ;
+ while (which < length)
+ {
+ loopcount = CyAsLowLevelTimeoutCount ;
+ do
+ {
+ v = CyAsReadIntrStatus(dev_p) ;
+
+ } while (v && loopcount-- > 0) ;
+
+ if (v)
+ {
+ CyAsHalPrintMessage(">>>>>> LOW LEVEL TIMEOUT %x %x %x %x\n",
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX0),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX1),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX2),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX3)) ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+
+ if (dev_p->ll_abort_curr_rqt)
+ {
+ dev_p->ll_sending_rqt = CyFalse ;
+ dev_p->ll_abort_curr_rqt = CyFalse ;
+ return CY_AS_ERROR_CANCELED ;
+ }
+
+ intStat = CyAsHalDisableInterrupts () ;
+
+ /*
+ * Check again whether the mailbox is free. It is possible that an ISR came in
+ * and wrote into the mailboxes since we last checked the status.
+ */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD ;
+ if (v)
+ {
+ /* Go back to the original check since the mailbox is not free. */
+ CyAsHalEnableInterrupts(intStat) ;
+ continue ;
+ }
+
+ if (which == 0)
+ {
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX1, length) ;
+ st = 2 ;
+ }
+ else
+ {
+ st = 1;
+ }
+
+ while ((which < length) && (st < 4))
+ {
+ CyAsHalWriteRegister(dev_p->tag, CyCastInt2UInt16(CY_AS_MEM_MCU_MAILBOX0 + st), req_p->data[which++]) ;
+ st++ ;
+ }
+
+ mb0 = req_p->box0 ;
+ if (which == length)
+ {
+ dev_p->ll_sending_rqt = CyFalse ;
+ mb0 |= CY_AS_REQUEST_RESPONSE_LAST_MASK ;
+ }
+
+ if (dev_p->ll_abort_curr_rqt)
+ {
+ dev_p->ll_sending_rqt = CyFalse ;
+ dev_p->ll_abort_curr_rqt = CyFalse ;
+ CyAsHalEnableInterrupts (intStat) ;
+ return CY_AS_ERROR_CANCELED ;
+ }
+
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX0, mb0) ;
+
+ /* Wait for the MBOX interrupt to be high */
+ CyAsHalSleep150() ;
+ CyAsHalEnableInterrupts (intStat) ;
+ }
+ }
+ else
+ {
+CheckMailboxAvailability:
+ /*
+ * Wait for the mailbox registers to become available. This should be a very quick
+ * wait as the firmware is designed to accept requests at interrupt time and queue
+ * them for future processing.
+ */
+ loopcount = CyAsLowLevelTimeoutCount ;
+ do
+ {
+ v = CyAsReadIntrStatus(dev_p) ;
+
+ } while (v && loopcount-- > 0) ;
+
+ if (v)
+ {
+ CyAsHalPrintMessage(">>>>>> LOW LEVEL TIMEOUT %x %x %x %x\n",
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX0),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX1),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX2),
+ CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX3)) ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+
+ intStat = CyAsHalDisableInterrupts ();
+
+ /*
+ * Check again whether the mailbox is free. It is possible that an ISR came in
+ * and wrote into the mailboxes since we last checked the status.
+ */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_MCU_MB_STAT) & CY_AS_MEM_P0_MCU_MBNOTRD ;
+ if (v)
+ {
+ /* Go back to the original check since the mailbox is not free. */
+ CyAsHalEnableInterrupts(intStat) ;
+ goto CheckMailboxAvailability ;
+ }
+
+ /* Write the data associated with the request into the mbox registers 1 - 3 */
+ v = 0 ;
+ for(i = req_p->length - 1 ; i >= 0 ; i--)
+ CyAsHalWriteRegister(dev_p->tag, CyCastInt2UInt16(CY_AS_MEM_MCU_MAILBOX1 + i), req_p->data[i]) ;
+
+ /* Write the mbox register 0 to trigger the interrupt */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_MCU_MAILBOX0, req_p->box0 | CY_AS_REQUEST_RESPONSE_LAST_MASK) ;
+
+ CyAsHalSleep150() ;
+ CyAsHalEnableInterrupts (intStat);
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* This function queues a single request to be sent to the firmware.
+*/
+extern CyAsReturnStatus_t
+CyAsLLSendRequest(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *req, /* The request to send */
+ CyAsLLRequestResponse *resp, /* Storage for a reply, must be sure it is of sufficient size */
+ CyBool sync, /* If true, this is a synchronous request */
+ CyAsResponseCallback cb /* Callback to call when reply is received */
+ )
+{
+ CyAsContext *ctxt_p ;
+ uint16_t box0 = req->box0 ;
+ uint8_t context ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestListNode *node_p ;
+ uint32_t mask, state ;
+
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE);
+
+ context = CyAsMboxGetContext(box0) ;
+ CyAsHalAssert(context < CY_RQT_CONTEXT_COUNT) ;
+ ctxt_p = dev_p->context[context] ;
+
+ /* Allocate the list node */
+ state = CyAsHalDisableInterrupts() ;
+ node_p = (CyAsLLRequestListNode *)CyAsHalCBAlloc(sizeof(CyAsLLRequestListNode)) ;
+ CyAsHalEnableInterrupts(state) ;
+
+ if (node_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Initialize the list node */
+ node_p->callback = cb ;
+ node_p->length = 0 ;
+ node_p->next = 0 ;
+ node_p->resp = resp ;
+ node_p->rqt = req ;
+ node_p->state = CY_AS_REQUEST_LIST_STATE_QUEUED ;
+ if (sync)
+ CyAsRequestNodeSetSync(node_p) ;
+
+ /* Put the request into the queue */
+ mask = CyAsHalDisableInterrupts() ;
+ if (ctxt_p->request_queue_p == 0)
+ {
+ /* Empty queue */
+ ctxt_p->request_queue_p = node_p ;
+ ctxt_p->last_node_p = node_p ;
+ }
+ else
+ {
+ ctxt_p->last_node_p->next = node_p ;
+ ctxt_p->last_node_p = node_p ;
+ }
+ CyAsHalEnableInterrupts(mask) ;
+ CyAsLLSendNextRequest(dev_p, ctxt_p) ;
+
+ if (!CyAsDeviceIsInCallback(dev_p))
+ {
+ mask = CyAsHalDisableInterrupts() ;
+ CyAsMailBoxQueuedDataHandler(dev_p) ;
+ CyAsHalEnableInterrupts(mask) ;
+ }
+
+ return ret ;
+}
+
+static void
+CyAsLLSendCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ (void)rqt ;
+ (void)resp ;
+ (void)ret ;
+
+
+ CyAsHalAssert(dev_p->sig == CY_AS_DEVICE_HANDLE_SIGNATURE) ;
+
+ /*
+ * Storage the state to return to the caller
+ */
+ dev_p->ll_error = ret ;
+
+ /*
+ * Now wake the caller
+ */
+ CyAsHalWake(&dev_p->context[context]->channel) ;
+}
+
+CyAsReturnStatus_t
+CyAsLLSendRequestWaitReply(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *req, /* The request to send */
+ CyAsLLRequestResponse *resp /* Storage for a reply, must be sure it is of sufficient size */
+ )
+{
+ CyAsReturnStatus_t ret ;
+ uint8_t context ;
+ uint32_t loopcount = 800 ; /* Larger 8 sec time-out to handle the init delay for slower storage devices in USB FS. */
+ CyAsContext *ctxt_p ;
+
+ /* Get the context for the request */
+ context = CyAsLLRequestResponse_GetContext(req) ;
+ CyAsHalAssert(context < CY_RQT_CONTEXT_COUNT) ;
+ ctxt_p = dev_p->context[context] ;
+
+ ret = CyAsLLSendRequest(dev_p, req, resp, CyTrue, CyAsLLSendCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ while (loopcount-- > 0)
+ {
+ /*
+ * Sleep while we wait on the response. Receiving the reply will
+ * wake this thread. We will wait, at most 2 seconds (10 ms * 200
+ * tries) before we timeout. Note if the reply arrives, we will not
+ * sleep the entire 10 ms, just til the reply arrives.
+ */
+ CyAsHalSleepOn(&ctxt_p->channel, 10) ;
+
+ /*
+ * If the request has left the queue, it means the request has been sent
+ * and the reply has been received. This means we can return to the caller
+ * and be sure the reply has been received.
+ */
+ if (!CyAsLLIsInQueue(ctxt_p, req))
+ return dev_p->ll_error ;
+ }
+
+ /* Remove the QueueListNode for this request. */
+ CyAsLLRemoveRequest(dev_p, ctxt_p, req, CyTrue) ;
+
+ return CY_AS_ERROR_TIMEOUT ;
+}
+
+CyAsReturnStatus_t
+CyAsLLRegisterRequestCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsResponseCallback cb)
+{
+ CyAsContext *ctxt_p ;
+ CyAsHalAssert(context < CY_RQT_CONTEXT_COUNT) ;
+ ctxt_p = dev_p->context[context] ;
+
+ ctxt_p->request_callback = cb ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+void
+CyAsLLRequestResponse_Pack(
+ CyAsLLRequestResponse *req_p,
+ uint32_t offset,
+ uint32_t length,
+ void *data_p)
+{
+ uint16_t dt ;
+ uint8_t *dp = (uint8_t *)data_p ;
+
+ while (length > 1)
+ {
+ dt = ((*dp++) << 8) ;
+ dt |= (*dp++) ;
+ CyAsLLRequestResponse_SetWord(req_p, offset, dt) ;
+ offset++ ;
+ length -= 2 ;
+ }
+
+ if (length == 1)
+ {
+ dt = (*dp << 8) ;
+ CyAsLLRequestResponse_SetWord(req_p, offset, dt) ;
+ }
+}
+
+void
+CyAsLLRequestResponse_Unpack(
+ CyAsLLRequestResponse *req_p,
+ uint32_t offset,
+ uint32_t length,
+ void *data_p)
+{
+ uint8_t *dp = (uint8_t *)data_p ;
+
+ while (length-- > 0)
+ {
+ uint16_t val = CyAsLLRequestResponse_GetWord(req_p, offset++) ;
+ *dp++ = (uint8_t)((val >> 8) & 0xff) ;
+
+ if (length)
+ {
+ length-- ;
+ *dp++ = (uint8_t)(val & 0xff) ;
+ }
+ }
+}
+
+extern CyAsReturnStatus_t
+CyAsLLSendStatusResponse(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ uint16_t code,
+ uint8_t clear_storage)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse resp ;
+ CyAsLLRequestResponse *resp_p = &resp ;
+
+ CyAsHalMemSet(resp_p, 0, sizeof(resp)) ;
+ resp_p->length = 1 ;
+ CyAsLLRequestResponse_SetResponse(resp_p) ;
+ CyAsLLRequestResponse_SetContext(resp_p, context) ;
+
+ if (clear_storage)
+ CyAsLLRequestResponse_SetClearStorageFlag(resp_p) ;
+
+ CyAsLLRequestResponse_SetCode(resp_p, CY_RESP_SUCCESS_FAILURE) ;
+ CyAsLLRequestResponse_SetWord(resp_p, 0, code) ;
+
+ ret = CyAsSendOne(dev_p, resp_p) ;
+
+ return ret ;
+}
+
+extern CyAsReturnStatus_t
+CyAsLLSendDataResponse(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ uint16_t code,
+ uint16_t length,
+ void *data)
+{
+ CyAsLLRequestResponse *resp_p ;
+ uint16_t wlen ;
+ uint8_t respbuf[256] ;
+
+ if (length > 192)
+ return CY_AS_ERROR_INVALID_SIZE ;
+
+ wlen = length / 2 ; /* Word length for bytes */
+ if (length % 2) /* If byte length odd, add one more */
+ wlen++ ;
+ wlen++ ; /* One for the length of field */
+
+ resp_p = (CyAsLLRequestResponse *)respbuf ;
+ CyAsHalMemSet(resp_p, 0, sizeof(respbuf)) ;
+ resp_p->length = wlen ;
+ CyAsLLRequestResponse_SetContext(resp_p, context) ;
+ CyAsLLRequestResponse_SetCode(resp_p, code) ;
+
+ CyAsLLRequestResponse_SetWord(resp_p, 0, length) ;
+ CyAsLLRequestResponse_Pack(resp_p, 1, length, data) ;
+
+ return CyAsSendOne(dev_p, resp_p) ;
+}
+
+static CyBool
+CyAsLLIsEPTransferRelatedRequest(CyAsLLRequestResponse *rqt_p, CyAsEndPointNumber_t ep)
+{
+ uint16_t v ;
+ uint8_t type = CyAsLLRequestResponse_GetCode(rqt_p) ;
+
+ if (CyAsLLRequestResponse_GetContext(rqt_p) != CY_RQT_USB_RQT_CONTEXT)
+ return CyFalse ;
+
+ /*
+ * When cancelling outstanding EP0 data transfers, any pending
+ * Setup ACK requests also need to be cancelled.
+ */
+ if ((ep == 0) && (type == CY_RQT_ACK_SETUP_PACKET))
+ return CyTrue ;
+
+ if (type != CY_RQT_USB_EP_DATA)
+ return CyFalse ;
+
+ v = CyAsLLRequestResponse_GetWord(rqt_p, 0) ;
+ if ((CyAsEndPointNumber_t)((v >> 13) & 1) != ep)
+ return CyFalse ;
+
+ return CyTrue ;
+}
+
+CyAsReturnStatus_t
+CyAsLLRemoveEpDataRequests(CyAsDevice *dev_p, CyAsEndPointNumber_t ep)
+{
+ CyAsContext *ctxt_p ;
+ CyAsLLRequestListNode *node_p ;
+ uint32_t imask ;
+
+ /*
+ * First, remove any queued requests
+ */
+ ctxt_p = dev_p->context[CY_RQT_USB_RQT_CONTEXT] ;
+ if (ctxt_p)
+ {
+ for(node_p = ctxt_p->request_queue_p ; node_p ; node_p = node_p->next)
+ {
+ if (CyAsLLIsEPTransferRelatedRequest(node_p->rqt, ep))
+ {
+ CyAsLLRemoveRequest(dev_p, ctxt_p, node_p->rqt, CyFalse) ;
+ break ;
+ }
+ }
+
+ /*
+ * Now, deal with any request that may be in transit
+ */
+ imask = CyAsHalDisableInterrupts() ;
+
+ if (ctxt_p->request_queue_p != 0 &&
+ CyAsLLIsEPTransferRelatedRequest(ctxt_p->request_queue_p->rqt, ep) &&
+ CyAsRequestGetNodeState(ctxt_p->request_queue_p) == CY_AS_REQUEST_LIST_STATE_WAITING)
+ {
+ CyAsHalPrintMessage("Need to remove an in-transit request to Antioch\n") ;
+
+ /*
+ * If the request has not been fully sent to West Bridge yet, abort sending.
+ * Otherwise, terminate the request with a CANCELED status. Firmware will
+ * already have terminated this transfer.
+ */
+ if (dev_p->ll_sending_rqt)
+ dev_p->ll_abort_curr_rqt = CyTrue ;
+ else
+ {
+ uint32_t state ;
+
+ node_p = ctxt_p->request_queue_p ;
+ if (node_p->callback)
+ node_p->callback(dev_p, ctxt_p->number, node_p->rqt, node_p->resp, CY_AS_ERROR_CANCELED) ;
+
+ ctxt_p->request_queue_p = node_p->next ;
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node_p) ;
+ CyAsHalEnableInterrupts(state) ;
+ }
+ }
+
+ CyAsHalEnableInterrupts(imask) ;
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyaslowlevel.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,306 @@
+/* Cypress West Bridge API header file (cyaslowlevel.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASLOWLEVEL_H_
+#define _INCLUDED_CYASLOWLEVEL_H_
+
+/*@@Low Level Communications
+
+ Summary
+ The low level communications module is responsible for communications between
+ the West Bridge device and the P port processor. Communications is organized as
+ a series of requests and subsequent responses. For each request there is a
+ one and only one response. Requests may go from the West Bridge device to the P port
+ processor, or from the P Port processor to the West Bridge device.
+
+ Description
+ Requests are issued across what is called a context. A context is a single
+ channel of communications from one processor to another processor. There can
+ be only a single request outstanding on a context at a given time. Contexts
+ are used to identify subsystems that can only process a single request at a
+ time, but are independent of other contexts in the system. For instance, there
+ is a context for communicating storage commands from the P port processor to the
+ West Bridge device. There is also a context for communicating USB commands from
+ the P port processor to the West Bridge device.
+
+ Requests and responses are identical with the exception of the type bit in the
+ request/response header. If the type bit is one, the packet is a request. If
+ this bit is zero, the packet is a response. Also encoded within the header of
+ the request/response is the code. The code is a command code for a request, or
+ a response code for a response. For a request, the code is a function of the
+ context. The code 0 has one meaning for the storage context and a different
+ meaning for the USB context. The code is treated differently in the response.
+ If the code in the response is less than 16, then the meaning of the response is
+ global across all contexts. If the response is greater than or equal to 16,
+ then the response is specific to the associated context.
+
+ Requests and responses are transferred between processors through the mailbox
+ registers. It may take one or more cycles to transmit a complete request or
+ response. The context is encoded into each cycle of the transfer to insure the
+ receiving processor can route the data to the appropriate context for processing.
+ In this way, the traffic from multiple contexts can be multiplexed into a single
+ data stream through the mailbox registers by the sending processor, and
+ demultiplexed from the mailbox registers by the receiving processor.
+
+ * Firmware Assumptions *
+ The firmware assumes that mailbox contents will be consumed immediately. Therefore
+ for multi-cycle packets, the data is sent in a tight polling loop from the firmware.
+ This implies that the data must be read from the mailbox register on the P port side
+ and processed immediately or performance of the firmware will suffer. In order to
+ insure this is the case, the data from the mailboxes is read and stored immediately
+ in a per context buffer. This occurs until the entire packet is received at which
+ time the request packet is processed. Since the protocol is designed to allow for
+ only one outstanding packet at a time, the firmware can never be in a position of
+ waiting on the mailbox registers while the P port is processing a request. Only after
+ the response to the previous request is sent will another request be sent.
+*/
+
+#include "cyashal.h"
+#include "cyasdevice.h"
+
+#include "cyas_cplus_start.h"
+
+/*
+ * Constants
+ */
+#define CY_AS_REQUEST_RESPONSE_CODE_MASK (0x00ff)
+#define CY_AS_REQUEST_RESPONSE_CONTEXT_MASK (0x0F00)
+#define CY_AS_REQUEST_RESPONSE_CONTEXT_SHIFT (8)
+#define CY_AS_REQUEST_RESPONSE_TYPE_MASK (0x4000)
+#define CY_AS_REQUEST_RESPONSE_LAST_MASK (0x8000)
+#define CY_AS_REQUEST_RESPONSE_CLEAR_STR_FLAG (0x1000)
+
+/*
+ * These macros extract the data from a 16 bit value
+ */
+#define CyAsMboxGetCode(c) ((uint8_t)((c) & CY_AS_REQUEST_RESPONSE_CODE_MASK))
+#define CyAsMboxGetContext(c) ((uint8_t)(((c) & CY_AS_REQUEST_RESPONSE_CONTEXT_MASK) >> CY_AS_REQUEST_RESPONSE_CONTEXT_SHIFT))
+#define CyAsMboxIsLast(c) ((c) & CY_AS_REQUEST_RESPONSE_LAST_MASK)
+#define CyAsMboxIsRequest(c) (((c) & CY_AS_REQUEST_RESPONSE_TYPE_MASK) != 0)
+#define CyAsMboxIsResponse(c) (((c) & CY_AS_REQUEST_RESPONSE_TYPE_MASK) == 0)
+
+/*
+ * These macros (not yet written) pack data into or extract data
+ * from the m_box0 field of the request or response
+ */
+#define CyAsLLRequestResponse_SetCode(req, code) \
+ ((req)->box0 = ((req)->box0 & ~CY_AS_REQUEST_RESPONSE_CODE_MASK) | \
+ (code & CY_AS_REQUEST_RESPONSE_CODE_MASK))
+
+#define CyAsLLRequestResponse_GetCode(req) CyAsMboxGetCode((req)->box0)
+
+#define CyAsLLRequestResponse_SetContext(req, context) \
+ ((req)->box0 |= ((context) << CY_AS_REQUEST_RESPONSE_CONTEXT_SHIFT))
+
+#define CyAsLLRequestResponse_SetClearStorageFlag(req) \
+ ((req)->box0 |= CY_AS_REQUEST_RESPONSE_CLEAR_STR_FLAG)
+
+#define CyAsLLRequestResponse_GetContext(req) CyAsMboxGetContext((req)->box0)
+
+#define CyAsLLRequestResponse_IsLast(req) CyAsMboxIsLast((req)->box0)
+
+#define CYAnLLRequestResponse__SetLast(req) \
+ ((req)->box0 |= CY_AS_REQUEST_RESPONSE_LAST_MASK)
+
+#define CyAsLLRequestResponse_IsRequest(req) CyAsMboxIsRequest((req)->box0)
+
+#define CyAsLLRequestResponse_SetRequest(req) \
+ ((req)->box0 |= CY_AS_REQUEST_RESPONSE_TYPE_MASK)
+
+#define CyAsLLRequestResponse_SetResponse(req) \
+ ((req)->box0 &= ~CY_AS_REQUEST_RESPONSE_TYPE_MASK)
+
+#define CyAsLLRequestResponse_IsResponse(req) CyAsMboxIsResponse((req)->box0)
+
+#define CyAsLLRequestResponse_GetWord(req, offset) ((req)->data[(offset)])
+
+#define CyAsLLRequestResponse_SetWord(req, offset, value) ((req)->data[(offset)] = value)
+
+typedef enum CyAsRemoveRequestResult_t
+{
+ CyAsRemoveRequestSucessful,
+ CyAsRemoveRequestInTransit,
+ CyAsRemoveRequestNotFound
+} CyAsRemoveRequestResult_t ;
+
+/* Summary
+ Start the low level communications module
+
+ Description
+*/
+CyAsReturnStatus_t
+CyAsLLStart(
+ CyAsDevice *dev_p
+ ) ;
+
+CyAsReturnStatus_t
+CyAsLLStop(
+ CyAsDevice *dev_p
+ ) ;
+
+
+CyAsLLRequestResponse *
+CyAsLLCreateRequest(
+ CyAsDevice *dev_p,
+ uint16_t code,
+ uint8_t context,
+ uint16_t length /* Length of the request in 16 bit words */
+ ) ;
+
+void
+CyAsLLInitRequest(
+ CyAsLLRequestResponse *req_p,
+ uint16_t code,
+ uint16_t context,
+ uint16_t length) ;
+
+void
+CyAsLLInitResponse(
+ CyAsLLRequestResponse *req_p,
+ uint16_t length) ;
+
+void
+CyAsLLDestroyRequest(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *) ;
+
+CyAsLLRequestResponse *
+CyAsLLCreateResponse(
+ CyAsDevice *dev_p,
+ uint16_t length /* Length of the request in 16 bit words */
+ ) ;
+
+CyAsRemoveRequestResult_t
+CyAsLLRemoveRequest(
+ CyAsDevice *dev_p,
+ CyAsContext *ctxt_p,
+ CyAsLLRequestResponse *req_p,
+ CyBool force
+ ) ;
+void
+CyAsLLRemoveAllRequests(CyAsDevice *dev_p,
+ CyAsContext *ctxt_p) ;
+
+void
+CyAsLLDestroyResponse(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *) ;
+
+CyAsReturnStatus_t
+CyAsLLSendRequest(
+ CyAsDevice * dev_p, /* The West Bridge device */
+ CyAsLLRequestResponse * req, /* The request to send */
+ CyAsLLRequestResponse * resp, /* Storage for a reply, must be sure it is of sufficient size */
+ CyBool sync, /* If true, this is a sync request */
+ CyAsResponseCallback cb /* Callback to call when reply is received */
+) ;
+
+CyAsReturnStatus_t
+CyAsLLSendRequestWaitReply(
+ CyAsDevice * dev_p, /* The West Bridge device */
+ CyAsLLRequestResponse * req, /* The request to send */
+ CyAsLLRequestResponse * resp /* Storage for a reply, must be sure it is of sufficient size */
+) ;
+
+/* Summary
+ This function registers a callback function to be called when a request arrives on a given
+ context.
+
+ Description
+
+ Returns
+ * CY_AS_ERROR_SUCCESS
+*/
+extern CyAsReturnStatus_t
+CyAsLLRegisterRequestCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsResponseCallback cb
+ ) ;
+
+/* Summary
+ This function packs a set of bytes given by the data_p pointer into a request, reply
+ structure.
+*/
+extern void
+CyAsLLRequestResponse_Pack(
+ CyAsLLRequestResponse *req, /* The destintation request or response */
+ uint32_t offset, /* The offset of where to pack the data */
+ uint32_t length, /* The length of the data to pack in bytes */
+ void *data_p /* The data to pack */
+ ) ;
+
+/* Summary
+ This function unpacks a set of bytes from a request/reply structure into a segment of memory given
+ by the data_p pointer.
+*/
+extern void
+CyAsLLRequestResponse_Unpack(
+ CyAsLLRequestResponse *req, /* The source of the data to unpack */
+ uint32_t offset, /* The offset of the data to unpack */
+ uint32_t length, /* The length of the data to unpack in bytes */
+ void *data_p /* The destination of the unpack operation */
+ ) ;
+
+/* Summary
+ This function sends a status response back to the West Bridge device in response to a
+ previously send request
+*/
+extern CyAsReturnStatus_t
+CyAsLLSendStatusResponse(
+ CyAsDevice *dev_p, /* The West Bridge device */
+ uint8_t context, /* The context to send the response on */
+ uint16_t code, /* The success/failure code to send */
+ uint8_t clear_storage) ; /* Flag to clear wait on storage context */
+
+/* Summary
+ This function sends a response back to the West Bridge device.
+
+ Description
+ This function sends a response back to the West Bridge device. The response is sent on the
+ context given by the 'context' variable. The code for the response is given by the 'code'
+ argument. The data for the response is given by the data and length arguments.
+*/
+extern CyAsReturnStatus_t
+CyAsLLSendDataResponse(
+ CyAsDevice *dev_p, /* The West Bridge device */
+ uint8_t context, /* The context to send the response on */
+ uint16_t code, /* The response code to use */
+ uint16_t length, /* The length of the data for the response */
+ void *data /* The data for the response */
+) ;
+
+/* Summary
+ This function removes any requests of the given type from the given context.
+
+ Description
+ This function removes requests of a given type from the context given via the
+ context number.
+*/
+extern CyAsReturnStatus_t
+CyAsLLRemoveEpDataRequests(
+ CyAsDevice *dev_p, /* The West Bridge device */
+ CyAsEndPointNumber_t ep
+ ) ;
+
+#include "cyas_cplus_end.h"
+
+#endif /* _INCLUDED_CYASLOWLEVEL_H_ */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasmisc.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,3359 @@
+/* Cypress West Bridge API source file (cyasmisc.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasmisc.h"
+#include "cyasdma.h"
+#include "cyasintr.h"
+#include "cyaserr.h"
+#include "cyasregs.h"
+#include "cyaslowlevel.h"
+#include "cyasprotocol.h"
+
+/*
+* The device list, the only global in the API
+*/
+static CyAsDevice *gDeviceList = 0 ;
+
+/*
+ * The current debug level
+ */
+static uint8_t DebugLevel = 0 ;
+
+/*
+ * This function sets the debug level for the API
+ *
+ */
+void
+CyAsMiscSetLogLevel(uint8_t level)
+{
+ DebugLevel = level ;
+}
+
+#ifdef CY_AS_LOG_SUPPORT
+
+/*
+ * This function is a low level logger for the API.
+ */
+void
+CyAsLogDebugMessage(int level, const char *str)
+{
+ if (level <= DebugLevel)
+ CyAsHalPrintMessage("Log %d: %s\n", level, str) ;
+}
+
+#endif
+
+#define CyAsCheckDeviceReady(dev_p) \
+{ \
+ if (!(dev_p) ||((dev_p)->sig != CY_AS_DEVICE_HANDLE_SIGNATURE)) \
+ return CY_AS_ERROR_INVALID_HANDLE ; \
+ \
+ if (!CyAsDeviceIsConfigured(dev_p)) \
+ return CY_AS_ERROR_NOT_CONFIGURED ; \
+ \
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p)) \
+ return CY_AS_ERROR_NO_FIRMWARE ; \
+}
+
+/* Find an West Bridge device based on a TAG */
+CyAsDevice *
+CyAsDeviceFindFromTag(CyAsHalDeviceTag tag)
+{
+ CyAsDevice *dev_p ;
+
+ for(dev_p = gDeviceList; dev_p != 0; dev_p = dev_p->next_p)
+ {
+ if (dev_p->tag == tag)
+ return dev_p ;
+ }
+
+ return 0 ;
+}
+
+/* Map a pre-V1.2 media type to the V1.2+ bus number */
+static void
+CyAsBusFromMediaType(CyAsMediaType type,
+ CyAsBusNumber_t* bus)
+{
+ if (type == CyAsMediaNand)
+ {
+ *bus = 0 ;
+ }
+ else
+ {
+ *bus = 1 ;
+ }
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseNoData(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+* Create a new West Bridge device
+*/
+CyAsReturnStatus_t
+CyAsMiscCreateDevice(CyAsDeviceHandle *handle_p, CyAsHalDeviceTag tag)
+{
+ CyAsDevice *dev_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscCreateDevice called") ;
+
+ dev_p = (CyAsDevice *)CyAsHalAlloc(sizeof(CyAsDevice)) ;
+ if (dev_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ CyAsHalMemSet(dev_p, 0, sizeof(CyAsDevice)) ;
+
+ /*
+ * Dynamically allocating this buffer to ensure that it is
+ * word aligned.
+ */
+ dev_p->usb_ep_data = (uint8_t *)CyAsHalAlloc(64 * sizeof(uint8_t)) ;
+ if (dev_p->usb_ep_data == 0)
+ {
+ CyAsHalFree(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ dev_p->sig = CY_AS_DEVICE_HANDLE_SIGNATURE ;
+ dev_p->tag = tag ;
+ dev_p->usb_max_tx_size = 0x40 ;
+
+ dev_p->storage_write_endpoint = CY_AS_P2S_WRITE_ENDPOINT ;
+ dev_p->storage_read_endpoint = CY_AS_P2S_READ_ENDPOINT ;
+
+ dev_p->func_cbs_misc = CyAsCreateCBQueue(CYAS_FUNC_CB) ;
+ if(dev_p->func_cbs_misc == 0)
+ goto destroy ;
+
+ dev_p->func_cbs_res = CyAsCreateCBQueue(CYAS_FUNC_CB) ;
+ if(dev_p->func_cbs_res == 0)
+ goto destroy ;
+
+ dev_p->func_cbs_stor = CyAsCreateCBQueue(CYAS_FUNC_CB) ;
+ if(dev_p->func_cbs_stor == 0)
+ goto destroy ;
+
+ dev_p->func_cbs_usb = CyAsCreateCBQueue(CYAS_FUNC_CB) ;
+ if(dev_p->func_cbs_usb == 0)
+ goto destroy ;
+
+ dev_p->func_cbs_mtp = CyAsCreateCBQueue(CYAS_FUNC_CB) ;
+ if(dev_p->func_cbs_mtp == 0)
+ goto destroy ;
+
+ /*
+ * Allocate memory for the DMA module here. It is then marked idle, and
+ * will be activated when CyAsMiscConfigureDevice is called.
+ */
+ ret = CyAsDmaStart(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ CyAsDeviceSetDmaStopped(dev_p) ;
+
+ /*
+ * Allocate memory for the low level module here. This module is also
+ * activated only when CyAsMiscConfigureDevice is called.
+ */
+ ret = CyAsLLStart(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ CyAsDeviceSetLowLevelStopped(dev_p) ;
+
+ dev_p->next_p = gDeviceList ;
+ gDeviceList = dev_p ;
+
+ *handle_p = dev_p ;
+ CyAsHalInitDevRegisters(tag, CyFalse) ;
+ return CY_AS_ERROR_SUCCESS ;
+
+destroy:
+ /* Free any queues that were successfully allocated. */
+ if (dev_p->func_cbs_misc) CyAsDestroyCBQueue(dev_p->func_cbs_misc) ;
+ if (dev_p->func_cbs_res) CyAsDestroyCBQueue(dev_p->func_cbs_res) ;
+ if (dev_p->func_cbs_stor) CyAsDestroyCBQueue(dev_p->func_cbs_stor) ;
+ if (dev_p->func_cbs_usb) CyAsDestroyCBQueue(dev_p->func_cbs_usb) ;
+ if (dev_p->func_cbs_mtp) CyAsDestroyCBQueue(dev_p->func_cbs_mtp) ;
+
+ CyAsHalFree(dev_p->usb_ep_data) ;
+ CyAsHalFree(dev_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ else
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+}
+
+/*
+* Destroy an existing West Bridge device
+*/
+CyAsReturnStatus_t
+CyAsMiscDestroyDevice(CyAsDeviceHandle handle)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscDestroyDevice called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * If the USB stack is still running, it must be stopped first
+ */
+ if (dev_p->usb_count > 0)
+ return CY_AS_ERROR_STILL_RUNNING ;
+
+ /*
+ * If the STORAGE stack is still running, it must be stopped first
+ */
+ if (dev_p->storage_count > 0)
+ return CY_AS_ERROR_STILL_RUNNING ;
+
+ if(CyAsDeviceIsIntrRunning(dev_p))
+ ret = CyAsIntrStop(dev_p) ;
+
+ ret = CyAsLLStop(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsIntrStart(dev_p, dev_p->use_int_drq) ;
+ return ret ;
+ }
+
+ ret = CyAsDmaStop(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsIntrStart(dev_p, dev_p->use_int_drq) ;
+ return ret ;
+ }
+
+ /* Reset the West Bridge device. */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, CY_AS_MEM_RST_CTRL_REG_HARD) ;
+
+ /*
+ * Remove the device from the device list
+ */
+ if (gDeviceList == dev_p)
+ {
+ gDeviceList = dev_p->next_p ;
+ }
+ else
+ {
+ CyAsDevice *tmp_p = gDeviceList ;
+ while (tmp_p && tmp_p->next_p != dev_p)
+ tmp_p = tmp_p->next_p ;
+
+ CyAsHalAssert(tmp_p != 0) ;
+ tmp_p->next_p = dev_p->next_p ;
+ }
+
+ /*
+ * Reset the signature so this will not be detected
+ * as a valid handle
+ */
+ dev_p->sig = 0 ;
+
+ CyAsDestroyCBQueue(dev_p->func_cbs_misc) ;
+ CyAsDestroyCBQueue(dev_p->func_cbs_res) ;
+ CyAsDestroyCBQueue(dev_p->func_cbs_stor) ;
+ CyAsDestroyCBQueue(dev_p->func_cbs_usb) ;
+ CyAsDestroyCBQueue(dev_p->func_cbs_mtp) ;
+
+ /*
+ * Free the memory associated with the device
+ */
+ CyAsHalFree(dev_p->usb_ep_data) ;
+ CyAsHalFree(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* Determine the endian mode for the processor we are running on, then
+* set the endian mode register
+*/
+static void
+CyAsSetupEndianMode(CyAsDevice *dev_p)
+{
+ /*
+ * BWG: In general, we always set West Bridge into the little endian mode. This
+ * causes the data on bit 0 internally to come out on data line 0 externally
+ * and it is generally what we want regardless of the endian mode of the
+ * processor. This capability in West Bridge should be labeled as a "SWAP" capability
+ * and can be used to swap the bytes of data in and out of West Bridge. This is
+ * useful if there is DMA hardware that requires this for some reason I cannot
+ * imagine at this time. Basically if the wires are connected correctly, we should
+ * never need to change the endian-ness of West Bridge.
+ */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_ENDIAN, CY_AS_LITTLE_ENDIAN) ;
+}
+
+/*
+* Query the West Bridge device and determine if we are an standby mode
+*/
+CyAsReturnStatus_t
+CyAsMiscInStandby(CyAsDeviceHandle handle, CyBool *standby)
+{
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscInStandby called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (CyAsDeviceIsPinStandby(dev_p) || CyAsDeviceIsRegisterStandby(dev_p))
+ {
+ *standby = CyTrue ;
+ }
+ else
+ *standby = CyFalse ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+CyAsMiscFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret) ;
+
+
+static void
+MyMiscCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p, CyAsLLRequestResponse *resp_p,
+ CyAsReturnStatus_t ret)
+{
+ (void)resp_p ;
+ (void)context ;
+ (void)ret ;
+
+ switch (CyAsLLRequestResponse_GetCode(req_p))
+ {
+ case CY_RQT_INITIALIZATION_COMPLETE:
+ {
+ uint16_t v ;
+
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_GENERAL_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ CyAsDeviceSetFirmwareLoaded(dev_p) ;
+
+ if (CyAsDeviceIsWaking(dev_p))
+ {
+ /*
+ * This is a callback from a CyAsMiscLeaveStandby() request. In this case we call the
+ * standby callback and clear the waking state.
+ */
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscAwake, 0) ;
+ CyAsDeviceClearWaking(dev_p) ;
+ }
+ else
+ {
+ v = CyAsLLRequestResponse_GetWord(req_p, 3) ;
+
+ /*
+ * Store the media supported on each of the device buses.
+ */
+ dev_p->media_supported[0] = (uint8_t)(v & 0xFF) ;
+ dev_p->media_supported[1] = (uint8_t)((v >> 8) & 0xFF) ;
+
+ v = CyAsLLRequestResponse_GetWord(req_p, 4) ;
+ dev_p->is_mtp_firmware = (CyBool)((v >> 8) & 0xFF) ;
+
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscInitialized, 0) ;
+ }
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_VM_SET) ;
+ if (v & CY_AS_MEM_P0_VM_SET_CFGMODE)
+ CyAsHalPrintMessage("Initialization Message Recieved, but config bit still set\n") ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG) ;
+ if ((v & CY_AS_MEM_RST_RSTCMPT) ==0)
+ CyAsHalPrintMessage("Initialization Message Recieved, but reset complete bit still not set\n") ;
+ }
+ break ;
+
+ case CY_RQT_OUT_OF_SUSPEND:
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_GENERAL_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ CyAsDeviceClearSuspendMode(dev_p) ;
+
+ /*
+ * If the wakeup was caused by an async CyAsMiscLeaveSuspend call, we have to
+ * call the corresponding callback.
+ */
+ if (dev_p->func_cbs_misc->count > 0)
+ {
+ CyAsFuncCBNode *node = (CyAsFuncCBNode*)dev_p->func_cbs_misc->head_p ;
+ CyAsHalAssert(node) ;
+
+ if (CyAsFunctCBTypeGetType(node->dataType) == CY_FUNCT_CB_MISC_LEAVESUSPEND)
+ {
+ CyAsHalAssert(node->cb_p != 0) ;
+ node->cb_p((CyAsDeviceHandle)dev_p, CY_AS_ERROR_SUCCESS, node->client_data,
+ CY_FUNCT_CB_MISC_LEAVESUSPEND, 0) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_misc) ;
+ }
+ }
+
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscWakeup, 0) ;
+ break ;
+
+ case CY_RQT_DEBUG_MESSAGE:
+ if ((req_p->data[0] == 0) && (req_p->data[1] == 0) && (req_p->data[2] == 0))
+ {
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscHeartBeat, 0) ;
+ }
+ else
+ {
+ CyAsHalPrintMessage("**** Debug Message: %02x %02x %02x %02x %02x %02x\n",
+ req_p->data[0] & 0xff, (req_p->data[0] >> 8) & 0xff,
+ req_p->data[1] & 0xff, (req_p->data[1] >> 8) & 0xff,
+ req_p->data[2] & 0xff, (req_p->data[2] >> 8) & 0xff) ;
+ }
+ break ;
+
+ case CY_RQT_WB_DEVICE_MISMATCH:
+ {
+ if (dev_p->misc_event_cb)
+ dev_p->misc_event_cb((CyAsDeviceHandle)dev_p, CyAsEventMiscDeviceMismatch, 0) ;
+ }
+ break ;
+
+ case CY_RQT_BOOTLOAD_NO_FIRMWARE:
+ {
+ /* TODO Handle case when firmware is not found during bootloading. */
+ CyAsHalPrintMessage("No firmware image found during bootload. Device not started\n") ;
+ }
+ break ;
+
+ default:
+ CyAsHalAssert (0) ;
+ }
+}
+
+static CyBool
+IsValidSiliconId(uint16_t v)
+{
+ CyBool idok = CyFalse ;
+
+ /*
+ * Remove the revision number from the ID value
+ */
+ v = v & CY_AS_MEM_CM_WB_CFG_ID_HDID_MASK ;
+
+ /*
+ * If this is West Bridge, then we are OK.
+ */
+ if (v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ANTIOCH_VALUE ||
+ v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_FPGA_VALUE ||
+ v == CY_AS_MEM_CM_WB_CFG_ID_HDID_ASTORIA_VALUE)
+ idok = CyTrue ;
+
+ return idok ;
+}
+
+/*
+* Configure the West Bridge device hardware
+*/
+CyAsReturnStatus_t
+CyAsMiscConfigureDevice(CyAsDeviceHandle handle, CyAsDeviceConfig *config_p)
+{
+ CyAsReturnStatus_t ret ;
+ CyBool standby ;
+ CyAsDevice *dev_p ;
+ uint16_t v ;
+ uint16_t fw_present;
+ CyAsLogDebugMessage(6, "CyAsMiscConfigureDevice called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /* Setup big endian vs little endian */
+ CyAsSetupEndianMode(dev_p) ;
+
+ /* Now, confirm that we can talk to the West Bridge device */
+ dev_p->silicon_id = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+ fw_present = CyAsHalReadRegister(dev_p->tag,CY_AS_MEM_RST_CTRL_REG ) ;
+ if (!(fw_present & CY_AS_MEM_RST_RSTCMPT))
+ {
+ if (!IsValidSiliconId(dev_p->silicon_id))
+ return CY_AS_ERROR_NO_ANTIOCH ;
+ }
+ /* Check for standby mode */
+ ret = CyAsMiscInStandby(handle, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ if (ret)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ /* Setup P-port interface mode (CRAM / SRAM). */
+ if (CyAsDeviceIsAstoriaDev(dev_p))
+ {
+ if (config_p->srammode)
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_SRAM ;
+ else
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_RAM ;
+ }
+ else
+ v = CY_AS_MEM_P0_VM_SET_VMTYPE_RAM ;
+
+ /* Setup synchronous versus asynchronous mode */
+ if (config_p->sync)
+ v |= CY_AS_MEM_P0_VM_SET_IFMODE ;
+ if (config_p->dackmode == CyAsDeviceDackAck)
+ v |= CY_AS_MEM_P0_VM_SET_DACKEOB ;
+ if (config_p->drqpol)
+ v |= CY_AS_MEM_P0_VM_SET_DRQPOL ;
+ if (config_p->dackpol)
+ v |= CY_AS_MEM_P0_VM_SET_DACKPOL ;
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_VM_SET, v) ;
+
+ if (config_p->crystal)
+ CyAsDeviceSetCrystal(dev_p) ;
+ else
+ CyAsDeviceSetExternalClock(dev_p) ;
+
+ /* Register a callback to handle MISC requests from the firmware */
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_GENERAL_RQT_CONTEXT, MyMiscCallback) ;
+
+ /* Now mark the DMA and low level modules as active. */
+ CyAsDeviceSetDmaRunning(dev_p) ;
+ CyAsDeviceSetLowLevelRunning(dev_p) ;
+
+ /* Now, initialize the interrupt module */
+ dev_p->use_int_drq = config_p->dmaintr ;
+
+ ret = CyAsIntrStart(dev_p, config_p->dmaintr) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Mark the interface as initialized */
+ CyAsDeviceSetConfigured(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+MyDmaCallback(CyAsDevice * dev_p,
+ CyAsEndPointNumber_t ep,
+ void * mem_p,
+ uint32_t size,
+ CyAsReturnStatus_t ret
+ )
+{
+ CyAsDmaEndPoint *ep_p ;
+
+ (void)size ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, ep) ;
+
+ /* Check the queue to see if is drained */
+ if (ep_p->queue_p == 0)
+ {
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)dev_p->func_cbs_misc->head_p ;
+
+ CyAsHalAssert(node) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ /*
+ * Disable endpoint 2. The storage module will enable this EP if necessary.
+ */
+ CyAsDmaEnableEndPoint(dev_p, CY_AS_FIRMWARE_ENDPOINT, CyFalse, CyAsDirectionIn) ;
+
+ /*
+ * Clear the reset register. This releases the Antioch micro-controller from
+ * reset and begins running the code at address zero.
+ */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, 0x00) ;
+ }
+
+ /* Call the user Callback */
+ node->cb_p((CyAsDeviceHandle)dev_p, ret, node->client_data, (CyAsFunctCBType)node->dataType, node->data) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_misc) ;
+ }
+ else
+ {
+ /* This is the header data that was allocated in the download firmware function,
+ * and can be safely freed here. */
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(mem_p) ;
+ CyAsHalEnableInterrupts(state) ;
+ }
+}
+
+CyAsReturnStatus_t
+CyAsMiscDownloadFirmware(CyAsDeviceHandle handle,
+ const void *mem_p,
+ uint16_t size,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ uint8_t *header ;
+ CyAsReturnStatus_t ret ;
+ CyBool standby ;
+ CyAsDevice *dev_p ;
+ CyAsDmaCallback dmacb = 0 ;
+ uint32_t state ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscDownloadFirmware called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * If the device has not been initialized, we cannot download firmware
+ * to the device.
+ */
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ /*
+ * Make sure West Bridge is not in standby
+ */
+ ret = CyAsMiscInStandby(dev_p, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /*
+ * Make sure we are in configuration mode
+ */
+ if ((CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_VM_SET) & CY_AS_MEM_P0_VM_SET_CFGMODE) == 0)
+ return CY_AS_ERROR_NOT_IN_CONFIG_MODE ;
+
+ /* Maximum firmware size is 24k */
+ if (size > CY_AS_MAXIMUM_FIRMWARE_SIZE)
+ return CY_AS_ERROR_INVALID_SIZE ;
+
+ /* Make sure the size is an even number of bytes as well */
+ if (size & 0x01)
+ return CY_AS_ERROR_ALIGNMENT_ERROR ;
+
+ /*
+ * Write the two word header that gives the base address and
+ * size of the firmware image to download
+ */
+ state = CyAsHalDisableInterrupts() ;
+ header = (uint8_t *)CyAsHalCBAlloc(4) ;
+ CyAsHalEnableInterrupts(state) ;
+ if (header == NULL)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ header[0] = 0x00 ;
+ header[1] = 0x00 ;
+ header[2] = (uint8_t)(size & 0xff) ;
+ header[3] = (uint8_t)((size >> 8) & 0xff) ;
+
+ /* Enable the firmware endpoint */
+ ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_FIRMWARE_ENDPOINT, CyTrue, CyAsDirectionIn) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /*
+ * Setup DMA for 64 byte packets. This is the requirement for downloading
+ * firmware to West Bridge.
+ */
+ CyAsDmaSetMaxDmaSize(dev_p, CY_AS_FIRMWARE_ENDPOINT, 64) ;
+
+ if(cb)
+ {
+ dmacb = MyDmaCallback ;
+ }
+
+ ret = CyAsDmaQueueRequest(dev_p, CY_AS_FIRMWARE_ENDPOINT, header, 4, CyFalse, CyFalse, dmacb) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /*
+ * Write the firmware image to the West Bridge device
+ */
+ ret = CyAsDmaQueueRequest(dev_p, CY_AS_FIRMWARE_ENDPOINT, (void *)mem_p, size, CyFalse, CyFalse, dmacb) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if(cb)
+ {
+ CyAsFuncCBNode* cbnode = CyAsCreateFuncCBNodeData(cb, client, CY_FUNCT_CB_MISC_DOWNLOADFIRMWARE, 0) ;
+
+ if(cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ else
+ CyAsInsertCBNode(dev_p->func_cbs_misc, cbnode) ;
+
+ ret = CyAsDmaKickStart(dev_p, CY_AS_FIRMWARE_ENDPOINT) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+ else
+ {
+
+ ret = CyAsDmaDrainQueue(dev_p, CY_AS_FIRMWARE_ENDPOINT, CyTrue) ;
+
+ /* Free the header memory that was allocated earlier. */
+ CyAsHalCBFree(header) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+ /*
+ * Disable endpoint 2. The storage module will enable this EP if necessary.
+ */
+ CyAsDmaEnableEndPoint(dev_p, CY_AS_FIRMWARE_ENDPOINT, CyFalse, CyAsDirectionIn) ;
+
+ /*
+ * Clear the reset register. This releases the West Bridge micro-controller from
+ * reset and begins running the code at address zero.
+ */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, 0x00) ;
+ }
+
+ /*
+ * The firmware is not marked as loaded until the firmware initializes West Bridge and a request
+ * is sent from West Bridge to the P port processor indicating that West Bridge is ready.
+ */
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+
+static CyAsReturnStatus_t
+MyHandleResponseGetFirmwareVersion(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsGetFirmwareVersionData *data_p)
+{
+
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t val ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_FIRMWARE_VERSION)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ data_p->major = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ data_p->minor = CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+ data_p->build = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ val = CyAsLLRequestResponse_GetWord(reply_p, 3) ;
+ data_p->mediaType = (uint8_t)(((val >> 8) & 0xFF) | (val & 0xFF)) ;
+ val = CyAsLLRequestResponse_GetWord(reply_p, 4) ;
+ data_p->isDebugMode = (CyBool)(val & 0xFF) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscGetFirmwareVersion(CyAsDeviceHandle handle,
+ CyAsGetFirmwareVersionData* data,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyBool standby ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ CyAsDevice *dev_p ;
+
+ (void)client ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscGetFirmwareVersion called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /*
+ * Make sure Antioch is not in standby
+ */
+ ret = CyAsMiscInStandby(dev_p, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_GET_FIRMWARE_VERSION, CY_RQT_GENERAL_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Reserve space for the reply, the reply data will not exceed three words */
+ reply_p = CyAsLLCreateResponse(dev_p, 5) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* Request and response are freed in MyHandleResponseGetFirmwareVersion. */
+ ret = MyHandleResponseGetFirmwareVersion(dev_p, req_p, reply_p, data) ;
+ return ret ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_GETFIRMWAREVERSION,
+ data, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p,
+ reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+static CyAsReturnStatus_t
+MyHandleResponseReadMCURegister(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ uint8_t *data_p)
+{
+
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MCU_REGISTER_DATA)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ *data_p = (uint8_t)(CyAsLLRequestResponse_GetWord(reply_p, 0)) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseGetGpioValue(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ uint8_t *data_p)
+{
+
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_GPIO_STATE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ else
+ *data_p = (uint8_t)(CyAsLLRequestResponse_GetWord(reply_p, 0)) ;
+
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+
+CyAsReturnStatus_t CyAsMiscSetSDPowerPolarity(
+ CyAsDeviceHandle handle,
+ CyAsMiscSignalPolarity polarity,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDPOLARITY , CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ {
+
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)polarity) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return (MyHandleResponseNoData(dev_p, req_p, reply_p)) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_SETSDPOLARITY,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+
+
+
+
+CyAsReturnStatus_t
+CyAsMiscReadMCURegister(CyAsDeviceHandle handle,
+ uint16_t address,
+ uint8_t *value,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscReadMCURegister called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /* Check whether the firmware supports this command. */
+ if (CyAsDeviceIsNandStorageSupported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_READ_MCU_REGISTER, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)address) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MCU_REGISTER_DATA)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ *value = (uint8_t)(CyAsLLRequestResponse_GetWord(reply_p, 0)) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_READMCUREGISTER,
+ value, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsMiscWriteMCURegister(CyAsDeviceHandle handle,
+ uint16_t address,
+ uint8_t mask,
+ uint8_t value,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscWriteMCURegister called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /* Check whether the firmware supports this command. */
+ if (CyAsDeviceIsNandStorageSupported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_WRITE_MCU_REGISTER, CY_RQT_GENERAL_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)address) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((mask << 8) | value)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_WRITEMCUREGISTER,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+MyHandleResponseReset(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsResetType type)
+{
+ uint16_t v ;
+
+ (void)req_p ;
+ (void)reply_p ;
+
+ /*
+ * If the device is in suspend mode, it needs to be woken up so that the write
+ * to the reset control register succeeds. We need not however wait for the
+ * wake up procedure to be complete.
+ */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ {
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+ CyAsHalSleep (1) ;
+ }
+
+ if (type == CyAsResetHard)
+ {
+ CyAsMiscCancelExRequests(dev_p) ;
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, CY_AS_MEM_RST_CTRL_REG_HARD) ;
+ CyAsDeviceSetUnconfigured(dev_p) ;
+ CyAsDeviceSetFirmwareNotLoaded(dev_p) ;
+ CyAsDeviceSetDmaStopped(dev_p) ;
+ CyAsDeviceSetLowLevelStopped(dev_p) ;
+ CyAsDeviceSetIntrStopped(dev_p) ;
+ CyAsDeviceClearSuspendMode(dev_p) ;
+ CyAsUsbCleanup(dev_p) ;
+ CyAsStorageCleanup(dev_p) ;
+
+ /*
+ * Wait for a small amount of time to allow reset to be complete.
+ */
+ CyAsHalSleep(100) ;
+ }
+
+ CyAsDeviceClearResetPending(dev_p) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscReset(CyAsDeviceHandle handle,
+ CyAsResetType type,
+ CyBool flush,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+ CyAsEndPointNumber_t i ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ (void)client ;
+ (void)cb ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscResetEX called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /*
+ * Soft reset is not supported until we close on the issues in the
+ * firmware with what needs to happen.
+ */
+ if (type == CyAsResetSoft)
+ return CY_AS_ERROR_NOT_YET_SUPPORTED ;
+
+ CyAsDeviceSetResetPending(dev_p) ;
+
+ if (flush)
+ {
+
+ /* Unable to DrainQueues in polling mode */
+ if((dev_p->storage_cb || dev_p->storage_cb_ms) && CyAsHalIsPolling())
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ /*
+ * Shutdown the endpoints so no more traffic can be queued
+ */
+ for(i = 0; i < 15; i++)
+ CyAsDmaEnableEndPoint(dev_p, i, CyFalse, CyAsDirectionDontChange) ;
+
+ /*
+ * If we are in normal mode, drain all traffic across all endpoints to be sure all traffic
+ * is flushed. If the device is suspended, data will not be coming in on any endpoint and
+ * all outstanding DMA operations can be canceled.
+ */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ {
+ for(i = 0; i < 15; i++)
+ {
+ CyAsDmaCancel(dev_p, i, CY_AS_ERROR_CANCELED) ;
+ }
+ }
+ else
+ {
+ for(i = 0; i < 15; i++)
+ {
+ if ((i == CY_AS_P2S_WRITE_ENDPOINT) || (i == CY_AS_P2S_READ_ENDPOINT))
+ CyAsDmaDrainQueue(dev_p, i, CyFalse) ;
+ else
+ CyAsDmaDrainQueue(dev_p, i, CyTrue) ;
+ }
+ }
+ }
+ else
+ {
+ /* No flush was requested, so cancel any outstanding DMAs
+ * so the user callbacks are called as needed
+ */
+ if(CyAsDeviceIsStorageAsyncPending(dev_p))
+ {
+ for(i = 0; i < 15; i++)
+ CyAsDmaCancel(dev_p, i, CY_AS_ERROR_CANCELED) ;
+ }
+ }
+
+ ret = MyHandleResponseReset(dev_p, 0, 0, type) ;
+
+ if(cb)
+ /* Even though no mailbox communication was needed, issue the callback so the
+ * user does not need to special case their code. */
+ cb((CyAsDeviceHandle)dev_p, ret, client, CY_FUNCT_CB_MISC_RESET, 0) ;
+
+ /*
+ * Initialize any registers that may have been changed when the device was reset.
+ */
+ CyAsHalInitDevRegisters(dev_p->tag, CyFalse) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+GetUnallocatedResource(CyAsDevice *dev_p, CyAsResourceType resource)
+{
+ uint8_t shift = 0 ;
+ uint16_t v ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_NOT_ACQUIRED ;
+
+ switch(resource)
+ {
+ case CyAsBusUSB:
+ shift = 4 ;
+ break ;
+ case CyAsBus_1:
+ shift = 0 ;
+ break ;
+ case CyAsBus_0:
+ shift = 2 ;
+ break ;
+ default:
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /* Get the semaphore value for this resource */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE) ;
+ v = (v >> shift) & 0x03 ;
+
+ if (v == 0x03)
+ {
+ ret = CY_AS_ERROR_RESOURCE_ALREADY_OWNED ;
+ }
+ else if ((v & 0x01) == 0)
+ {
+ /* The resource is not owned by anyone, we can try to get it */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_RSE_MASK, (0x03 << shift)) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_RSE_MASK) ;
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE, (0x01 << shift)) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_RSE_MASK) ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE) ;
+ v = (v >> shift) & 0x03 ;
+ if (v == 0x03)
+ ret = CY_AS_ERROR_SUCCESS ;
+ }
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseAcquireResource(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsResourceType *resource)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ ret = GetUnallocatedResource(dev_p, *resource) ;
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ ret = CY_AS_ERROR_SUCCESS ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscAcquireResource(CyAsDeviceHandle handle,
+ CyAsResourceType *resource,
+ CyBool force,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret ;
+
+ CyAsDevice *dev_p ;
+
+ (void)client ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscAcquireResource called") ;
+
+ if (*resource != CyAsBusUSB && *resource != CyAsBus_0 && *resource != CyAsBus_1)
+ return CY_AS_ERROR_INVALID_RESOURCE ;
+
+
+ /* Make sure the device is ready to accept the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+
+ ret = GetUnallocatedResource(dev_p, *resource) ;
+
+ /*
+ * Make sure that the callback is called if the resource is successfully
+ * acquired at this point.
+ */
+ if ((ret == CY_AS_ERROR_SUCCESS) && (cb != 0))
+ cb(handle, ret, client, CY_FUNCT_CB_MISC_ACQUIRERESOURCE, resource) ;
+
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ return ret ;
+
+ if (!force)
+ return CY_AS_ERROR_NOT_ACQUIRED ;
+
+ /* Create the request to acquire the resource */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_ACQUIRE_RESOURCE, CY_RQT_RESOURCE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)(*resource)) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_ACQUIRERESOURCE,
+ resource, dev_p->func_cbs_res, CY_AS_REQUEST_RESPONSE_EX, req_p,
+ reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ ret = GetUnallocatedResource(dev_p, *resource) ;
+ if (ret != CY_AS_ERROR_NOT_ACQUIRED)
+ ret = CY_AS_ERROR_SUCCESS ;
+ }
+
+ return ret ;
+}
+CyAsReturnStatus_t
+CyAsMiscReleaseResource(CyAsDeviceHandle handle, CyAsResourceType resource)
+{
+ uint8_t shift = 0 ;
+ uint16_t v ;
+
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscReleaseResource called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if (resource != CyAsBusUSB && resource != CyAsBus_0 && resource != CyAsBus_1)
+ return CY_AS_ERROR_INVALID_RESOURCE ;
+
+ switch(resource)
+ {
+ case CyAsBusUSB:
+ shift = 4 ;
+ break ;
+ case CyAsBus_1:
+ shift = 0 ;
+ break ;
+ case CyAsBus_0:
+ shift = 2 ;
+ break ;
+ default:
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /* Get the semaphore value for this resource */
+ v = (CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE) >> shift) & 0x03 ;
+ if (v == 0 || v == 1 || v == 2)
+ return CY_AS_ERROR_RESOURCE_NOT_OWNED ;
+
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_RSE_MASK, (0x03 << shift)) ;
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_RSE_ALLOCATE, (0x02 << shift)) ;
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_P0_RSE_MASK, 0) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscSetTraceLevel(CyAsDeviceHandle handle,
+ uint8_t level,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint32_t unit,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscSetTraceLevel called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (unit > 255)
+ return CY_AS_ERROR_NO_SUCH_UNIT ;
+
+ if (level >= CYAS_FW_TRACE_MAX_LEVEL)
+ return CY_AS_ERROR_INVALID_TRACE_LEVEL ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_TRACE_LEVEL, CY_RQT_GENERAL_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)level) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((bus << 12) | (device << 8) | (unit))) ;
+
+ /* Reserve space for the reply, the reply data will not exceed three words */
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_NOT_SUPPORTED ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_SETTRACELEVEL,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscHeartBeatControl(CyAsDeviceHandle handle,
+ CyBool enable,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscHeartBeatControl called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CONTROL_ANTIOCH_HEARTBEAT, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)enable) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_HEARTBEATCONTROL,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MySetSDClockFreq (
+ CyAsDevice *dev_p,
+ uint8_t cardType,
+ uint8_t setting,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ if (CyAsDeviceIsInCallback(dev_p) && (cb == 0))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_SD_CLOCK_FREQ, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((cardType << 8) | setting)) ;
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_SETSDFREQ, 0,
+ dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscSetLowSpeedSDFreq(
+ CyAsDeviceHandle handle,
+ CyAsLowSpeedSDFreq setting,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscSetLowSpeedSDFreq called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if ((setting != CY_AS_SD_DEFAULT_FREQ) && (setting != CY_AS_SD_RATED_FREQ))
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ return MySetSDClockFreq(dev_p, 0, (uint8_t)setting, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscSetHighSpeedSDFreq(
+ CyAsDeviceHandle handle,
+ CyAsHighSpeedSDFreq setting,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscSetHighSpeedSDFreq called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if ((setting != CY_AS_HS_SD_FREQ_24) && (setting != CY_AS_HS_SD_FREQ_48))
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ return MySetSDClockFreq(dev_p, 1, (uint8_t)setting, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscGetGpioValue(CyAsDeviceHandle handle,
+ CyAsMiscGpio pin,
+ uint8_t *value,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsDevice *dev_p ;
+ uint16_t v ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscGetGpioValue called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /* If the pin specified is UVALID, there is no need for firmware to be loaded. */
+ if (pin == CyAsMiscGpio_UValid)
+ {
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_PMU_UPDATE) ;
+ *value = (uint8_t)(v & CY_AS_MEM_PMU_UPDATE_UVALID) ;
+
+ if (cb != 0)
+ cb(dev_p, ret, client, CY_FUNCT_CB_MISC_GETGPIOVALUE, value) ;
+
+ return ret ;
+ }
+
+ /* Check whether the firmware supports this command. */
+ if (CyAsDeviceIsNandStorageSupported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Make sure the pin selected is valid */
+ if ((pin != CyAsMiscGpio_1) && (pin != CyAsMiscGpio_0))
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_GET_GPIO_STATE, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, ((uint8_t)pin << 8)) ;
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_GPIO_STATE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ *value = (uint8_t)CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_GETGPIOVALUE,
+ value, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsMiscSetGpioValue(CyAsDeviceHandle handle,
+ CyAsMiscGpio pin,
+ uint8_t value,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsDevice *dev_p ;
+ uint16_t v ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscSetGpioValue called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /* If the pin specified is UVALID, there is no need for firmware to be loaded. */
+ if (pin == CyAsMiscGpio_UValid)
+ {
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_PMU_UPDATE) ;
+ if (value)
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_PMU_UPDATE, (v | CY_AS_MEM_PMU_UPDATE_UVALID)) ;
+ else
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_PMU_UPDATE, (v & ~CY_AS_MEM_PMU_UPDATE_UVALID)) ;
+
+ if (cb != 0)
+ cb(dev_p, ret, client, CY_FUNCT_CB_MISC_SETGPIOVALUE, 0) ;
+ return ret ;
+ }
+
+ /* Check whether the firmware supports this command. */
+ if (CyAsDeviceIsNandStorageSupported(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Make sure the pin selected is valid */
+ if ((pin < CyAsMiscGpio_0) || (pin > CyAsMiscGpio_UValid))
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ /* Create and initialize the low level request to the firmware. */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_GPIO_STATE, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ v = (uint16_t)(((uint8_t)pin << 8) | (value > 0)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, v) ;
+
+ /* Reserve space for the reply, which will not exceed one word. */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_SETGPIOVALUE,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyEnterStandby(CyAsDevice *dev_p, CyBool pin)
+{
+ CyAsMiscCancelExRequests(dev_p) ;
+
+ /* Save the current values in the critical P-port registers, where necessary. */
+ CyAsHalReadRegsBeforeStandby(dev_p->tag) ;
+
+ if (pin)
+ {
+ if (CyAsHalSetWakeupPin(dev_p->tag, CyFalse))
+ CyAsDeviceSetPinStandby(dev_p) ;
+ else
+ return CY_AS_ERROR_SETTING_WAKEUP_PIN ;
+ }
+ else
+ {
+ /*
+ * Put antioch in the standby mode
+ */
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_PWR_MAGT_STAT, 0x02) ;
+ CyAsDeviceSetRegisterStandby(dev_p) ;
+ }
+
+ /*
+ * When the Antioch comes out of standby, we have to wait until
+ * the firmware initialization completes before sending other
+ * requests down.
+ */
+ CyAsDeviceSetFirmwareNotLoaded(dev_p) ;
+
+ /*
+ * Keep West Bridge interrupt disabled until the device is being woken
+ * up from standby.
+ */
+ dev_p->stby_int_mask = CyAsHalDisableInterrupts ();
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseEnterStandby(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyBool pin)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ ret = MyEnterStandby(dev_p, pin) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscEnterStandby(CyAsDeviceHandle handle,
+ CyBool pin,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyBool standby ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscEnterStandby called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * If we already are in standby, do not do it again and let the
+ * user know via the error return.
+ */
+ ret = CyAsMiscInStandby(handle, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (standby == CyTrue)
+ return CY_AS_ERROR_ALREADY_STANDBY ;
+
+ /*
+ * If the user wants to transition from suspend mode to standby mode,
+ * the device needs to be woken up so that it can complete all pending
+ * operations.
+ */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ CyAsMiscLeaveSuspend(dev_p, 0, 0) ;
+
+ if (dev_p->usb_count)
+ {
+ /*
+ * We do not allow West Bridge to go into standby mode when the
+ * USB stack is initialized. You must stop the USB stack in
+ * order to enter standby mode.
+ */
+ return CY_AS_ERROR_USB_RUNNING ;
+ }
+
+ /*
+ * If the storage stack is not running, the device can directly be put into
+ * sleep mode. Otherwise, the firmware needs to be signaled to prepare for
+ * going into sleep mode.
+ */
+ if (dev_p->storage_count)
+ {
+ /*
+ * If there are async storage operations pending, make one attempt to
+ * complete them.
+ */
+ if (CyAsDeviceIsStorageAsyncPending(dev_p))
+ {
+ /* DrainQueue will not work in polling mode */
+ if(CyAsHalIsPolling())
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ CyAsDmaDrainQueue(dev_p, CY_AS_P2S_READ_ENDPOINT, CyFalse) ;
+ CyAsDmaDrainQueue(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CyFalse) ;
+
+ /*
+ * If more storage operations were queued at this stage, return
+ * an error.
+ */
+ if (CyAsDeviceIsStorageAsyncPending(dev_p))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_PREPARE_FOR_STANDBY, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(!cb)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed in the HandleResponse */
+ return MyHandleResponseEnterStandby(dev_p, req_p, reply_p, pin) ;
+
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_ENTERSTANDBY,
+ (void*)pin, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p,
+ reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else
+ {
+ ret = MyEnterStandby(dev_p, pin) ;
+ if(cb)
+ /* Even though no mailbox communication was needed, issue the callback so the
+ * user does not need to special case their code. */
+ cb((CyAsDeviceHandle)dev_p, ret, client, CY_FUNCT_CB_MISC_ENTERSTANDBY, 0) ;
+ }
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscEnterStandbyEXU(CyAsDeviceHandle handle,
+ CyBool pin,
+ CyBool uvalid_special,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if(uvalid_special)
+ {
+ CyAsHalWriteRegister(dev_p->tag, 0xc5, 0x4) ;
+ }
+
+ return CyAsMiscEnterStandby(handle, pin, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscLeaveStandby(CyAsDeviceHandle handle, CyAsResourceType resource)
+{
+ CyAsDevice *dev_p ;
+ uint16_t v ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint32_t count = 8 ;
+ uint8_t retry = 1 ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscLeaveStandby called") ;
+ (void)resource ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (CyAsDeviceIsRegisterStandby(dev_p))
+ {
+ /*
+ * Set a flag to indicate that the West Bridge is waking up from standby.
+ */
+ CyAsDeviceSetWaking(dev_p) ;
+
+ /*
+ * The initial read will not succeed, but will just wake the West Bridge
+ * device from standby. Successive reads should succeed and in that way
+ * we know West Bridge is awake.
+ */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+
+ do
+ {
+ /*
+ * We have initiated the operation to leave standby, now we need to wait at least
+ * N ms before trying to access the West Bridge device to insure the PLLs have locked and we
+ * can talk to the device.
+ */
+ if (CyAsDeviceIsCrystal(dev_p))
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL) ;
+ else
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+
+ /*
+ * If the P-SPI interface mode is in use, there may be a need to re-synchronise the
+ * serial clock used for Astoria access.
+ */
+ if (!IsValidSiliconId(v))
+ {
+ if (CyAsHalSyncDeviceClocks(dev_p->tag) != CyTrue)
+ {
+ CyAsHalEnableInterrupts (dev_p->stby_int_mask) ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+ }
+ } while (!IsValidSiliconId(v) && count-- > 0) ;
+
+ /*
+ * If we tried to read the register and could not, return a timeout
+ */
+ if (count == 0)
+ {
+ CyAsHalEnableInterrupts (dev_p->stby_int_mask) ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+
+ /*
+ * The standby flag is cleared here, after the action to exit standby has
+ * been taken. The wait for firmware initialization, is ensured by marking
+ * the firmware as not loaded until the init event is received.
+ */
+ CyAsDeviceClearRegisterStandby(dev_p) ;
+
+ /*
+ * Initialize any registers that may have been changed while the device was in standby mode.
+ */
+ CyAsHalInitDevRegisters(dev_p->tag, CyTrue) ;
+ }
+ else if (CyAsDeviceIsPinStandby(dev_p))
+ {
+ /*
+ * Set a flag to indicate that the West Bridge is waking up from standby.
+ */
+ CyAsDeviceSetWaking(dev_p) ;
+
+TryWakeupAgain:
+ /*
+ * Try to set the wakeup pin, if this fails in the HAL layer, return this
+ * failure to the user.
+ */
+ if (!CyAsHalSetWakeupPin(dev_p->tag, CyTrue))
+ {
+ CyAsHalEnableInterrupts (dev_p->stby_int_mask) ;
+ return CY_AS_ERROR_SETTING_WAKEUP_PIN ;
+ }
+
+ /*
+ * We have initiated the operation to leave standby, now we need to wait at least
+ * N ms before trying to access the West Bridge device to insure the PLLs have locked and we
+ * can talk to the device.
+ */
+ if (CyAsDeviceIsCrystal(dev_p))
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CRYSTAL) ;
+ else
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK) ;
+
+ /*
+ * Initialize any registers that may have been changed while the device was in standby mode.
+ */
+ CyAsHalInitDevRegisters(dev_p->tag, CyTrue) ;
+
+ /*
+ * The standby flag is cleared here, after the action to exit standby has
+ * been taken. The wait for firmware initialization, is ensured by marking
+ * the firmware as not loaded until the init event is received.
+ */
+ CyAsDeviceClearPinStandby(dev_p) ;
+ }
+ else
+ {
+ return CY_AS_ERROR_NOT_IN_STANDBY ;
+ }
+
+ /*
+ * The West Bridge interrupt can be enabled now.
+ */
+ CyAsHalEnableInterrupts (dev_p->stby_int_mask) ;
+
+ /*
+ * Release the West Bridge Micro-Controller from reset, so that firmware initialization
+ * can complete.
+ * The attempt to release Antioch reset is made upto 8 times.
+ */
+ v = 0x03 ;
+ count = 0x08 ;
+ while ((v & 0x03) && (count))
+ {
+ CyAsHalWriteRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG, 0x00) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_RST_CTRL_REG) ;
+ count-- ;
+ }
+
+ if (v & 0x03)
+ {
+ CyAsHalPrintMessage("Failed to clear Antioch reset\n") ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+
+ /*
+ * If the wake-up pin is being used, wait here to make sure that the wake-up event
+ * is received within a reasonable delay. Otherwise, toggle the wake-up pin again
+ * in an attempt to start the firmware properly.
+ */
+ if (retry)
+ {
+ count = 10 ;
+ while (count)
+ {
+ /* If the wake-up event has been received, we can return. */
+ if (CyAsDeviceIsFirmwareLoaded (dev_p))
+ break ;
+ /* If we are in polling mode, the interrupt may not have been serviced as yet.
+ * Read the interrupt status register. If a pending mailbox interrupt is seen,
+ * we can assume that the wake-up event will be received soon. */
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_P0_INTR_REG) ;
+ if (v & CY_AS_MEM_P0_INTR_REG_MBINT)
+ break ;
+
+ CyAsHalSleep (10) ;
+ count-- ;
+ }
+
+ if (!count)
+ {
+ retry = 0 ;
+ dev_p->stby_int_mask = CyAsHalDisableInterrupts() ;
+ CyAsHalSetWakeupPin(dev_p->tag, CyFalse) ;
+ CyAsHalSleep (10) ;
+ goto TryWakeupAgain ;
+ }
+ }
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscRegisterCallback(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsMiscEventCallback callback /* The function to call */
+ )
+{
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscRegisterCallback called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ dev_p->misc_event_cb = callback ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscStorageChanged(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyBool standby ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscStorageChanged called") ;
+
+ /* Make sure the device is ready for the command. */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /*
+ * Make sure Antioch is not in standby
+ */
+ ret = CyAsMiscInStandby(dev_p, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ /*
+ * Make sure Westbridge is not in suspend mode.
+ */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STORAGE_MEDIA_CHANGED, CY_RQT_GENERAL_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_STORAGECHANGED,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsMiscEnterSuspend(
+ CyAsDeviceHandle handle,
+ CyBool usb_wakeup_en,
+ CyBool gpio_wakeup_en,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyBool standby ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ uint16_t value ;
+ uint32_t int_state ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscEnterSuspend called") ;
+
+ /*
+ * Basic sanity checks to ensure that the device is initialised.
+ */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /*
+ * Make sure West Bridge is not already in standby
+ */
+ CyAsMiscInStandby(dev_p, &standby) ;
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ /*
+ * Make sure that the device is not already in suspend mode.
+ */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /*
+ * Make sure there is no active USB connection.
+ */
+ if ((CyAsDeviceIsUsbConnected(dev_p)) && (dev_p->usb_last_event != CyAsEventUsbSuspend))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ /*
+ * Make sure that there are no async requests at this point in time.
+ */
+ int_state = CyAsHalDisableInterrupts() ;
+ if ((dev_p->func_cbs_misc->count) || (dev_p->func_cbs_res->count) ||
+ (dev_p->func_cbs_stor->count) || (dev_p->func_cbs_usb->count))
+ {
+ CyAsHalEnableInterrupts(int_state) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+ CyAsHalEnableInterrupts(int_state) ;
+
+ /* Create the request to send to the Antioch device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_ENTER_SUSPEND_MODE, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Wakeup control flags. */
+ value = 0x0001 ;
+ if (usb_wakeup_en)
+ value |= 0x04 ;
+ if (gpio_wakeup_en)
+ value |= 0x02 ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, value) ;
+
+ if (cb != 0)
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_ENTERSUSPEND,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return CY_AS_ERROR_SUCCESS ;
+ }
+ else
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+
+destroy:
+ if (ret == CY_AS_ERROR_SUCCESS)
+ CyAsDeviceSetSuspendMode(dev_p) ;
+
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscLeaveSuspend(
+ CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p ;
+ uint16_t v, count ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscLeaveSuspend called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /* Make sure we are in suspend mode. */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ {
+ if (cb)
+ {
+ CyAsFuncCBNode *cbnode = CyAsCreateFuncCBNodeData(cb, client, CY_FUNCT_CB_MISC_LEAVESUSPEND, 0) ;
+ if (cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsInsertCBNode(dev_p->func_cbs_misc, cbnode) ;
+ }
+
+ /*
+ * Do a read from the ID register so that the CE assertion will wake West Bridge.
+ * The read is repeated until the read comes back with valid data.
+ */
+ count = 8 ;
+
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+
+ while (!IsValidSiliconId(v) && count-- > 0)
+ {
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK) ;
+ v = CyAsHalReadRegister(dev_p->tag, CY_AS_MEM_CM_WB_CFG_ID) ;
+ }
+
+ /*
+ * If we tried to read the register and could not, return a timeout
+ */
+ if (count == 0)
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+ else
+ return CY_AS_ERROR_NOT_IN_SUSPEND ;
+
+ if (cb == 0)
+ {
+ /*
+ * Wait until the in suspend mode flag is cleared.
+ */
+ count = 20 ;
+ while ((CyAsDeviceIsInSuspendMode(dev_p)) && (count--))
+ {
+ CyAsHalSleep(CY_AS_LEAVE_STANDBY_DELAY_CLOCK) ;
+ }
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ ret = CY_AS_ERROR_TIMEOUT ;
+ }
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscReserveLNABootArea(CyAsDeviceHandle handle,
+ uint8_t numzones,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyBool standby ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ CyAsDevice *dev_p ;
+
+ (void)client ;
+
+ CyAsLogDebugMessage(6, "CyAsMiscSwitchPnandMode called") ;
+
+ /* Make sure we have a valid device */
+ dev_p = (CyAsDevice *)handle ;
+ CyAsCheckDeviceReady(dev_p) ;
+
+ /*
+ * Make sure Antioch is not in standby
+ */
+ ret = CyAsMiscInStandby(dev_p, &standby) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ if (standby)
+ return CY_AS_ERROR_IN_STANDBY ;
+
+ /* Make sure the Antioch is not in suspend mode. */
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_RESERVE_LNA_BOOT_AREA, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)numzones) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MISC_RESERVELNABOOTAREA,
+ 0, dev_p->func_cbs_misc, CY_AS_REQUEST_RESPONSE_EX, req_p,
+ reply_p, CyAsMiscFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsFuncCBNode*
+CyAsCreateFuncCBNodeData(CyAsFunctionCallback cb,
+ uint32_t client,
+ CyAsFunctCBType type,
+ void* data)
+{
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)CyAsHalCBAlloc(sizeof(CyAsFuncCBNode)) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(node != 0)
+ {
+ node->nodeType = CYAS_FUNC_CB ;
+ node->cb_p = cb ;
+ node->client_data = client ;
+ node->dataType = type ;
+ if(data != 0)
+ node->dataType |= CY_FUNCT_CB_DATA ;
+ else
+ node->dataType |= CY_FUNCT_CB_NODATA ;
+ node->data = data ;
+ node->next_p = 0 ;
+ }
+ return node ;
+}
+
+CyAsFuncCBNode*
+CyAsCreateFuncCBNode(CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ return CyAsCreateFuncCBNodeData(cb, client, CY_FUNCT_CB_NODATA, 0) ;
+}
+
+void
+CyAsDestroyFuncCBNode(CyAsFuncCBNode* node)
+{
+ uint32_t state ;
+
+ node->nodeType = CYAS_INVALID ;
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+CyAsUsbFuncCBNode*
+CyAsCreateUsbFuncCBNode(CyAsUsbFunctionCallback cb, uint32_t client)
+{
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsUsbFuncCBNode * node = (CyAsUsbFuncCBNode *)CyAsHalCBAlloc(sizeof(CyAsUsbFuncCBNode)) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(node != 0)
+ {
+ node->type = CYAS_USB_FUNC_CB ;
+ node->cb_p = cb ;
+ node->client_data = client ;
+ node->next_p = 0 ;
+ }
+ return node ;
+}
+
+void
+CyAsDestroyUsbFuncCBNode(CyAsUsbFuncCBNode* node)
+{
+ uint32_t state ;
+
+ node->type = CYAS_INVALID ;
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+CyAsUsbIoCBNode*
+CyAsCreateUsbIoCBNode(CyAsUsbIoCallback cb)
+{
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsUsbIoCBNode * node = (CyAsUsbIoCBNode *)CyAsHalCBAlloc(sizeof(CyAsUsbIoCBNode)) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(node != 0)
+ {
+ node->type = CYAS_USB_IO_CB ;
+ node->cb_p = cb ;
+ node->next_p = 0 ;
+ }
+ return node ;
+}
+
+void
+CyAsDestroyUsbIoCBNode(CyAsUsbIoCBNode* node)
+{
+ uint32_t state ;
+
+ node->type = CYAS_INVALID ;
+
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+CyAsStorageIoCBNode*
+CyAsCreateStorageIoCBNode(CyAsStorageCallback cb, CyAsMediaType media, uint32_t device_index,
+ uint32_t unit, uint32_t block_addr, CyAsOperType oper,
+ CyAsLLRequestResponse* req_p, CyAsLLRequestResponse* reply_p)
+{
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsStorageIoCBNode * node = (CyAsStorageIoCBNode *)CyAsHalCBAlloc(sizeof(CyAsStorageIoCBNode)) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(node != 0)
+ {
+ node->type = CYAS_STORAGE_IO_CB ;
+ node->cb_p = cb ;
+ node->media = media ;
+ node->device_index = device_index ;
+ node->unit = unit ;
+ node->block_addr = block_addr ;
+ node->oper = oper ;
+ node->req_p = req_p ;
+ node->reply_p = reply_p ;
+ node->next_p = 0 ;
+ }
+ return node ;
+}
+
+void
+CyAsDestroyStorageIoCBNode(CyAsStorageIoCBNode* node)
+{
+ uint32_t state ;
+ node->type = CYAS_INVALID ;
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(node) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+CyAsCBQueue *
+CyAsCreateCBQueue(CyAsCBNodeType type)
+{
+ uint32_t state = CyAsHalDisableInterrupts() ;
+ CyAsCBQueue * queue = (CyAsCBQueue *)CyAsHalCBAlloc(sizeof(CyAsCBQueue)) ;
+ CyAsHalEnableInterrupts(state) ;
+ if(queue)
+ {
+ queue->type = type ;
+ queue->head_p = 0 ;
+ queue->tail_p = 0 ;
+ queue->count = 0 ;
+ }
+
+ return queue ;
+}
+
+void
+CyAsDestroyCBQueue(CyAsCBQueue* queue)
+{
+ uint32_t state ;
+ queue->type = CYAS_INVALID ;
+ queue->head_p = 0 ;
+ queue->tail_p = 0 ;
+ queue->count = 0 ;
+ state = CyAsHalDisableInterrupts() ;
+ CyAsHalCBFree(queue) ;
+ CyAsHalEnableInterrupts(state) ;
+}
+
+/* Inserts a CyAsCBNode into the queue, the node type must match the queue type*/
+void
+CyAsInsertCBNode(CyAsCBQueue * queue_p, void* cbnode)
+{
+ uint32_t int_state ;
+
+ int_state = CyAsHalDisableInterrupts() ;
+
+ CyAsHalAssert(queue_p != 0) ;
+
+ switch (queue_p->type)
+ {
+ case CYAS_USB_FUNC_CB:
+ {
+ CyAsUsbFuncCBNode* node = (CyAsUsbFuncCBNode*)cbnode ;
+ CyAsUsbFuncCBNode* tail = (CyAsUsbFuncCBNode*)queue_p->tail_p ;
+
+ CyAsHalAssert(node->type == CYAS_USB_FUNC_CB) ;
+ CyAsHalAssert(tail == 0 || tail->type == CYAS_USB_FUNC_CB) ;
+ if(queue_p->head_p == 0)
+ queue_p->head_p = node ;
+ else
+ tail->next_p = node ;
+
+ queue_p->tail_p = node ;
+ }
+ break ;
+
+ case CYAS_USB_IO_CB:
+ {
+ CyAsUsbIoCBNode* node = (CyAsUsbIoCBNode*)cbnode ;
+ CyAsUsbIoCBNode* tail = (CyAsUsbIoCBNode*)queue_p->tail_p ;
+
+ CyAsHalAssert(node->type == CYAS_USB_IO_CB) ;
+ CyAsHalAssert(tail == 0 || tail->type == CYAS_USB_IO_CB) ;
+ if(queue_p->head_p == 0)
+ queue_p->head_p = node ;
+ else
+ tail->next_p = node ;
+
+ queue_p->tail_p = node ;
+ }
+ break ;
+
+ case CYAS_STORAGE_IO_CB:
+ {
+ CyAsStorageIoCBNode* node = (CyAsStorageIoCBNode*)cbnode ;
+ CyAsStorageIoCBNode* tail = (CyAsStorageIoCBNode*)queue_p->tail_p ;
+
+ CyAsHalAssert(node->type == CYAS_STORAGE_IO_CB) ;
+ CyAsHalAssert(tail == 0 || tail->type == CYAS_STORAGE_IO_CB) ;
+ if(queue_p->head_p == 0)
+ queue_p->head_p = node ;
+ else
+ tail->next_p = node ;
+
+ queue_p->tail_p = node ;
+ }
+ break ;
+
+ case CYAS_FUNC_CB:
+ {
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)cbnode ;
+ CyAsFuncCBNode* tail = (CyAsFuncCBNode*)queue_p->tail_p ;
+
+ CyAsHalAssert(node->nodeType == CYAS_FUNC_CB) ;
+ CyAsHalAssert(tail == 0 || tail->nodeType == CYAS_FUNC_CB) ;
+ if(queue_p->head_p == 0)
+ queue_p->head_p = node ;
+ else
+ tail->next_p = node ;
+
+ queue_p->tail_p = node ;
+ }
+ break ;
+
+ default:
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ queue_p->count++ ;
+
+ CyAsHalEnableInterrupts(int_state) ;
+}
+
+/* Removes the tail node from the queue and frees it */
+void
+CyAsRemoveCBTailNode(CyAsCBQueue *queue_p)
+{
+ uint32_t int_state ;
+
+ int_state = CyAsHalDisableInterrupts () ;
+
+ if (queue_p->count > 0)
+ {
+ /*
+ * The worst case length of the queue should be under 10 elements, and the average
+ * case should be just 1 element. So, we just employ a linear search to find the node
+ * to be freed.
+ */
+ switch (queue_p->type)
+ {
+ case CYAS_FUNC_CB:
+ {
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)queue_p->head_p ;
+ CyAsFuncCBNode* tail = (CyAsFuncCBNode*)queue_p->tail_p ;
+ if (node != tail)
+ {
+ while (node->next_p != tail)
+ node = node->next_p ;
+ node->next_p = 0 ;
+ queue_p->tail_p = node ;
+ }
+ CyAsDestroyFuncCBNode (tail) ;
+ }
+ break ;
+
+ case CYAS_USB_FUNC_CB:
+ {
+ CyAsUsbFuncCBNode* node = (CyAsUsbFuncCBNode*)queue_p->head_p ;
+ CyAsUsbFuncCBNode* tail = (CyAsUsbFuncCBNode*)queue_p->tail_p ;
+ if (node != tail)
+ {
+ while (node->next_p != tail)
+ node = node->next_p ;
+ node->next_p = 0 ;
+ queue_p->tail_p = node ;
+ }
+
+ CyAsDestroyUsbFuncCBNode (tail) ;
+ }
+ break ;
+
+ case CYAS_USB_IO_CB:
+ {
+ CyAsUsbIoCBNode* node = (CyAsUsbIoCBNode*)queue_p->head_p ;
+ CyAsUsbIoCBNode* tail = (CyAsUsbIoCBNode*)queue_p->tail_p ;
+ if (node != tail)
+ {
+ while (node->next_p != tail)
+ node = node->next_p ;
+ node->next_p = 0 ;
+ queue_p->tail_p = node ;
+ }
+ CyAsDestroyUsbIoCBNode (tail) ;
+ }
+ break ;
+
+ case CYAS_STORAGE_IO_CB:
+ {
+ CyAsStorageIoCBNode* node = (CyAsStorageIoCBNode*)queue_p->head_p ;
+ CyAsStorageIoCBNode* tail = (CyAsStorageIoCBNode*)queue_p->tail_p ;
+ if (node != tail)
+ {
+ while (node->next_p != tail)
+ node = node->next_p ;
+ node->next_p = 0 ;
+ queue_p->tail_p = node ;
+ }
+ CyAsDestroyStorageIoCBNode (tail) ;
+ }
+ break ;
+
+ default:
+ CyAsHalAssert (CyFalse) ;
+ }
+
+ queue_p->count-- ;
+ if (queue_p->count == 0)
+ {
+ queue_p->head_p = 0 ;
+ queue_p->tail_p = 0 ;
+ }
+ }
+
+ CyAsHalEnableInterrupts (int_state) ;
+}
+
+/* Removes the first CyAsCBNode from the queue and frees it */
+void
+CyAsRemoveCBNode(CyAsCBQueue * queue_p)
+{
+ uint32_t int_state ;
+
+ int_state = CyAsHalDisableInterrupts() ;
+
+ CyAsHalAssert(queue_p->count >= 0) ;
+ if(queue_p->count > 0)
+ {
+ if(queue_p->type == CYAS_USB_FUNC_CB)
+ {
+ CyAsUsbFuncCBNode* node = (CyAsUsbFuncCBNode*)queue_p->head_p ;
+ queue_p->head_p = node->next_p ;
+ CyAsDestroyUsbFuncCBNode(node) ;
+ }
+ else if(queue_p->type == CYAS_USB_IO_CB)
+ {
+ CyAsUsbIoCBNode* node = (CyAsUsbIoCBNode*)queue_p->head_p ;
+ queue_p->head_p = node->next_p ;
+ CyAsDestroyUsbIoCBNode(node) ;
+ }
+ else if(queue_p->type == CYAS_STORAGE_IO_CB)
+ {
+ CyAsStorageIoCBNode* node = (CyAsStorageIoCBNode*)queue_p->head_p ;
+ queue_p->head_p = node->next_p ;
+ CyAsDestroyStorageIoCBNode(node) ;
+ }
+ else if(queue_p->type == CYAS_FUNC_CB)
+ {
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)queue_p->head_p ;
+ queue_p->head_p = node->next_p ;
+ CyAsDestroyFuncCBNode(node) ;
+ }
+ else
+ {
+ CyAsHalAssert(CyFalse) ;
+ }
+
+ queue_p->count-- ;
+ if(queue_p->count == 0)
+ {
+ queue_p->head_p = 0 ;
+ queue_p->tail_p = 0 ;
+ }
+ }
+
+ CyAsHalEnableInterrupts(int_state) ;
+}
+
+void MyPrintFuncCBNode(CyAsFuncCBNode* node)
+{
+ CyAsFunctCBType type = CyAsFunctCBTypeGetType(node->dataType) ;
+ CyAsHalPrintMessage("[cd:%2u dt:%2u cb:0x%08x d:0x%08x nt:%1i]",
+ node->client_data, type, (uint32_t)node->cb_p, (uint32_t)node->data, node->nodeType) ;
+}
+
+void MyPrintCBQueue(CyAsCBQueue* queue_p)
+{
+ uint32_t i = 0 ;
+
+ CyAsHalPrintMessage("| Count: %u Type: ", queue_p->count) ;
+
+ if(queue_p->type == CYAS_USB_FUNC_CB)
+ {
+ CyAsHalPrintMessage("USB_FUNC_CB\n") ;
+ }
+ else if(queue_p->type == CYAS_USB_IO_CB)
+ {
+ CyAsHalPrintMessage("USB_IO_CB\n") ;
+ }
+ else if(queue_p->type == CYAS_STORAGE_IO_CB)
+ {
+ CyAsHalPrintMessage("STORAGE_IO_CB\n") ;
+ }
+ else if(queue_p->type == CYAS_FUNC_CB)
+ {
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)queue_p->head_p ;
+ CyAsHalPrintMessage("FUNC_CB\n") ;
+ if(queue_p->count > 0)
+ {
+ CyAsHalPrintMessage("| Head->") ;
+
+ for(i = 0; i < queue_p->count; i++)
+ {
+ if(node)
+ {
+ CyAsHalPrintMessage("->") ;
+ MyPrintFuncCBNode(node) ;
+ node = node->next_p ;
+ }
+ else
+ CyAsHalPrintMessage("->[NULL]\n") ;
+ }
+
+ CyAsHalPrintMessage("\n| Tail->") ;
+ MyPrintFuncCBNode((CyAsFuncCBNode*)queue_p->tail_p) ;
+ CyAsHalPrintMessage("\n") ;
+ }
+ }
+ else
+ {
+ CyAsHalPrintMessage("INVALID\n") ;
+ }
+
+ CyAsHalPrintMessage("|----------\n") ;
+}
+
+
+/* Removes and frees all pending callbacks */
+void
+CyAsClearCBQueue(CyAsCBQueue * queue_p)
+{
+ uint32_t int_state = CyAsHalDisableInterrupts() ;
+
+ while(queue_p->count != 0)
+ CyAsRemoveCBNode(queue_p) ;
+
+ CyAsHalEnableInterrupts(int_state) ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscSendRequest(CyAsDevice* dev_p,
+ CyAsFunctionCallback cb,
+ uint32_t client,
+ CyAsFunctCBType type,
+ void* data,
+ CyAsCBQueue* queue,
+ uint16_t req_type,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsResponseCallback rcb)
+{
+
+ CyAsFuncCBNode* cbnode = CyAsCreateFuncCBNodeData(cb, client, type, data) ;
+ CyAsReturnStatus_t ret ;
+
+ if(cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ else
+ CyAsInsertCBNode(queue, cbnode) ;
+
+ req_p->flags |= req_type ;
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, rcb) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsRemoveCBTailNode(queue) ;
+ }
+
+ return ret ;
+}
+
+void
+CyAsMiscCancelExRequests(CyAsDevice *dev_p)
+{
+ int i ;
+ for(i = 0; i < CY_RQT_CONTEXT_COUNT; i++)
+ CyAsLLRemoveAllRequests(dev_p, dev_p->context[i]) ;
+}
+
+
+static void
+CyAsMiscFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ CyAsFuncCBNode* node = NULL ;
+ CyAsReturnStatus_t ret ;
+
+ CyBool exRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX) == CY_AS_REQUEST_RESPONSE_EX ;
+ CyBool msRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS) == CY_AS_REQUEST_RESPONSE_MS ;
+ uint8_t code ;
+ uint32_t type ;
+ uint8_t cntxt ;
+
+ CyAsHalAssert(exRequest || msRequest) ;
+ (void) exRequest;
+ (void) msRequest;
+ (void)context ;
+
+ cntxt = CyAsLLRequestResponse_GetContext(rqt) ;
+ code = CyAsLLRequestResponse_GetCode(rqt) ;
+
+ switch(cntxt)
+ {
+ case CY_RQT_GENERAL_RQT_CONTEXT:
+ CyAsHalAssert(dev_p->func_cbs_misc->count != 0) ;
+ CyAsHalAssert(dev_p->func_cbs_misc->type == CYAS_FUNC_CB) ;
+ node = (CyAsFuncCBNode*)dev_p->func_cbs_misc->head_p ;
+ type = CyAsFunctCBTypeGetType(node->dataType) ;
+
+ switch(code)
+ {
+ case CY_RQT_GET_FIRMWARE_VERSION:
+ CyAsHalAssert(node->data != 0) ;
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_GETFIRMWAREVERSION) ;
+ ret = MyHandleResponseGetFirmwareVersion(dev_p, rqt, resp, (CyAsGetFirmwareVersionData*)node->data) ;
+ break ;
+ case CY_RQT_READ_MCU_REGISTER:
+ CyAsHalAssert(node->data != 0) ;
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_READMCUREGISTER) ;
+ ret = MyHandleResponseReadMCURegister(dev_p, rqt, resp, (uint8_t*)node->data) ;
+ break ;
+ case CY_RQT_GET_GPIO_STATE:
+ CyAsHalAssert(node->data != 0) ;
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_GETGPIOVALUE) ;
+ ret = MyHandleResponseGetGpioValue(dev_p, rqt, resp, (uint8_t*)node->data) ;
+ break ;
+ case CY_RQT_SET_SD_CLOCK_FREQ:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_SETSDFREQ) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_CONTROL_ANTIOCH_HEARTBEAT:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_HEARTBEATCONTROL) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_WRITE_MCU_REGISTER:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_WRITEMCUREGISTER) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_STORAGE_MEDIA_CHANGED:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_STORAGECHANGED) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_SET_GPIO_STATE:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_SETGPIOVALUE) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_SET_TRACE_LEVEL:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_SETTRACELEVEL) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ if (ret == CY_AS_ERROR_INVALID_RESPONSE)
+ ret = CY_AS_ERROR_NOT_SUPPORTED ;
+ break ;
+ case CY_RQT_PREPARE_FOR_STANDBY:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_ENTERSTANDBY) ;
+ ret = MyHandleResponseEnterStandby(dev_p, rqt, resp, (CyBool)node->data) ;
+ break ;
+ case CY_RQT_ENTER_SUSPEND_MODE:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_ENTERSUSPEND) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDeviceSetSuspendMode(dev_p) ;
+ }
+ break ;
+ case CY_RQT_RESERVE_LNA_BOOT_AREA:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_RESERVELNABOOTAREA) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_SDPOLARITY:
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_SETSDPOLARITY) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+
+
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+ break ;
+
+ case CY_RQT_RESOURCE_RQT_CONTEXT:
+ CyAsHalAssert(dev_p->func_cbs_res->count != 0) ;
+ CyAsHalAssert(dev_p->func_cbs_res->type == CYAS_FUNC_CB) ;
+ node = (CyAsFuncCBNode*)dev_p->func_cbs_res->head_p ;
+ type = CyAsFunctCBTypeGetType(node->dataType) ;
+
+ switch(code)
+ {
+ case CY_RQT_ACQUIRE_RESOURCE:
+ /* The node->data field is actually an enum value which could be
+ 0, thus no assert is done */
+ CyAsHalAssert(type == CY_FUNCT_CB_MISC_ACQUIRERESOURCE) ;
+ ret = MyHandleResponseAcquireResource(dev_p, rqt, resp, (CyAsResourceType*)node->data) ;
+ break ;
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+ break ;
+
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /*
+ * If the low level layer returns a direct error, use the corresponding error code.
+ * If not, use the error code based on the response from firmware.
+ */
+ if (stat == CY_AS_ERROR_SUCCESS)
+ stat = ret ;
+
+ /* Call the user Callback */
+ node->cb_p((CyAsDeviceHandle)dev_p, stat, node->client_data, (CyAsFunctCBType)node->dataType, node->data) ;
+ if(cntxt == CY_RQT_GENERAL_RQT_CONTEXT)
+ CyAsRemoveCBNode(dev_p->func_cbs_misc) ;
+ else
+ CyAsRemoveCBNode(dev_p->func_cbs_res) ;
+
+}
+
+
+/* This includes the implementation of the deprecated functions for backward
+ * compatibility
+ */
+#include "cyasmisc_dep_impl.h"
+
+/*[]*/
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasmisc_dep_impl.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,71 @@
+/* Cypress West Bridge API source file (cyasmisc_dep_impl.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/* This c file will contain Antioch specific implementation
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility
+ */
+CyAsReturnStatus_t
+CyAsMiscAcquireResource_dep(CyAsDeviceHandle handle,
+ CyAsResourceType resource,
+ CyBool force)
+{
+ CyAsResourceType *resource_p, my_resource = resource;
+ resource_p = &my_resource;
+ return CyAsMiscAcquireResource(handle, resource_p, force, 0, 0);
+}
+
+
+CyAsReturnStatus_t
+CyAsMiscGetFirmwareVersion_dep(CyAsDeviceHandle handle,
+ uint16_t *major,
+ uint16_t *minor,
+ uint16_t *build,
+ uint8_t *mediaType,
+ CyBool *isDebugMode)
+{
+ CyAsGetFirmwareVersionData data ;
+ CyAsReturnStatus_t status = CyAsMiscGetFirmwareVersion(handle, &data, 0, 0) ;
+ *major = data.major ;
+ *minor = data.minor ;
+ *build = data.build ;
+ *mediaType = data.mediaType ;
+ *isDebugMode = data.isDebugMode ;
+ return status ;
+}
+
+CyAsReturnStatus_t
+CyAsMiscSetTraceLevel_dep(CyAsDeviceHandle handle,
+ uint8_t level,
+ CyAsMediaType media,
+ uint32_t device,
+ uint32_t unit,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsBusNumber_t bus ;
+ if(media >= CyAsMediaMaxMediaValue) return CY_AS_ERROR_NOT_SUPPORTED;
+ CyAsBusFromMediaType(media, &bus) ;
+ return CyAsMiscSetTraceLevel(handle, level, bus, device, unit, cb, client) ;
+}
+
+
+/*[]*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasmtp.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1073 @@
+/* Cypress West Bridge API header file (cyasmtp.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasmtp.h"
+#include "cyaserr.h"
+#include "cyasdma.h"
+#include "cyaslowlevel.h"
+
+static void
+CyAsMTPFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat) ;
+
+static CyAsReturnStatus_t
+IsMTPActive(CyAsDevice *dev_p)
+{
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->mtp_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+MyMtpRequestCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *resp_p,
+ CyAsReturnStatus_t ret)
+{
+ uint16_t val, ev, status ;
+ uint16_t mtp_datalen = 0 ;
+ uint32_t bytecount_l, bytecount_h ;
+ CyAsMTPSendObjectCompleteData sendObjData ;
+ CyAsMTPGetObjectCompleteData getObjData ;
+ CyAsDmaEndPoint *ep_p ;
+
+ uint8_t code = CyAsLLRequestResponse_GetCode(req_p) ;
+
+ (void)resp_p ;
+ (void)context ;
+ (void)ret ;
+
+ switch(code)
+ {
+ case CY_RQT_MTP_EVENT:
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ status = (val >> 8) & 0xFF ; /* MSB indicates status of read/write */
+ ev = val & 0xFF ; /* event type */
+ switch(ev)
+ {
+ case 0: /* SendObject Complete */
+ {
+ bytecount_l = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ bytecount_h = CyAsLLRequestResponse_GetWord(req_p, 2) ;
+ sendObjData.byte_count = (bytecount_h << 16) | bytecount_l ;
+
+ sendObjData.status = status ;
+
+ /* use the byte count again */
+ bytecount_l = CyAsLLRequestResponse_GetWord(req_p, 3) ;
+ bytecount_h = CyAsLLRequestResponse_GetWord(req_p, 4) ;
+ sendObjData.transaction_id = (bytecount_h << 16) | bytecount_l ;
+
+ dev_p->mtp_turbo_active = CyFalse ;
+
+ if (dev_p->mtp_event_cb)
+ dev_p->mtp_event_cb((CyAsDeviceHandle)dev_p, CyAsMTPSendObjectComplete,
+ &sendObjData) ;
+ }
+ break ;
+
+ case 1: /* GetObject Complete */
+ {
+ bytecount_l = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ bytecount_h = CyAsLLRequestResponse_GetWord(req_p, 2) ;
+
+ getObjData.byte_count = (bytecount_h << 16) | bytecount_l ;
+ getObjData.status = status ;
+
+ dev_p->mtp_turbo_active = CyFalse ;
+
+ if (dev_p->mtp_event_cb)
+ dev_p->mtp_event_cb((CyAsDeviceHandle)dev_p, CyAsMTPGetObjectComplete,
+ &getObjData);
+ }
+ break ;
+
+ case 2: /* BlockTable Needed */
+ {
+ if (dev_p->mtp_event_cb)
+ dev_p->mtp_event_cb((CyAsDeviceHandle)dev_p, CyAsMTPBlockTableNeeded, 0);
+ }
+ break ;
+ default:
+ CyAsHalPrintMessage("Invalid event type\n") ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_TUR_RQT_CONTEXT, CY_RESP_MTP_INVALID_EVENT, sizeof(ev), &ev) ;
+ break ;
+ }
+ break ;
+
+ case CY_RQT_TURBO_CMD_FROM_HOST:
+ {
+ mtp_datalen = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+
+ /* Get the endpoint pointer based on the endpoint number */
+ ep_p = CY_AS_NUM_EP(dev_p, CY_AS_MTP_READ_ENDPOINT) ;
+
+ /* The event should arrive only after the DMA operation has been queued. */
+ CyAsHalAssert(ep_p->queue_p != 0) ;
+
+ /* Put the len in ep data information in dmaqueue and kick start the queue */
+ CyAsHalAssert(ep_p->queue_p->size >= mtp_datalen) ;
+
+ if (mtp_datalen == 0)
+ {
+ CyAsDmaCompletedCallback(dev_p->tag, CY_AS_MTP_READ_ENDPOINT, 0, CY_AS_ERROR_SUCCESS) ;
+ }
+ else
+ {
+ ep_p->maxhwdata = mtp_datalen ;
+
+ /*
+ * Make sure that the DMA status for this EP is not running, so that
+ * the call to CyAsDmaKickStart gets this transfer going.
+ * Note: In MTP mode, we never leave a DMA transfer of greater than one
+ * packet running. So, it is okay to override the status here and start
+ * the next packet transfer.
+ */
+ CyAsDmaEndPointSetStopped(ep_p) ;
+
+ /* Kick start the queue if it is not running */
+ CyAsDmaKickStart(dev_p, CY_AS_MTP_READ_ENDPOINT) ;
+ }
+ }
+ break ;
+
+ case CY_RQT_TURBO_START_WRITE_DMA:
+ {
+ /*
+ * Now that the firmware is ready to receive the next packet of data, start
+ * the corresponding DMA transfer. First, ensure that a DMA operation is still
+ * pending in the queue for the write endpoint.
+ */
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_TUR_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+
+ ep_p = CY_AS_NUM_EP(dev_p, CY_AS_MTP_WRITE_ENDPOINT) ;
+ CyAsHalAssert (ep_p->queue_p != 0) ;
+
+ CyAsDmaEndPointSetStopped(ep_p) ;
+ CyAsDmaKickStart(dev_p, CY_AS_MTP_WRITE_ENDPOINT) ;
+ }
+ break ;
+
+ default:
+ CyAsHalPrintMessage("Invalid request received on TUR context\n") ;
+ val = req_p->box0 ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_TUR_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;
+ break ;
+ }
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseNoData(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseMTPStart(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ dev_p->mtp_count++ ;
+
+ CyAsDmaEnableEndPoint(dev_p, CY_AS_MTP_READ_ENDPOINT, CyTrue, CyAsDirectionOut) ;
+ dev_p->usb_config[CY_AS_MTP_READ_ENDPOINT].enabled = CyTrue ;
+ dev_p->usb_config[CY_AS_MTP_READ_ENDPOINT].dir = CyAsUsbOut ;
+ dev_p->usb_config[CY_AS_MTP_READ_ENDPOINT].type = CyAsUsbBulk ;
+
+ CyAsDmaEnableEndPoint(dev_p, CY_AS_MTP_WRITE_ENDPOINT, CyTrue, CyAsDirectionIn) ;
+ dev_p->usb_config[CY_AS_MTP_WRITE_ENDPOINT].enabled = CyTrue ;
+ dev_p->usb_config[CY_AS_MTP_WRITE_ENDPOINT].dir = CyAsUsbIn ;
+ dev_p->usb_config[CY_AS_MTP_WRITE_ENDPOINT].type = CyAsUsbBulk ;
+
+ CyAsDmaSetMaxDmaSize(dev_p, 0x02, 0x0200) ; /* Packet size is 512 bytes */
+ CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x40) ; /* Packet size is 64 bytes until a switch to high speed happens. */
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+
+ CyAsDeviceClearMSSPending(dev_p) ;
+
+ return ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsMTPStart(CyAsDeviceHandle handle,
+ CyAsMTPEventCallback eventCB,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice* dev_p ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if(CyAsDeviceIsMSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (dev_p->usb_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (dev_p->is_mtp_firmware == 0)
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ CyAsDeviceSetMSSPending(dev_p) ;
+
+ if (dev_p->mtp_count == 0)
+ {
+
+ dev_p->mtp_event_cb = eventCB ;
+ /*
+ * We register here becuase the start request may cause events to occur before the
+ * response to the start request.
+ */
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_TUR_RQT_CONTEXT, MyMtpRequestCallback) ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_MTP, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ CyAsDeviceClearMSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsDeviceClearMSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseMTPStart(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_START,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else
+ {
+ dev_p->mtp_count++ ;
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_MTP_START, 0) ;
+ }
+
+ CyAsDeviceClearMSSPending(dev_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseMTPStop(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /*
+ * We sucessfully shutdown the stack, so decrement to make the count
+ * zero.
+ */
+ dev_p->mtp_count-- ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+
+ CyAsDeviceClearMSSPending(dev_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPStop(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsMTPStop called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsMTPActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if(CyAsDeviceIsMSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ CyAsDeviceSetMSSPending(dev_p) ;
+
+ if (dev_p->mtp_count == 1)
+ {
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STOP_MTP, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseMTPStop(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_STOP,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else if (dev_p->mtp_count > 1)
+ {
+
+ dev_p->mtp_count-- ;
+
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_MTP_STOP, 0) ;
+ }
+
+ CyAsDeviceClearMSSPending(dev_p) ;
+
+ return ret ;
+}
+
+static void
+MtpWriteCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ CyAsHalAssert(context == CY_RQT_TUR_RQT_CONTEXT) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ }
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ /* Firmware failed the request. Cancel the DMA transfer. */
+ CyAsDmaCancel(dev_p, 0x04, CY_AS_ERROR_CANCELED) ;
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ }
+
+ CyAsLLDestroyResponse(dev_p, resp) ;
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+}
+
+static void
+AsyncWriteRequestCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ CyAsDeviceHandle h ;
+ CyAsFunctionCallback cb ;
+
+ (void)size ;
+ (void)buf_p ;
+ (void)ep ;
+
+
+ CyAsLogDebugMessage(6, "AsyncWriteRequestCallback called") ;
+
+ h = (CyAsDeviceHandle)dev_p ;
+
+ cb = dev_p->mtp_cb ;
+ dev_p->mtp_cb = 0 ;
+
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+
+ if (cb)
+ cb(h, err, dev_p->mtp_client, dev_p->mtp_op, 0) ;
+
+}
+
+static void
+SyncMTPCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ (void)ep ;
+ (void)buf_p ;
+ (void)size ;
+
+ dev_p->mtp_error = err ;
+}
+
+static CyAsReturnStatus_t
+CyAsMTPOperation(CyAsDevice *dev_p,
+ CyAsMTPBlockTable* blk_table,
+ uint32_t num_bytes,
+ uint32_t transaction_id,
+ CyAsFunctionCallback cb,
+ uint32_t client,
+ uint8_t rqttype
+ )
+{
+ CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint32_t mask = 0 ;
+ CyAsFunctCBType mtp_cb_op = (CyAsFunctCBType)0 ;
+ uint16_t size = 2 ;
+
+ if(dev_p->mtp_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (rqttype == CY_RQT_INIT_SEND_OBJECT)
+ {
+ mtp_cb_op = CY_FUNCT_CB_MTP_INIT_SEND_OBJECT ;
+ dev_p->mtp_turbo_active = CyTrue ;
+ }
+ else if (rqttype == CY_RQT_INIT_GET_OBJECT)
+ {
+ mtp_cb_op = CY_FUNCT_CB_MTP_INIT_GET_OBJECT ;
+ dev_p->mtp_turbo_active = CyTrue ;
+ }
+ else
+ mtp_cb_op = CY_FUNCT_CB_MTP_SEND_BLOCK_TABLE ;
+
+ ret = IsMTPActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CY_RQT_INIT_GET_OBJECT == rqttype)
+ {
+ size = 4 ;
+ }
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, rqttype, CY_RQT_TUR_RQT_CONTEXT, size) ;
+ if (req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)(num_bytes & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((num_bytes >> 16) & 0xFFFF)) ;
+
+ /* If it is GET_OBJECT, send transaction id as well */
+ if (CY_RQT_INIT_GET_OBJECT == rqttype)
+ {
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(transaction_id & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)((transaction_id >> 16) & 0xFFFF)) ;
+ }
+
+ if(cb == 0)
+ {
+ /* Queue the DMA request for block table write */
+ ret = CyAsDmaQueueRequest(dev_p, 4, blk_table, sizeof(CyAsMTPBlockTable), CyFalse, CyFalse, SyncMTPCallback) ;
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, 4, CY_AS_ERROR_CANCELED) ;
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+
+ goto destroy ;
+ }
+
+ ret = CyAsDmaDrainQueue(dev_p, 4, CyTrue) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = dev_p->mtp_error ;
+ goto destroy ;
+ }
+ else
+ {
+#if 0
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_INIT_SEND_OBJECT,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+#endif
+
+ /* Protection from interrupt driven code */
+ /* since we are using storage EP4 check if any storage activity is pending */
+ mask = CyAsHalDisableInterrupts() ;
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+ CyAsDeviceSetStorageAsyncPending(dev_p) ;
+ CyAsHalEnableInterrupts(mask) ;
+
+ dev_p->mtp_cb = cb ;
+ dev_p->mtp_client = client ;
+ dev_p->mtp_op = mtp_cb_op ;
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, MtpWriteCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = CyAsDmaQueueRequest(dev_p, 4, blk_table, sizeof(CyAsMTPBlockTable), CyFalse, CyFalse, AsyncWriteRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Kick start the queue if it is not running */
+ CyAsDmaKickStart(dev_p, 4) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPInitSendObject(CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* blk_table,
+ uint32_t num_bytes,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsDevice* dev_p ;
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ return CyAsMTPOperation(dev_p, blk_table, num_bytes, 0, cb, client, CY_RQT_INIT_SEND_OBJECT) ;
+
+}
+
+CyAsReturnStatus_t
+CyAsMTPInitGetObject(CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* blk_table,
+ uint32_t num_bytes,
+ uint32_t transaction_id,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsDevice* dev_p ;
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ return CyAsMTPOperation(dev_p, blk_table, num_bytes, transaction_id, cb, client, CY_RQT_INIT_GET_OBJECT) ;
+
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseCancelSendObject(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPCancelSendObject(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice*dev_p ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if(dev_p->mtp_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CANCEL_SEND_OBJECT, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseCancelSendObject(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_CANCEL_SEND_OBJECT,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseCancelGetObject(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPCancelGetObject(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice*dev_p ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if(dev_p->mtp_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CANCEL_GET_OBJECT, CY_RQT_TUR_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseCancelGetObject(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_CANCEL_GET_OBJECT,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPSendBlockTable(CyAsDeviceHandle handle,
+ CyAsMTPBlockTable* blk_table,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsDevice* dev_p ;
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ return CyAsMTPOperation(dev_p, blk_table, 0, 0, cb, client, CY_RQT_SEND_BLOCK_TABLE) ;
+}
+
+static void
+CyAsMTPFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)dev_p->func_cbs_mtp->head_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code ;
+ CyBool delay_callback = CyFalse ;
+
+ CyAsHalAssert(dev_p->func_cbs_mtp->count != 0) ;
+ CyAsHalAssert(dev_p->func_cbs_mtp->type == CYAS_FUNC_CB) ;
+
+ (void)context ;
+
+ /* The Handlers are responsible for Deleting the rqt and resp when
+ * they are finished
+ */
+ code = CyAsLLRequestResponse_GetCode(rqt) ;
+ switch(code)
+ {
+ case CY_RQT_START_MTP:
+ ret = MyHandleResponseMTPStart(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_STOP_MTP:
+ ret = MyHandleResponseMTPStop(dev_p, rqt, resp, stat) ;
+ break ;
+#if 0
+ case CY_RQT_INIT_SEND_OBJECT:
+ ret = MyHandleResponseInitSendObject(dev_p, rqt, resp, stat, CyTrue) ;
+ delay_callback = CyTrue ;
+ break ;
+#endif
+ case CY_RQT_CANCEL_SEND_OBJECT:
+ ret = MyHandleResponseCancelSendObject(dev_p, rqt, resp, stat) ;
+ break ;
+#if 0
+ case CY_RQT_INIT_GET_OBJECT:
+ ret = MyHandleResponseInitGetObject(dev_p, rqt, resp, stat, CyTrue) ;
+ delay_callback = CyTrue ;
+ break ;
+#endif
+ case CY_RQT_CANCEL_GET_OBJECT:
+ ret = MyHandleResponseCancelGetObject(dev_p, rqt, resp, stat) ;
+ break ;
+#if 0
+ case CY_RQT_SEND_BLOCK_TABLE:
+ ret = MyHandleResponseSendBlockTable(dev_p, rqt, resp, stat, CyTrue) ;
+ delay_callback = CyTrue ;
+ break ;
+#endif
+ case CY_RQT_ENABLE_USB_PATH:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ dev_p->is_storage_only_mode = CyFalse ;
+ break ;
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /*
+ * If the low level layer returns a direct error, use the corresponding error code.
+ * If not, use the error code based on the response from firmware.
+ */
+ if (stat == CY_AS_ERROR_SUCCESS)
+ stat = ret ;
+
+ if(!delay_callback)
+ {
+ node->cb_p((CyAsDeviceHandle)dev_p, stat, node->client_data, (CyAsFunctCBType)node->dataType, node->data) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_mtp) ;
+ }
+}
+
+CyAsReturnStatus_t
+CyAsMTPStorageOnlyStart(CyAsDeviceHandle handle)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ dev_p->is_storage_only_mode = CyTrue ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsMTPStorageOnlyStop(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (dev_p->is_storage_only_mode == CyFalse)
+ return CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_ENABLE_USB_PATH, CY_RQT_TUR_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ dev_p->is_storage_only_mode = CyFalse ;
+ return ret ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_MTP_STOP_STORAGE_ONLY,
+ 0, dev_p->func_cbs_mtp, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsMTPFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasprotocol.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,3718 @@
+/* Cypress West Bridge API header file (cyasprotocol.h)
+ ## ===========================
+ ##
+ ## Copyright Cypress Semiconductor Corporation, 2006-2009,
+ ## All Rights Reserved
+ ## UNPUBLISHED, LICENSED SOFTWARE.
+ ##
+ ## CONFIDENTIAL AND PROPRIETARY INFORMATION
+ ## WHICH IS THE PROPERTY OF CYPRESS.
+ ##
+ ## Use of this file is governed
+ ## by the license agreement included in the file
+ ##
+ ## <install>/license/license.txt
+ ##
+ ## where <install> is the Cypress software
+ ## installation root directory path.
+ ##
+ ## ===========================
+*/
+
+#ifndef _INCLUDED_CYASPROTOCOL_H_
+#define _INCLUDED_CYASPROTOCOL_H_
+
+/*
+ * Constants defining the per context buffer sizes
+ */
+#ifndef __doxygen__
+#define CY_CTX_GEN_MAX_DATA_SIZE (8)
+#define CY_CTX_RES_MAX_DATA_SIZE (8)
+#define CY_CTX_STR_MAX_DATA_SIZE (64)
+#define CY_CTX_USB_MAX_DATA_SIZE (130 + 23)
+#define CY_CTX_TUR_MAX_DATA_SIZE (12)
+#endif
+
+/* Summary
+ This response indicates a command has been processed and returned a status.
+
+ Direction
+ West Bridge -> P Port Processor
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = all
+ * Response Code = 0
+
+ D0
+ * 0 = success (CY_AS_ERROR_SUCCESS)
+ * non-zero = error code
+
+ Description
+ This response indicates that a request was processed and no data
+ was generated as a result of the request beyond a single 16 bit
+ status value. This response contains the 16 bit data value.
+ */
+#define CY_RESP_SUCCESS_FAILURE (0)
+
+/* Summary
+ This response indicates an invalid request was sent
+
+ Direction
+ West Bridge -> P Port Processor
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = all
+ * Response Code = 1
+
+ D0
+ * Mailbox contents for invalid request
+
+ Description
+ This response is returned when a request is sent that contains an invalid
+ context or request code.
+*/
+#define CY_RESP_INVALID_REQUEST (1)
+
+/* Summary
+ This response indicates a request of invalid length was sent
+
+ Direction
+ West Bridge -> P Port Processor
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = all
+ * Response Code = 2
+
+ D0
+ * Mailbox contenxt for invalid request
+ * Length for invalid request
+
+ Description
+ The software API and firmware sends requests across the P Port to West Bridge
+ interface on different contexts. Each contexts has a maximum size of the
+ request packet that can be received. The size of a request can be determined
+ during the first cycle of a request transfer. If the request is larger
+ than can be handled by the receiving context this response is returned. Note
+ that the complete request is received before this response is sent, but that
+ the request is dropped after this response is sent.
+*/
+#define CY_RESP_INVALID_LENGTH (2)
+
+
+/* Summary
+ This response indicates a request was made to an invalid storage address.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = all
+ * Response Code = 0
+
+ D0
+ Bits 15 - 12 : Media Type
+ * 0 = NAND
+ * 1 = SD Flash
+ * 2 = MMC Flash
+ * 3 = CE-ATA
+
+ Bits 11 - 8 : Zero based device index
+
+ Bits 7 - 0 : Zero based unit index
+
+ D1
+ Upper 16 bits of block address
+
+ D2
+ Lower 16 bits of block address
+
+ D3
+ Portion of address that is invalid
+ * 0 = Media Type
+ * 1 = Device Index
+ * 2 = Unit Index
+ * 3 = Block Address
+
+ Description
+ This response indicates a request to an invalid storage media
+ address
+ */
+#define CY_RESP_NO_SUCH_ADDRESS (3)
+
+
+/******************************************************/
+
+/*@@General requests
+ Summary
+ The general requests include:
+ * CY_RQT_GET_FIRMWARE_VERSION
+ * CY_RQT_SET_TRACE_LEVEL
+ * CY_RQT_INITIALIZATION_COMPLETE
+ * CY_RQT_READ_MCU_REGISTER
+ * CY_RQT_WRITE_MCU_REGISTER
+ * CY_RQT_STORAGE_MEDIA_CHANGED
+ * CY_RQT_CONTROL_ANTIOCH_HEARTBEAT
+ * CY_RQT_PREPARE_FOR_STANDBY
+ * CY_RQT_ENTER_SUSPEND_MODE
+ * CY_RQT_OUT_OF_SUSPEND
+ * CY_RQT_GET_GPIO_STATE
+ * CY_RQT_SET_GPIO_STATE
+ * CY_RQT_SET_SD_CLOCK_FREQ
+ * CY_RQT_WB_DEVICE_MISMATCH
+ * CY_RQT_BOOTLOAD_NO_FIRMWARE
+ * CY_RQT_RESERVE_LNA_BOOT_AREA
+ * CY_RQT_ABORT_P2S_XFER
+ */
+
+#ifndef __doxygen__
+#define CY_RQT_GENERAL_RQT_CONTEXT (0)
+#endif
+
+/* Summary
+ This command returns the firmware version number, media types supported and
+ debug/release mode information.
+
+ Direction
+ P Port Processor-> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request Code = 0
+
+ Description
+ The response contains the 16-bit major version, the 16-bit minor version,
+ the 16 bit build number, media types supported and release/debug mode
+ information.
+
+ Responses
+ * CY_RESP_FIRMWARE_VERSION
+ */
+#define CY_RQT_GET_FIRMWARE_VERSION (0)
+
+
+/* Summary
+ This command changes the trace level and trace information destination within
+ the West Bridge firmware.
+
+ Direction
+ P Port Processor-> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request Code = 1
+
+ D0
+ Trace Level
+ * 0 = no trace information
+ * 1 = state information
+ * 2 = function call
+ * 3 = function call with args/return value
+
+ D1
+ Bits 12 - 15 : MediaType
+ * 0 = NAND
+ * 1 = SDIO Flash
+ * 2 = MMC Flash
+ * 3 = CE-ATA
+
+ Bits 8 - 11 : Zero based device index
+
+ Bits 0 - 7 : Zero based unit index
+
+ Description
+ The West Bridge firmware contains debugging facilities that can be used to trace the
+ execution of the firmware. This request sets the level of tracing information that
+ is stored and the location where it is stored.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_SET_TRACE_LEVEL (1)
+
+/* Summary
+ This command indicates that the firmware is up and ready for communications with the
+ P port processor.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 0
+ * Request Code = 3
+
+ D0
+ Major Version
+
+ D1
+ Minor Version
+
+ D2
+ Build Number
+
+ D3
+ Bits 15-8: Media types supported on Bus 1.
+ Bits 7-0: Media types supported on Bus 0.
+ Bits 8, 0: NAND support.
+ * 0: NAND is not supported.
+ * 1: NAND is supported.
+ Bits 9, 1: SD memory card support.
+ * 0: SD memory card is not supported.
+ * 1: SD memory card is supported.
+ Bits 10, 2: MMC card support.
+ * 0: MMC card is not supported.
+ * 1: MMC card is supported.
+ Bits 11, 3: CEATA drive support
+ * 0: CEATA drive is not supported.
+ * 1: CEATA drive is supported.
+ Bits 12, 4: SD IO card support.
+ * 0: SD IO card is not supported.
+ * 1: SD IO card is supported.
+
+ D4
+ Bits 15 - 8 : MTP information
+ * 0 : MTP not supported in firmware
+ * 1 : MTP supported in firmware
+ Bits 7 - 0 : Debug/Release mode information.
+ * 0 : Release mode
+ * 1 : Debug mode
+
+ Description
+ When the West Bridge firmware is loaded it being by performing initialization. Initialization must
+ be complete before West Bridge is ready to accept requests from the P port processor. This request
+ is sent from West Bridge to the P port processor to indicate that initialization is complete.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_INITIALIZATION_COMPLETE (3)
+
+/* Summary
+ This command requests the firmware to read and return the contents of a MCU accessible
+ register.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 4
+
+ D0
+ Address of register to read
+
+ Description
+ This debug command allows the processor to read the contents of a MCU accessible register.
+
+ Responses
+ * CY_RESP_MCU_REGISTER_DATA
+ */
+#define CY_RQT_READ_MCU_REGISTER (4)
+
+/* Summary
+ This command requests the firmware to write to an MCU accessible register.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 5
+
+ D0
+ Address of register to be written
+
+ D1
+ Bits 15 - 8 : Mask to be applied to existing data.
+ Bits 7 - 0 : Data to be ORed with masked data.
+
+ Description
+ This debug command allows the processor to write to an MCU accessible register.
+ Note: This has to be used with caution, and is supported by the firmware only
+ in special debug builds.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_WRITE_MCU_REGISTER (5)
+
+/* Summary
+ This command tells the West Bridge firmware that a change in storage media has been detected.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 6
+
+ Description
+ If the insertion or removal of SD or MMC cards is detected by hardware external to West Bridge,
+ this command is used to tell the West Bridge firmware to re-initialize the storage controlled by
+ the device.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+*/
+#define CY_RQT_STORAGE_MEDIA_CHANGED (6)
+
+/* Summary
+ This command enables/disables the periodic heartbeat message from the West Bridge firmware to
+ the processor.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 7
+
+ Description
+ This command enables/disables the periodic heartbeat message from the West Bridge firmware to
+ the processor. The heartbeat message is left enabled by default, and can lead to a loss
+ in performance on the P port interface.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_CONTROL_ANTIOCH_HEARTBEAT (7)
+
+/* Summary
+ This command requests the West Bridge firmware to prepare for the device going into standby
+ mode.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 8
+
+ Description
+ This command is sent by the processor to the West Bridge as preparation for going into
+ standby mode. The request allows the firmware to complete any pending/cached storage
+ operations before going into the low power state.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_PREPARE_FOR_STANDBY (8)
+
+/* Summary
+ Requests the firmware to go into suspend mode.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 9
+
+ D0
+ Bits 7-0: Wakeup control information.
+
+ Description
+ This command is sent by the processor to the West Bridge to request the device
+ to be placed in suspend mode. The firmware will complete any pending/cached storage
+ operations before going into the low power state.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_ENTER_SUSPEND_MODE (9)
+
+/* Summary
+ Indicates that the device has left suspend mode.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 10
+
+ Description
+ This message is sent by the West Bridge to the Processor to indicate that the device
+ has woken up from suspend mode, and is ready to accept new requests.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_OUT_OF_SUSPEND (10)
+
+/* Summary
+ Request to get the current state of an West Bridge GPIO pin.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 11
+
+ D0
+ Bits 15 - 8 : GPIO pin identifier
+
+ Responses
+ * CY_RESP_GPIO_STATE
+
+ Description
+ Request from the processor to get the current state of an West Bridge GPIO pin.
+ */
+#define CY_RQT_GET_GPIO_STATE (11)
+
+/* Summary
+ Request to update the output value on an West Bridge GPIO pin.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 12
+
+ D0
+ Bits 15 - 8 : GPIO pin identifier
+ Bit 0 : Desired output state
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+
+ Description
+ Request from the processor to update the output value on an West Bridge GPIO pin.
+ */
+#define CY_RQT_SET_GPIO_STATE (12)
+
+/* Summary
+ Set the clock frequency on the SD interface of the West Bridge device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 13
+
+ D0
+ Bit 8: Type of SD/MMC media
+ 0 = low speed media
+ 1 = high speed media
+ Bit 0: Clock frequency selection
+ 0 = Default frequency
+ 1 = Alternate frequency (24 MHz in both cases)
+
+ Description
+ This request is sent by the processor to set the operating clock
+ frequency used on the SD interface of the device.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_SET_SD_CLOCK_FREQ (13)
+
+/* Summary
+ Indicates the firmware downloaded to West Bridge cannot run on the active device.
+
+ Direction
+ West Bridge -> P Port processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 14
+
+ Description
+ Some versions of West Bridge firmware can only run on specific types/versions of
+ the West Bridge device. This error is returned when a firmware image is downloaded
+ onto a device that does not support it.
+
+ Responses
+ * None
+ */
+#define CY_RQT_WB_DEVICE_MISMATCH (14)
+
+/* Summary
+ This command is indicates that no firmware was found in the storage media.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 0
+ * Request code = 15
+
+ Description
+ The command is received only in case of silicon with bootloader ROM. The device sends
+ the request if there is no firmware image found in the storage media or the image is
+ corrupted. The device is waiting for P port to download a valid firmware image.
+
+ Responses
+ * None
+ */
+#define CY_RQT_BOOTLOAD_NO_FIRMWARE (15)
+
+/* Summary
+ This command reserves first numzones zones of nand device for storing processor boot image.
+
+ Direction
+ P Port Processor-> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request Code = 16
+
+ D0
+ Bits 7-0: numzones
+
+ Description
+ The first numzones zones in nand device will be used for storing proc boot image. LNA firmware in Astoria will
+ work on this nand area and boots the processor which will then use the remaining nand for usual purposes.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_RESERVE_LNA_BOOT_AREA (16)
+
+/* Summary
+ This command cancels the processing of a P2S operation in firmware.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request Code = 17
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+*/
+#define CY_RQT_ABORT_P2S_XFER (17)
+
+/*
+ * Used for debugging, ignore for normal operations
+ */
+#ifndef __doxygen__
+#define CY_RQT_DEBUG_MESSAGE (127)
+#endif
+
+/******************************************************/
+
+/*@@General responses
+ Summary
+ The general responses include:
+ * CY_RESP_FIRMWARE_VERSION
+ * CY_RESP_MCU_REGISTER_DATA
+ * CY_RESP_GPIO_STATE
+ */
+
+
+/* Summary
+ This response indicates success and contains the firmware version number, media types supported
+ by the firmware and release/debug mode information.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 0
+ * Response Code = 16
+
+ D0
+ Major Version
+
+ D1
+ Minor Version
+
+ D2
+ Build Number
+
+ D3
+ Bits 15-8: Media types supported on Bus 1.
+ Bits 7-0: Media types supported on Bus 0.
+ Bits 8, 0: NAND support.
+ * 0: NAND is not supported.
+ * 1: NAND is supported.
+ Bits 9, 1: SD memory card support.
+ * 0: SD memory card is not supported.
+ * 1: SD memory card is supported.
+ Bits 10, 2: MMC card support.
+ * 0: MMC card is not supported.
+ * 1: MMC card is supported.
+ Bits 11, 3: CEATA drive support
+ * 0: CEATA drive is not supported.
+ * 1: CEATA drive is supported.
+ Bits 12, 4: SD IO card support.
+ * 0: SD IO card is not supported.
+ * 1: SD IO card is supported.
+
+ D4
+ Bits 15 - 8 : MTP information
+ * 0 : MTP not supported in firmware
+ * 1 : MTP supported in firmware
+ Bits 7 - 0 : Debug/Release mode information.
+ * 0 : Release mode
+ * 1 : Debug mode
+
+ Description
+ This reponse is sent to return the firmware version number to the requestor.
+ */
+#define CY_RESP_FIRMWARE_VERSION (16)
+
+/* Summary
+ This response returns the contents of a MCU accessible register to the processor.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Response code = 17
+
+ D0
+ Bits 7 - 0 : MCU register contents
+
+ Description
+ This response is sent by the firmware in response to the CY_RQT_READ_MCU_REGISTER
+ command.
+ */
+#define CY_RESP_MCU_REGISTER_DATA (17)
+
+/* Summary
+ Reports the current state of an West Bridge GPIO pin.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request code = 18
+
+ D0
+ Bit 0: Current state of the GP input pin
+
+ Description
+ This response is sent by the West Bridge to report the current state observed on
+ a general purpose input pin.
+ */
+#define CY_RESP_GPIO_STATE (18)
+
+
+/* Summary
+ This command notifies West Bridge the polarity of the SD power pin
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 0
+ * Request Code = 19
+ D0: CyAnMiscActivehigh / CyAnMiscActivelow
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+
+ */
+
+#define CY_RQT_SDPOLARITY (19)
+
+/********************************************************************/
+
+/*@@Resource requests
+ Summary
+
+ The resource requests include:
+ * CY_RQT_ACQUIRE_RESOURCE
+ * CY_RQT_RELEASE_RESOURCE
+ */
+
+
+
+
+
+#ifndef __doxygen__
+#define CY_RQT_RESOURCE_RQT_CONTEXT (1)
+#endif
+
+
+/* Summary
+ This command is a request from the P port processor for ownership
+ of a resource.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 1
+ * Request Code = 0
+
+ D0
+ Resource
+ * 0 = USB
+ * 1 = SDIO/MMC
+ * 2 = NAND
+
+ D1
+ Force Flag
+ * 0 = Normal
+ * 1 = Force
+
+ Description
+ The resource may be the USB pins, the SDIO/MMC bus, or the NAND bus.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_NOT_RELEASED
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_RESOURCE
+ */
+#define CY_RQT_ACQUIRE_RESOURCE (0)
+
+
+/* Summary
+ This command is a request from the P port processor to release
+ ownership of a resource.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 1
+ * Request Code = 1
+
+ D0
+ Resource
+ * 0 = USB
+ * 1 = SDIO/MMC
+ * 2 = NAND
+
+ Description
+ The resource may be the USB pins, the SDIO/MMC bus, or the NAND bus.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_NOT_OWNER
+ */
+#define CY_RQT_RELEASE_RESOURCE (1)
+
+
+/******************************************************/
+
+/*@@Storage requests
+ Summary
+ The storage commands include:
+ * CY_RQT_START_STORAGE
+ * CY_RQT_STOP_STORAGE
+ * CY_RQT_CLAIM_STORAGE
+ * CY_RQT_RELEASE_STORAGE
+ * CY_RQT_QUERY_MEDIA
+ * CY_RQT_QUERY_DEVICE
+ * CY_RQT_QUERY_UNIT
+ * CY_RQT_READ_BLOCK
+ * CY_RQT_WRITE_BLOCK
+ * CY_RQT_MEDIA_CHANGED
+ * CY_RQT_ANTIOCH_CLAIM
+ * CY_RQT_ANTIOCH_RELEASE
+ * CY_RQT_SD_INTERFACE_CONTROL
+ * CY_RQT_SD_REGISTER_READ
+ * CY_RQT_CHECK_CARD_LOCK
+ * CY_RQT_QUERY_BUS
+ * CY_RQT_PARTITION_STORAGE
+ * CY_RQT_PARTITION_ERASE
+ * CY_RQT_GET_TRANSFER_AMOUNT
+ * CY_RQT_ERASE
+ * CY_RQT_SDIO_READ_DIRECT
+ * CY_RQT_SDIO_WRITE_DIRECT
+ * CY_RQT_SDIO_READ_EXTENDED
+ * CY_RQT_SDIO_WRITE_EXTENDED
+ * CY_RQT_SDIO_INIT_FUNCTION
+ * CY_RQT_SDIO_QUERY_CARD
+ * CY_RQT_SDIO_GET_TUPLE
+ * CY_RQT_SDIO_ABORT_IO
+ * CY_RQT_SDIO_INTR
+ * CY_RQT_SDIO_SUSPEND
+ * CY_RQT_SDIO_RESUME
+ * CY_RQT_SDIO_RESET_DEV
+ * CY_RQT_P2S_DMA_START
+ */
+#ifndef __doxygen__
+#define CY_RQT_STORAGE_RQT_CONTEXT (2)
+#endif
+
+/* Summary
+ This command requests initialization of the storage stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 0
+
+ Description
+ This command is required before any other storage related command
+ can be send to the West Bridge firmware.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_ALREADY_RUNNING
+ */
+#define CY_RQT_START_STORAGE (0)
+
+
+/* Summary
+ This command requests shutdown of the storage stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 1
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_NOT_RUNNING
+ */
+#define CY_RQT_STOP_STORAGE (1)
+
+
+/* Summary
+ This command requests ownership of the given media type by the P port processor.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 2
+
+ D0
+ Bits 12 - 15 : Bus Index
+ Bits 8 - 11 : Zero based device index
+
+ Responses
+ * CY_RESP_MEDIA_CLAIMED_RELEASED
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_CLAIM_STORAGE (2)
+
+
+/* Summary
+ This command releases ownership of a given media type by the P port processor.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 3
+
+ D0
+ Bits 12 - 15 : Bus Index
+ Bits 8 - 11 : Zero based device index
+
+ Responses
+ * CY_RESP_MEDIA_CLAIMED_RELEASED
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_RELEASE_STORAGE (3)
+
+
+/* Summary
+ This command returns the total number of logical devices of the given type of media.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 4
+
+ D0
+ Bits 12 - 15 : MediaType
+ * 0 = NAND
+ * 1 = SDIO Flash
+ * 2 = MMC Flash
+ * 3 = CE-ATA
+
+ Bits 8 - 11 : Not Used
+
+ Bits 0 - 7 : Not Used
+
+ Responses
+ * CY_RESP_MEDIA_DESCRIPTOR
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_QUERY_MEDIA (4)
+
+
+/* Summary
+ This command queries a given device to determine information about the number
+ of logical units on the given device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 5
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Not Used
+
+ Responses
+ * CY_RESP_DEVICE_DESCRIPTOR
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_INVALID_PARTITION_TABLE
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_QUERY_DEVICE (5)
+
+
+/* Summary
+ This command queries a given device to determine information about the size
+ and location of a logical unit located on a physical device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 6
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ Responses
+ * CY_RESP_UNIT_DESCRIPTOR
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_INVALID_PARTITION_TABLE
+ * CY_RESP_NO_SUCH_ADDRESS
+ */
+#define CY_RQT_QUERY_UNIT (6)
+
+
+/* Summary
+ This command initiates the read of a specific block from the given media,
+ device and unit.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 2
+ * Request Code = 7
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ D1
+ Upper 16 bits of block address
+
+ D2
+ Lower 16 bits of block address
+
+ D3
+ BIT 8 - 15 : Upper 8 bits of Number of blocks
+
+ BIT 0 - 7 : Reserved
+
+ * D4 *
+ BITS 8 - 15 : Lower 8 bits of Number of blocks
+ BITS 1 - 7 : Not Used
+ BIT 0 : Indicates whether this command is a part of a P2S only burst.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_ANTIOCH_DEFERRED_ERROR
+ */
+#define CY_RQT_READ_BLOCK (7)
+
+
+/* Summary
+ This command initiates the write of a specific block from the given media,
+ device and unit.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 2
+ * Request Code = 8
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ D1
+ Upper 16 bits of block address
+
+ D2
+ Lower 16 bits of block address
+
+ D3
+ BIT 8 - 15 : Upper 8 bits of Number of blocks
+
+ BIT 0 - 7 : Reserved
+
+ * D4 *
+ BITS 8 - 15 : Lower 8 bits of Number of blocks
+ BITS 1 - 7 : Not Used
+ BIT 0 : Indicates whether this command is a part of a P2S only burst.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_ANTIOCH_DEFERRED_ERROR
+ */
+#define CY_RQT_WRITE_BLOCK (8)
+
+/* Summary
+ This request is sent when the West Bridge device detects a change in the status
+ of the media.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request Code = 9
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 0 - 7 : Media type
+
+ D1
+ Bit 0 : Action
+ * 0 = Inserted
+ * 1 = Removed
+
+ Description
+ When the media manager detects the insertion or removal of a media from the West Bridge
+ port, this request is sent from the West Bridge device to the P Port processor to inform
+ the processor of the change in status of the media. This request is sent for both an
+ insert operation and a removal operation.
+
+ Responses
+ * CY_RESPO_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_MEDIA_CHANGED (9)
+
+/* Summary
+ This request is sent when the USB module wishes to claim storage media.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request Code = 10
+
+ D0
+ Bit 0:
+ * 0 = do not release NAND
+ * 1 = release NAND
+
+ Bit 1:
+ * 0 = do not release SD Flash
+ * 1 = release SD Flash
+
+ Bit 2:
+ * 0 = do not release MMC flash
+ * 1 = release MMC flash
+
+ Bit 3:
+ * 0 = do not release CE-ATA storage
+ * 1 = release CE-ATA storage
+
+ Bit 8:
+ * 0 = do not release storage on bus 0
+ * 1 = release storage on bus 0
+
+ Bit 9:
+ * 0 = do not release storage on bus 1
+ * 1 = release storage on bus 1
+
+ Description
+ When the USB cable is attached to the West Bridge device, West Bridge will enumerate the storage
+ devices per the USB initialization of West Bridge. In order for West Bridge to respond to requests
+ received via USB for the mass storage devices, the USB module must claim the storeage. This
+ request is a request to the P port processor to release the storage medium. The medium will
+ not be visible on the USB host, until it has been released by the processor.
+*/
+#define CY_RQT_ANTIOCH_CLAIM (10)
+
+/* Summary
+ This request is sent when the P port has asked West Bridge to release storage media, and the
+ West Bridge device has completed this.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request Code = 11
+
+ D0
+ Bit 0:
+ * 0 = No change in ownership of NAND storage
+ * 1 = NAND ownership has been given to processor
+
+ Bit 1:
+ * 0 = No change in ownership of SD storage
+ * 1 = SD ownership has been given to processor
+
+ Bit 2:
+ * 0 = No change in ownership of MMC storage
+ * 1 = MMC ownership has been given to processor
+
+ Bit 3:
+ * 0 = No change in ownership of CE-ATA storage
+ * 1 = CE-ATA ownership has been given to processor
+
+ Bit 4:
+ * 0 = No change in ownership of SD IO device
+ * 1 = SD IO device ownership has been given to processor
+
+ Bit 8:
+ * 0 = No change in ownership of storage on bus 0
+ * 1 = Bus 0 ownership has been given to processor
+
+ Bit 9:
+ * 0 = No change in ownership of storage on bus 1
+ * 1 = Bus 1 ownership has been given to processor
+
+ Description
+ When the P port asks for control of a particular media, West Bridge may be able to release the
+ media immediately. West Bridge may also need to complete the flush of buffers before releasing
+ the media. In the later case, West Bridge will indicated a release is not possible immediately
+ and West Bridge will send this request to the P port when the release has been completed.
+*/
+#define CY_RQT_ANTIOCH_RELEASE (11)
+
+/* Summary
+ This request is sent by the Processor to enable/disable the handling of SD card
+ detection and SD card write protection by the firmware.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 12
+
+ D0
+ Bit 8: Enable/disable handling of card detection.
+ Bit 1: SDAT_3 = 0, GIPO_0 = 1
+ Bit 0: Enable/disable handling of write protection.
+
+ Description
+ This request is sent by the Processor to enable/disable the handling of SD card
+ detection and SD card write protection by the firmware.
+ */
+#define CY_RQT_SD_INTERFACE_CONTROL (12)
+
+/* Summary
+ Request from the processor to read a register on the SD card, and return the
+ contents.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 13
+
+ D0
+ Bits 12 - 15 : MediaType
+ * 0 = Reserved
+ * 1 = SDIO Flash
+ * 2 = MMC Flash
+ * 3 = Reserved
+
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Type of register to read
+
+ Description
+ This request is sent by the processor to instruct the West Bridge to read a register
+ on the SD/MMC card, and send the contents back through the CY_RESP_SD_REGISTER_DATA
+ response.
+ */
+#define CY_RQT_SD_REGISTER_READ (13)
+
+/* Summary
+ Check if the SD/MMC card connected to West Bridge is password locked.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 14
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+
+ Description
+ This request is sent by the processor to check if the SD/MMC connected to the West Bridge
+ is locked with a password.
+ */
+#define CY_RQT_CHECK_CARD_LOCK (14)
+
+/* Summary
+ This command returns the total number of logical devices on the given bus
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 15
+
+ D0
+ Bits 12 - 15 : Bus Number
+
+ Bits 0 - 11: Not Used
+
+ Responses
+ * CY_RESP_BUS_DESCRIPTOR
+ * CY_RESP_NO_SUCH_BUS
+ */
+#define CY_RQT_QUERY_BUS (15)
+
+/* Summary
+ Divide a storage device into two partitions.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request code = 16
+
+ D0
+ Bits 12 - 15 : Bus number
+ Bits 8 - 11 : Device number
+ Bits 0 - 7 : Not used
+
+ D1
+ Size of partition 0 (MS word)
+
+ D2
+ Size of partition 0 (LS word)
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_PARTITION_STORAGE (16)
+
+/* Summary
+ Remove the partition table and unify all partitions on a storage device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request code = 17
+
+ D0
+ Bits 12 - 15 : Bus number
+ Bits 8 - 11 : Device number
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_PARTITION_ERASE (17)
+
+/* Summary
+ Requests the current transfer amount.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request code = 18
+
+ D0
+ Bits 12 - 15 : Bus number
+ Bits 8 - 11 : Device number
+
+ Responses
+ * CY_RESP_TRANSFER_COUNT
+ */
+#define CY_RQT_GET_TRANSFER_AMOUNT (18)
+
+/* Summary
+ Erases.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 2
+ * Request code = 19
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ D1
+ Upper 16 bits of erase unit
+
+ D2
+ Lower 16 bits of erase unit
+
+ D3
+ BIT 8 - 15 : Upper 8 bits of Number of erase units
+ BIT 0 - 7 : Reserved
+
+ * D4 *
+ BIT 8 - 15 : Lower 8 bits of Number of erase units
+ BIT 0 - 7 : Not Used
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ */
+#define CY_RQT_ERASE (19)
+
+/* Summary
+ This command reads 1 byte from an SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 23
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ D1
+ Bits 8 - 15 : 0
+ Bit 7 : 0 to indicate a read
+ Bits 4 - 6 : Function number
+ Bit 3 : 0
+ Bit 2 : 1 if SDIO interrupt needs to be re-enabled.
+ Bits 0 - 1 : Two Most significant bits of Read address
+
+ D2
+ Bits 1 - 15 : 15 Least significant bits of Read address
+ Bit 0 : 0
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ * CY_RESP_SDIO_DIRECT
+*/
+#define CY_RQT_SDIO_READ_DIRECT (23)
+
+/* Summary
+ This command writes 1 byte to an SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 24
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ D1
+ Bits 8 - 15 : Data to write
+ Bit 7 : 1 to indicate a write
+ Bits 4 - 6 : Function number
+ Bit 3 : 1 if Read after write is enabled
+ Bit 2 : 1 if SDIO interrupt needs to be re-enabled.
+ Bits 0 - 1 : Two Most significant bits of write address
+
+ D2
+ Bits 1 - 15 : 15 Least significant bits of write address
+ Bit 0 : 0
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SDIO_DIRECT
+*/
+#define CY_RQT_SDIO_WRITE_DIRECT (24)
+
+/* Summary
+ This command reads performs a multi block/byte read from an SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 25
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ D1
+ Bit 15 : 0 to indicate a read
+ Bit 12 - 14 : Function Number
+ Bit 11 : Block Mode
+ Bit 10 : OpCode
+ Bits 0 - 9 : 10 Most significant bits of Read address
+
+ D2
+ Bits 9 - 15 : 7 Least significant bits of address
+ Bits 0 - 8 : Block/Byte Count
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SDIO_EXT
+*/
+#define CY_RQT_SDIO_READ_EXTENDED (25)
+
+/* Summary
+ This command reads performs a multi block/byte write to an SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 26
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ D1
+ Bit 15 : 1 to indicate a write
+ Bit 12 - 14 : Function Number
+ Bit 11 : Block Mode
+ Bit 10 : OpCode
+ Bits 0 - 9 : 10 Most significant bits of Read address
+
+ D2
+ Bits 9 - 15 : 7 Least significant bits of address
+ Bits 0 - 8 : Block/Byte Count
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SDIO_EXT
+*/
+#define CY_RQT_SDIO_WRITE_EXTENDED (26)
+
+/* Summary
+ This command initialises an IO function on the SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 27
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SDIO_INIT_FUNCTION (27)
+
+/* Summary
+ This command gets properties of the SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 28
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_QUERY_CARD
+*/
+#define CY_RQT_SDIO_QUERY_CARD (28)
+
+/* Summary
+ This command reads a tuple from the CIS of an SDIO card.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 29
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ D1
+ Bits 8 - 15 : Tuple ID to read
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SDIO_GET_TUPLE
+*/
+#define CY_RQT_SDIO_GET_TUPLE (29)
+
+/* Summary
+ This command Aborts an IO operation.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 30
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SDIO_ABORT_IO (30)
+
+/* Summary
+ SDIO Interrupt request sent to the processor from the West Bridge device.
+
+ Direction
+ West Bridge ->P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 31
+
+ D0
+ Bits 0 - 7 : Bus Index
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SDIO_INTR (31)
+
+/* Summary
+ This command Suspends an IO operation.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 32
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SDIO_SUSPEND (32)
+
+/* Summary
+ This command resumes a suspended operation.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 33
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based function number
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SDIO_RESUME
+*/
+#define CY_RQT_SDIO_RESUME (33)
+
+/* Summary
+ This command resets an SDIO device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request Code = 34
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : 0
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SDIO_RESET_DEV (34)
+
+/* Summary
+ This command asks the API to start the DMA transfer for a P2S operation.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Request code = 35
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_P2S_DMA_START (35)
+
+/******************************************************/
+
+/*@@Storage responses
+ Summary
+ The storage responses include:
+ * CY_RESP_MEDIA_CLAIMED_RELEASED
+ * CY_RESP_MEDIA_DESCRIPTOR
+ * CY_RESP_DEVICE_DESCRIPTOR
+ * CY_RESP_UNIT_DESCRIPTOR
+ * CY_RESP_ANTIOCH_DEFERRED_ERROR
+ * CY_RESP_SD_REGISTER_DATA
+ * CY_RESP_SD_LOCK_STATUS
+ * CY_RESP_BUS_DESCRIPTOR
+ * CY_RESP_TRANSFER_COUNT
+ * CY_RESP_SDIO_EXT
+ * CY_RESP_SDIO_INIT_FUNCTION
+ * CY_RESP_SDIO_QUERY_CARD
+ * CY_RESP_SDIO_GET_TUPLE
+ * CY_RESP_SDIO_DIRECT
+ * CY_RESP_SDIO_INVALID_FUNCTION
+ * CY_RESP_SDIO_RESUME
+ */
+
+/* Summary
+ Based on the request sent, the state of a given media was changed as indicated
+ by this response.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Response Code = 16
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+
+ D1
+ State of Media
+ * 0 = released
+ * 1 = claimed
+ */
+#define CY_RESP_MEDIA_CLAIMED_RELEASED (16)
+
+
+/* Summary
+ This response gives the number of physical devices associated with a given
+ media type.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Response Code = 17
+
+ D0
+ Media Type
+ Bits 12 - 15
+ * 0 = NAND
+ * 1 = SDIO Flash
+ * 2 = MMC Flash
+ * 3 = CE-ATA
+
+ D1
+ Number of devices
+ */
+#define CY_RESP_MEDIA_DESCRIPTOR (17)
+
+
+/* Summary
+ This response gives description of a physical device.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 2
+ * Response Code = 18
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Type of media present on bus
+
+ D1
+ Block Size in bytes
+
+ D2
+ Bit 15 : Is device removable
+ Bit 9 : Is device password locked
+ Bit 8 : Is device writeable
+ Bits 0 - 7 : Number Of Units
+
+ D3
+ ERASE_UNIT_SIZE high 16 bits
+
+ D4
+ ERASE_UNIT_SIZE low 16 bits
+
+ */
+#define CY_RESP_DEVICE_DESCRIPTOR (18)
+
+
+/* Summary
+ This response gives description of a unit on a physical device.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 6
+
+ MailBox0
+ * Context = 2
+ * Response Code = 19
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ D1
+ Bits 0 - 7 : Media type
+ * 1 = NAND
+ * 2 = SD FLASH
+ * 4 = MMC FLASH
+ * 8 = CEATA
+ * 16 = SD IO
+
+ D2
+ Block Size in bytes
+
+ D3
+ Start Block Low 16 bits
+
+ D4
+ Start Block High 16 bits
+
+ D5
+ Unit Size Low 16 bits
+
+ D6
+ Unit Size High 16 bits
+ */
+#define CY_RESP_UNIT_DESCRIPTOR (19)
+
+
+/* Summary
+ This response is sent as error status for P2S
+ Storage operation.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 2
+ * Request Code = 20
+
+ D0
+ Bit 8 : Type of operation (Read / Write)
+ Bits 7 - 0 : Error code
+
+ D1
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Zero based unit index
+
+ *D2 - D3*
+ Address where the error occurred.
+
+ D4
+ Length of the operation in blocks.
+
+ Description
+ This error is returned by the West Bridge to the processor if a
+ storage operation fails due to a medium error.
+*/
+#define CY_RESP_ANTIOCH_DEFERRED_ERROR (20)
+
+/* Summary
+ Contents of a register on the SD/MMC card connected to West Bridge.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ Variable
+
+ Mailbox0
+ * Context = 2
+ * Request code = 21
+
+ D0
+ Length of data in bytes
+
+ D1 - Dn
+ The register contents
+
+ Description
+ This is the response to a CY_RQT_SD_REGISTER_READ request.
+*/
+#define CY_RESP_SD_REGISTER_DATA (21)
+
+/* Summary
+ Status of whether the SD card is password locked.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 22
+
+ D0
+ Bit 0 : The card's lock status
+
+ Description
+ Status of whether the SD card is password locked.
+*/
+#define CY_RESP_SD_LOCK_STATUS (22)
+
+
+/* Summary
+ This response gives the types of physical devices attached to a given bus.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 2
+ * Response Code = 23
+
+ D0
+ Bus Number
+ Bits 12 - 15
+
+ D1
+ Media present on addressed bus
+ */
+#define CY_RESP_BUS_DESCRIPTOR (23)
+
+/* Summary
+ Amount of data read/written through the USB mass storage/MTP device.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 2
+ * Request code = 24
+
+ D0
+ MS 16 bits of number of sectors written
+
+ D1
+ LS 16 bits of number of sectors written
+
+ D2
+ MS 16 bits of number of sectors read
+
+ D3
+ LS 16 bits of number of sectors read
+
+ Description
+ This is the response to the CY_RQT_GET_TRANSFER_AMOUNT request, and
+ represents the number of sectors of data that has been written to or
+ read from the storage device through the USB Mass storage or MTP
+ interface.
+ */
+#define CY_RESP_TRANSFER_COUNT (24)
+
+/* Summary
+ Status of SDIO Extended read/write operation.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 34
+
+ D0
+ Bit 8 : 1 if Read response, 0 if write response
+ Bits 0-7: Error Status
+
+ Description
+ Status of SDIO Extended read write operation.
+*/
+
+#define CY_RESP_SDIO_EXT (34)
+
+/* Summary
+ Status of SDIO operation to Initialize a function
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 2
+ * Request code = 35
+
+
+ D0
+ Bits 8-15 : Function Interface Code
+ Bits 0-7: Extended Function Interface Code
+
+ D1
+ Bits 0-15 : Function Block Size
+
+ D2
+ Bits 0-15 : Most significant Word of Function PSN
+
+ D3
+ Bits 0-15 : Least significant Word of Function PSN
+
+ D4
+ Bit 15 : CSA Enabled Status
+ Bit 14 : CSA Support Status
+ Bit 9 : CSA No Format Status
+ Bit 8 : CSA Write Protect Status
+ Bit 0 : Function Wake Up Support status
+
+ Description
+ Status of SDIO Function Initialization operation.
+*/
+#define CY_RESP_SDIO_INIT_FUNCTION (35)
+
+/* Summary
+ Status of SDIO operation to query the Card
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 2
+ * Request code = 36
+
+
+ D0
+ Bits 8-15 : Number of IO functions present
+ Bit 0: 1 if memory is present
+
+ D1
+ Bits 0-15 : Card Manufacturer ID
+
+ D2
+ Bits 0-15 : Card Manufacturer Additional Information
+
+ D3
+ Bits 0-15 : Function 0 Block Size
+
+ D4
+ Bits 8-15 :SDIO Card Capability register
+ Bits 0-7: SDIO Version
+
+
+ Description
+ Status of SDIO Card Query operation.
+ */
+#define CY_RESP_SDIO_QUERY_CARD (36)
+/* Summary
+ Status of SDIO CIS read operation
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 37
+
+ D0
+ Bit 8 : 1
+ Bits 0-7: Error Status
+
+ D1
+ Bits 0 - 7 : Size of data read.
+
+ Description
+ Status of SDIO Get Tuple Read operation.
+ */
+#define CY_RESP_SDIO_GET_TUPLE (37)
+
+/* Summary
+ Status of SDIO Direct read/write operation.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 38
+
+ D0
+ Bit 8 : Error Status
+ Bits 0-7: Data Read(If any)
+
+ Description
+ Status of SDIO Direct read write operation.
+
+*/
+#define CY_RESP_SDIO_DIRECT (38)
+
+/* Summary
+ Indicates an un-initialized function has been used for IO
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 39
+
+ Description
+ Indicates an IO request on an uninitialized function.
+*/
+#define CY_RESP_SDIO_INVALID_FUNCTION (39)
+
+/* Summary
+ Response to a Resume request
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 2
+ * Request code = 40
+
+ D0
+ Bits 8-15 : Error Status
+ Bit 0: 1 if data is available. 0 otherwise.
+
+ Description
+ Response to a Resume request. Indicates if data is available after resum or not.
+*/
+#define CY_RESP_SDIO_RESUME (40)
+
+/******************************************************/
+
+/*@@USB requests
+ Summary
+ The USB requests include:
+ * CY_RQT_START_USB
+ * CY_RQT_STOP_USB
+ * CY_RQT_SET_CONNECT_STATE
+ * CY_RQT_GET_CONNECT_STATE
+ * CY_RQT_SET_USB_CONFIG
+ * CY_RQT_GET_USB_CONFIG
+ * CY_RQT_STALL_ENDPOINT
+ * CY_RQT_GET_STALL
+ * CY_RQT_SET_DESCRIPTOR
+ * CY_RQT_GET_DESCRIPTOR
+ * CY_RQT_SET_USB_CONFIG_REGISTERS
+ * CY_RQT_USB_EVENT
+ * CY_RQT_USB_EP_DATA
+ * CY_RQT_ENDPOINT_SET_NAK
+ * CY_RQT_GET_ENDPOINT_NAK
+ * CY_RQT_ACK_SETUP_PACKET
+ * CY_RQT_SCSI_INQUIRY_COMMAND
+ * CY_RQT_SCSI_START_STOP_COMMAND
+ * CY_RQT_SCSI_UNKNOWN_COMMAND
+ * CY_RQT_USB_REMOTE_WAKEUP
+ * CY_RQT_CLEAR_DESCRIPTORS
+ * CY_RQT_USB_STORAGE_MONITOR
+ * CY_RQT_USB_ACTIVITY_UPDATE
+ * CY_RQT_MS_PARTITION_SELECT
+ */
+#ifndef __doxygen__
+#define CY_RQT_USB_RQT_CONTEXT (3)
+#endif
+
+/* Summary
+ This command requests initialization of the USB stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 0
+
+ Description
+ This command is required before any other USB related command can be
+ sent to the West Bridge firmware.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_ALREADY_RUNNING
+ */
+#define CY_RQT_START_USB (0)
+
+
+/* Summary
+ This command requests shutdown of the USB stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 1
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_STOP_USB (1)
+
+
+/* Summary
+ This command requests that the USB pins be connected or disconnected to/from
+ the West Bridge device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 2
+
+ D0
+ Desired Connect State
+ * 0 = DISCONNECTED
+ * 1 = CONNECTED
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_SET_CONNECT_STATE (2)
+
+
+/* Summary
+ This command requests the connection state of the West Bridge USB pins.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 3
+
+ Responses
+ * CY_RESP_CONNECT_STATE
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_GET_CONNECT_STATE (3)
+
+
+/* Summary
+ This request configures the USB subsystem.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 3
+ * Request Code = 4
+
+ D0
+ Bits 8 - 15: Media to enumerate (bit mask)
+ Bits 0 - 7: Enumerate Mass Storage (bit mask)
+ * 1 = Enumerate device on bus 0
+ * 2 = Enumerate device on bus 1
+
+ D1
+ Enumeration Methodology
+ * 1 = West Bridge enumeration
+ * 0 = P Port enumeration
+
+ D2
+ Mass storage interface number - Interface number to be used for the mass storage interface
+
+ D3
+ Mass storage callbacks
+ * 1 = relay to P port
+ * 0 = completely handle in firmware
+
+ Description
+ This indicates how enumeration should be handled. Enumeration can be handled by the
+ West Bridge device or by the P port processor.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_INVALID_MASK
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_INVALID_STORAGE_MEDIA
+ */
+#define CY_RQT_SET_USB_CONFIG (4)
+
+
+/* Summary
+ This request retrieves the current USB configuration from the West Bridge device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 5
+
+ Responses
+ * CY_RESP_USB_CONFIG
+ */
+#define CY_RQT_GET_USB_CONFIG (5)
+
+
+/* Summary
+ This request stalls the given endpoint.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 6
+
+ D0
+ Endpoint Number
+
+ D1
+ * 1 = Stall Endpoint
+ * 0 = Clear Stall
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_INVALID_ENDPOINT
+ */
+#define CY_RQT_STALL_ENDPOINT (6)
+
+
+/* Summary
+ This request retrieves the stall status of the requested endpoint.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 7
+
+ D0
+ Endpoint number
+
+ Responses
+ * CY_RESP_ENDPOINT_STALL
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_INVALID_ENDPOINT
+ */
+#define CY_RQT_GET_STALL (7)
+
+
+/* Summary
+ This command sets the contents of a descriptor.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 8
+
+ D0
+ Bit 15 - Bit 8
+ Descriptor Index
+
+ Bit 7 - Bit 0
+ Descriptor Type
+ * Device = 1
+ * Device Qualifier = 2
+ * Full Speed Configuration = 3
+ * High Speed Configuration = 4
+
+ * D1 - DN *
+ Actual data for the descriptor
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_TYPE
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_INDEX
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_LENGTH
+ */
+#define CY_RQT_SET_DESCRIPTOR (8)
+
+/* Summary
+ This command gets the contents of a descriptor.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 9
+
+ D0
+ Bit 15 - Bit 8
+ Descriptor Index
+
+ Bit 7 - Bit 0
+ Descriptor Type
+ * Device = 1
+ * Device Qualifier = 2
+ * Full Speed Configuration = 3
+ * High Speed Configuration = 4
+
+ Responses
+ * CY_RESP_USB_DESCRIPTOR
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_TYPE
+ * CY_RESP_SUCCESS_FAILURE:CY_ERR_BAD_INDEX
+ */
+#define CY_RQT_GET_DESCRIPTOR (9)
+
+/* Summary
+ This request is sent from the P port processor to the West Bridge device to
+ physically configure the endpoints in the device.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 3
+
+ MailBox0
+ * Context = 3
+ * Request Code = 10
+
+ D0
+ Bit 15 - Bit 8
+ EP1OUTCFG register value
+ Bit 7 - Bit 0
+ EP1INCFG register value
+
+ * D1 - D2 *
+ PEPxCFS register values where x = 3, 5, 7, 9
+
+ * D3 - D7 *
+ LEPxCFG register values where x = 3, 5, 7, 9, 10, 11, 12, 13, 14, 15
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_SET_USB_CONFIG_REGISTERS (10)
+
+/* Summary
+ This request is sent to the P port processor when a USB event occurs
+ and needs to be relayed to the P port.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Request Code = 11
+
+ D0
+ Event Type
+ * 0 = Reserved
+ * 1 = Reserved
+ * 2 = USB Suspend
+ * 3 = USB Resume
+ * 4 = USB Reset
+ * 5 = USB Set Configuration
+ * 6 = USB Speed change
+
+ D1
+ If EventTYpe is USB Speed change
+ * 0 = Full Speed
+ * 1 = High Speed
+
+ If EventType is USB Set Configuration
+ * The number of the configuration to use (may be zero to unconfigure)
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_USB_EVENT (11)
+
+/* Summary
+ This request is sent in both directions to transfer endpoint data for
+ endpoints 0 and 1.
+
+ Direction
+ West Bridge -> P Port Processor
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ Variable
+
+ Mailbox0
+ * Context = 3
+ * Request Code = 12
+
+ D0
+ Bit 15 - 14 Data Type
+ * 0 = Setup (payload should be the 8 byte setup packet)
+ * 1 = Data
+ * 2 = Status (payload should be empty)
+
+ Bit 13 Endpoint Number (only 0 and 1 supported)
+ Bit 12 First Packet (only supported for Host -> West Bridge traffic)
+ Bit 11 Last Packet (only supported for Host -> West Bridge traffic)
+
+ Bit 9 - 0 Data Length (real max data length is 64 bytes for EP0 and EP1)
+
+ *D1-Dn*
+ Endpoint data
+*/
+#define CY_RQT_USB_EP_DATA (12)
+
+
+/* Summary
+ This request sets the NAK bit on an endpoint.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 13
+
+ D0
+ Endpoint Number
+
+ D1
+ * 1 = NAK Endpoint
+ * 0 = Clear NAK
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_INVALID_ENDPOINT
+ */
+#define CY_RQT_ENDPOINT_SET_NAK (13)
+
+
+/* Summary
+ This request retrieves the NAK config status of the requested endpoint.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Request Code = 14
+
+ D0
+ Endpoint number
+
+ Responses
+ * CY_RESP_ENDPOINT_NAK
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_INVALID_ENDPOINT
+ */
+#define CY_RQT_GET_ENDPOINT_NAK (14)
+
+/* Summary
+ This request acknowledges a setup packet that does not require any data transfer.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox
+ * Context = 3
+ * Request Code = 15
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_ACK_SETUP_PACKET (15)
+
+/* Summary
+ This request is sent when the USB storage driver within West Bridge receives an Inquiry request.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ x - variable
+
+ Mailbox0
+ * Context = 3
+ * Request Code = 16
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Media type being addressed
+
+ D1
+ Bits 8 : EVPD bit from request
+ Bits 0 - 7 : Codepage from the inquiry request
+
+ D2
+ Length of the inquiry response in bytes
+
+ * D3 - Dn *
+ The inquiry response
+
+ Description
+ When the West Bridge firmware receives an SCSI Inquiry request from the USB host, the response to this
+ mass storage command is created by West Bridge and forwarded to the P port processor. The P port processor
+ may change this response before it is returned to the USB host. This request is the method by which
+ this may happen.
+*/
+#define CY_RQT_SCSI_INQUIRY_COMMAND (16)
+
+/* Summary
+ This request is sent when the USB storage driver within West Bridge receives a Start/Stop request.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Request Code = 17
+
+ D0
+ Bits 12 - 15 : Bus index
+ Bits 8 - 11 : Zero based device index
+ Bits 0 - 7 : Media type being addressed
+
+ D1
+ Bit 1
+ * LoEj Bit (See SCSI-3 specification)
+
+ Bit 0
+ * Start Bit (See SCSI-3 specification)
+
+ Description
+ When the West Bridge firmware received a SCSI Start/Stop request from the USB host, this request is relayed to
+ the P port processor. This request is used to relay the command. The USB firmware will not response to the
+ USB command until the response to this request is recevied by the firmware.
+*/
+#define CY_RQT_SCSI_START_STOP_COMMAND (17)
+
+/* Summary
+ This request is sent when the USB storage driver receives an unknown CBW on mass storage.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 4
+
+ Mailbox0
+ * Context = 3
+ * Request Code = 18
+
+ D0
+ Bits 12 - 15 : MediaType
+ * 0 = NAND
+ * 1 = SDIO Flash
+ * 2 = MMC Flash
+ * 3 = CE-ATA
+
+ D1
+ The length of the request in bytes
+
+ D2 - Dn
+ CBW command block from the SCSI host controller.
+
+ Description
+ When the firmware recevies a SCSI request that is not understood, this request is relayed to the
+ P port processor.
+*/
+#define CY_RQT_SCSI_UNKNOWN_COMMAND (18)
+
+/* Summary
+ Request the West Bridge to signal remote wakeup to the USB host.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Request code = 19
+
+ Description
+ Request from the processor to West Bridge, to signal remote wakeup to the USB host.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_USB_REMOTE_WAKEUP (19)
+
+/* Summary
+ Request the West Bridge to clear all descriptors that were set previously
+ using the Set Descriptor calls.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Request code = 20
+
+ Description
+ Request from the processor to West Bridge, to clear all descriptor information
+ that was previously stored on the West Bridge using CyAnUsbSetDescriptor calls.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_CLEAR_DESCRIPTORS (20)
+
+/* Summary
+ Request the West Bridge to monitor USB to storage activity and send
+ periodic updates.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 3
+ * Request code = 21
+
+ D0
+ Upper 16 bits of write threshold
+
+ D1
+ Lower 16 bits of write threshold
+
+ D2
+ Upper 16 bits of read threshold
+
+ D3
+ Lower 16 bits of read threshold
+
+ Description
+ Request from the processor to West Bridge, to start monitoring the level
+ of read/write activity on the USB mass storage drive and to set the
+ threshold level at which progress reports are sent.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_USB_STORAGE_MONITOR (21)
+
+/* Summary
+ Event from the West Bridge showing that U2S activity since the last event has
+ crossed the threshold.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 3
+ * Request code = 22
+
+ D0
+ Upper 16 bits of sectors written since last event.
+
+ D1
+ Lower 16 bits of sectors written since last event.
+
+ D2
+ Upper 16 bits of sectors read since last event.
+
+ D3
+ Lower 16 bits of sectors read since last event.
+
+ Description
+ Event notification from the West Bridge indicating that the number of
+ read/writes on the USB mass storage device have crossed a pre-defined
+ threshold level.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_USB_ACTIVITY_UPDATE (22)
+
+/* Summary
+ Request to select the partitions to be enumerated on a storage device with
+ partitions.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Request code = 23
+
+ D0
+ Bits 8-15 : Bus index
+ Bits 0- 7 : Device index
+
+ D1
+ Bits 8-15 : Control whether to enumerate partition 1.
+ Bits 0- 7 : Control whether to enumerate partition 0.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE
+ */
+#define CY_RQT_MS_PARTITION_SELECT (23)
+
+/******************************************************/
+
+/*@@USB responses
+ Summary
+ The USB responses include:
+ * CY_RESP_USB_CONFIG
+ * CY_RESP_ENDPOINT_CONFIG
+ * CY_RESP_ENDPOINT_STALL
+ * CY_RESP_CONNECT_STATE
+ * CY_RESP_USB_DESCRIPTOR
+ * CY_RESP_USB_INVALID_EVENT
+ * CY_RESP_ENDPOINT_NAK
+ * CY_RESP_INQUIRY_DATA
+ * CY_RESP_UNKNOWN_SCSI_COMMAND
+ */
+
+/* Summary
+ This response contains the enumeration configuration information for the USB module.
+
+ Direction
+ 8051->P
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Response Code = 32
+
+ D0
+ Bits 8 - 15: Media to enumerate (bit mask)
+ Bits 0 - 7: Buses to enumerate (bit mask)
+ * 1 = Bus 0
+ * 2 = Bus 1
+
+ D1
+ Enumeration Methodology
+ * 0 = West Bridge enumeration
+ * 1 = P Port enumeration
+
+ D2
+ Bits 7 - 0 : Interface Count - the number of interfaces
+ Bits 15 - 8 : Mass storage callbacks
+
+ */
+#define CY_RESP_USB_CONFIG (32)
+
+
+/* Summary
+ This response contains the configuration information for the specified endpoint.
+
+ Direction
+ 8051->P
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Response Code = 33
+
+ D0
+ Bits 15 - 12 : Endpoint Number (0 - 15)
+
+ Bits 11 - 10 : Endpoint Type
+ * 0 = Control
+ * 1 = Bulk
+ * 2 = Interrupt
+ * 3 = Isochronous
+
+ Bits 9 : Endpoint Size
+ * 0 = 512
+ * 1 = 1024
+
+ Bits 8 - 7 : Buffering
+ * 0 = Double
+ * 1 = Triple
+ * 2 = Quad
+
+ Bits 6 : Bit Direction
+ * 0 = Input
+ * 1 = Output
+ */
+#define CY_RESP_ENDPOINT_CONFIG (33)
+
+
+/* Summary
+ This response contains the stall status for the specified endpoint.
+
+ Direction
+ 8051->P
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Response Code = 34
+
+ D0
+ Stall status
+ * 0 = Active
+ * 1 = Stalled
+ */
+#define CY_RESP_ENDPOINT_STALL (34)
+
+
+/* Summary
+ This response contains the connected/disconnected state of the West Bridge USB pins.
+
+ Direction
+ 8051->P
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 3
+ * Response Code = 35
+
+ D0
+ Connect state
+ * 0 = Disconnected
+ * 1 = Connected
+ */
+#define CY_RESP_CONNECT_STATE (35)
+
+/* Summary
+ This response contains the information about the USB configuration
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length
+ x bytes
+
+ Mailbox0
+ * Context = 3
+ * Response Code = 36
+
+ D0
+ Length in bytes of the descriptor
+
+ * D1 - DN *
+ Descriptor contents
+*/
+#define CY_RESP_USB_DESCRIPTOR (36)
+
+/* Summary
+ This response is sent in response to a bad USB event code
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length
+ 1 word (2 bytes)
+
+ Mailbox0
+ * Context = 3
+ * Response Code = 37
+
+ D0
+ The invalid event code in the request
+*/
+#define CY_RESP_USB_INVALID_EVENT (37)
+
+/* Summary
+ This response contains the current NAK status of a USB endpoint.
+
+ Direction
+ West Bridge -> P port processor
+
+ Length
+ 1 transfer
+
+ Mailbox0
+ * Context = 3
+ * Response Code = 38
+
+ D0
+ The NAK status of the endpoint
+ 1 : NAK bit set
+ 0 : NAK bit clear
+*/
+#define CY_RESP_ENDPOINT_NAK (38)
+
+/* Summary
+ This response gives the contents of the inquiry data back to West Bridge to
+ returns to the USB host.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length
+ Variable
+
+ MailBox0
+ * Context = 3
+ * Response Code = 39
+
+ D0
+ Length of the inquiry response
+
+ *D1 - Dn*
+ Inquiry data
+*/
+#define CY_RESP_INQUIRY_DATA (39)
+
+/* Summary
+ This response gives the status of an unknown SCSI command. This also gives three
+ bytes of sense information.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 3
+ * Response Code = 40
+
+ D0
+ The length of the reply in bytes
+
+ D1
+ * Status of the command
+ * Sense Key
+
+ D2
+ * Additional Sense Code (ASC)
+ * Additional Sense Code Qualifier (ASCQ)
+*/
+#define CY_RESP_UNKNOWN_SCSI_COMMAND (40)
+/*******************************************************/
+
+/*@@Turbo requests
+ Summary
+ The Turbo requests include:
+ * CY_RQT_START_MTP
+ * CY_RQT_STOP_MTP
+ * CY_RQT_INIT_SEND_OBJECT
+ * CY_RQT_CANCEL_SEND_OBJECT
+ * CY_RQT_INIT_GET_OBJECT
+ * CY_RQT_CANCEL_GET_OBJECT
+ * CY_RQT_SEND_BLOCK_TABLE
+ * CY_RQT_MTP_EVENT
+ * CY_RQT_TURBO_CMD_FROM_HOST
+ * CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST
+ * CY_RQT_TURBO_SWITCH_ENDPOINT
+ * CY_RQT_TURBO_START_WRITE_DMA
+ * CY_RQT_ENABLE_USB_PATH
+ * CY_RQT_CANCEL_ASYNC_TRANSFER
+ */
+#ifndef __doxygen__
+#define CY_RQT_TUR_RQT_CONTEXT (4)
+#endif
+
+/* Summary
+ This command requests initialization of the MTP stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 0
+
+ Description
+ This command is required before any other MTP related command can be
+ sent to the West Bridge firmware.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_ALREADY_RUNNING
+ */
+#define CY_RQT_START_MTP (0)
+
+/* Summary
+ This command requests shutdown of the MTP stack.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 1
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_STOP_MTP (1)
+
+/* Summary
+ This command sets up an MTP SendObject operation.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 2
+
+ D0
+ Total bytes for send object Low 16 bits
+
+ D1
+ Total bytes for send object High 16 bits
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_INIT_SEND_OBJECT (2)
+
+/* Summary
+ This command cancels West Bridges handling of
+ an ongoing MTP SendObject operation. This
+ does NOT send an MTP response.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 3
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_NO_OPERATION_PENDING
+ */
+#define CY_RQT_CANCEL_SEND_OBJECT (3)
+
+/* Summary
+ This command sets up an MTP GetObject operation.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 4
+ * Request Code = 4
+
+ D0
+ Total bytes for get object Low 16 bits
+
+ D1
+ Total bytes for get object High 16 bits
+
+ D2
+ Transaction Id for get object Low 16 bits
+
+ D3
+ Transaction Id for get object High 16 bits
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_INIT_GET_OBJECT (4)
+
+/* Summary
+ This command notifies West Bridge of a new
+ BlockTable transfer.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 5
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_SEND_BLOCK_TABLE (5)
+
+/* Summary
+ This request is sent to the P port processor when a MTP event occurs
+ and needs to be relayed to the P port.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 4
+ * Request Code = 6
+
+ D0
+ Bits 15 - 8 : Return Status for GetObject/SendObject
+ Bits 7 - 0 : Event Type
+ * 0 = MTP SendObject Complete
+ * 1 = MTP GetObject Complete
+ * 2 = BlockTable Needed
+
+ D1
+ Lower 16 bits of the length of the data that got transferred in the Turbo Endpoint.
+ (Applicable to "MTP SendObject Complete" and "MTP GetObject Complete" events)
+
+ D2
+ Upper 16 bits of the length of the data that got transferred in the Turbo Endpoint.
+ (Applicable to "MTP SendObject Complete" and "MTP GetObject Complete" events)
+
+ D3
+ Lower 16 bits of the Transaction Id of the MTP_SEND_OBJECT command.
+ (Applicable to "MTP SendObject Complete" event)
+
+ D4
+ Upper 16 bits of the Transaction Id of the MTP_SEND_OBJECT command.
+ (Applicable to "MTP SendObject Complete" event)
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_MTP_EVENT (6)
+
+/* Summary
+ This request is sent to the P port processor when a command is received
+ from Host in a Turbo Endpoint. Upon receiving this event, P port should
+ read the data from the endpoint as soon as possible.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 4
+ * Request Code = 7
+
+ D0
+ This contains the EP number. (This will be always two now).
+
+ D1
+ Length of the data available in the Turbo Endpoint.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_TURBO_CMD_FROM_HOST (7)
+
+/* Summary
+ This request is sent to the West Bridge when the P port needs to send
+ data to the Host in a Turbo Endpoint. Upon receiving this event,
+ Firmware will make the end point avilable for the P port. If the length is
+ zero, then firmware will send a zero length packet.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ Mailbox0
+ * Context = 4
+ * Request Code = 8
+
+ D0
+ This contains the EP number. (This will be always six now).
+
+ D1
+ Lower 16 bits of the length of the data that needs to be sent in the Turbo Endpoint.
+
+ D2
+ Upper 16 bits of the length of the data that needs to be sent in the Turbo Endpoint.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+*/
+#define CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST (8)
+
+/* Summary
+ This command cancels West Bridges handling of
+ an ongoing MTP GetObject operation. This
+ does NOT send an MTP response.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 9
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_NO_OPERATION_PENDING
+ */
+#define CY_RQT_CANCEL_GET_OBJECT (9)
+
+/* Summary
+ This command switches a Turbo endpoint
+ from the U port to the P port. If no data
+ is in the endpoint the endpoint is
+ primed to switch as soon as data is placed
+ in the endpoint. The endpoint will continue
+ to switch until all data has been transferd.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 2
+
+ MailBox0
+ * Context = 4
+ * Request Code = 10
+
+ D0
+ Whether the read is a packet read.
+
+ D1
+ Lower 16 bits of the length of the data to switch the Turbo Endpoint for.
+
+ D2
+ Upper 16 bits of the length of the data to switch the Turbo Endpoint for.
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ * CY_RESP_SUCCESS_FAILURE:CY_RESP_NOT_RUNNING
+ */
+#define CY_RQT_TURBO_SWITCH_ENDPOINT (10)
+
+/* Summary
+ This command requests the API to start the DMA transfer of a packet
+ of MTP data to the Antioch.
+
+ Direction
+ West Bridge -> P Port Processor
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request Code = 11
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ */
+#define CY_RQT_TURBO_START_WRITE_DMA (11)
+
+/* Summary
+ This command requests the firmware to switch the internal data paths to enable
+ USB access to the Mass storage / MTP endpoints.
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ MailBox0
+ * Context = 4
+ * Request code = 12
+
+ Responses
+ * CY_RESP_SUCCESS_FAILURE:CY_AS_ERROR_SUCCESS
+ */
+#define CY_RQT_ENABLE_USB_PATH (12)
+
+/* Summary
+ Request to cancel an asynchronous MTP write from the processor side.
+
+ Direction
+ P Port processor -> West Bridge
+
+ Length (in transfers)
+ 1
+
+ Mailbox0
+ * Context = 4
+ * Request code = 13
+
+ D0
+ * EP number
+
+ Description
+ This is a request to the firmware to update internal state so that a pending write
+ on the MTP endpoint can be cancelled.
+ */
+#define CY_RQT_CANCEL_ASYNC_TRANSFER (13)
+
+/******************************************************/
+
+/*@@Turbo responses
+ Summary
+ The Turbo responses include:
+ * CY_RESP_MTP_INVALID_EVENT
+ */
+
+/* Summary
+ This response is sent in response to a bad MTP event code
+
+ Direction
+ P Port Processor -> West Bridge
+
+ Length
+ 1 word (2 bytes)
+
+ Mailbox0
+ * Context = 4
+ * Response Code = 16
+
+ D0
+ The invalid event code in the request
+*/
+#define CY_RESP_MTP_INVALID_EVENT (16)
+
+#ifndef __doxygen__
+#define CY_RQT_CONTEXT_COUNT (5)
+#endif
+
+#endif /* _INCLUDED_CYASPROTOCOL_H_ */
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasstorage.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,3941 @@
+/* Cypress West Bridge API source file (cyasstorage.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/*
+* Storage Design
+*
+* The storage module is fairly straight forward once the DMA and LOWLEVEL modules
+* have been designed. The storage module simple takes requests from the user, queues the
+* associated DMA requests for action, and then sends the low level requests to the
+* West Bridge firmware.
+*
+*/
+
+#include "cyashal.h"
+#include "cyasstorage.h"
+#include "cyaserr.h"
+#include "cyasdevice.h"
+#include "cyaslowlevel.h"
+#include "cyasdma.h"
+#include "cyasregs.h"
+
+/* Map a pre-V1.2 media type to the V1.2+ bus number */
+CyAsReturnStatus_t
+CyAnMapBusFromMediaType(CyAsDevice *dev_p, CyAsMediaType type, CyAsBusNumber_t *bus)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code = (uint8_t)(1 << type) ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+
+ if (dev_p->media_supported[0] & code)
+ {
+ if (dev_p->media_supported[1] & code)
+ {
+ /*
+ * This media type could be supported on multiple buses. So, report
+ * an address resolution error.
+ */
+ ret = CY_AS_ERROR_ADDRESS_RESOLUTION_ERROR ;
+ }
+ else
+ *bus = 0 ;
+ }
+ else
+ {
+ if (dev_p->media_supported[1] & code)
+ *bus = 1 ;
+ else
+ ret = CY_AS_ERROR_NO_SUCH_MEDIA ;
+ }
+
+ return ret ;
+}
+
+static uint16_t
+CreateAddress(CyAsBusNumber_t bus, uint32_t device, uint8_t unit)
+{
+ CyAsHalAssert(bus >= 0 && bus < CY_AS_MAX_BUSES) ;
+ CyAsHalAssert(device < 16) ;
+
+ return (uint16_t)(((uint8_t)bus << 12) | (device << 8) | unit) ;
+}
+
+CyAsMediaType
+CyAsStorageGetMediaFromAddress(uint16_t v)
+{
+ CyAsMediaType media = CyAsMediaMaxMediaValue ;
+
+ switch(v & 0xFF)
+ {
+ case 0x00:
+ break;
+ case 0x01:
+ media = CyAsMediaNand ;
+ break ;
+ case 0x02:
+ media = CyAsMediaSDFlash ;
+ break ;
+ case 0x04:
+ media = CyAsMediaMMCFlash ;
+ break ;
+ case 0x08:
+ media = CyAsMediaCEATA ;
+ break ;
+ case 0x10:
+ media = CyAsMediaSDIO ;
+ break ;
+ default:
+ CyAsHalAssert(0) ;
+ break ;
+ }
+
+ return media ;
+}
+
+CyAsBusNumber_t
+CyAsStorageGetBusFromAddress(uint16_t v)
+{
+ CyAsBusNumber_t bus = (CyAsBusNumber_t)((v >> 12) & 0x0f) ;
+ CyAsHalAssert(bus >= 0 && bus < CY_AS_MAX_BUSES) ;
+ return bus ;
+}
+
+uint32_t
+CyAsStorageGetDeviceFromAddress(uint16_t v)
+{
+ return (uint32_t)((v >> 8) & 0x0f) ;
+}
+
+static uint8_t
+GetUnitFromAddress(uint16_t v)
+{
+ return (uint8_t)(v & 0xff) ;
+}
+
+static CyAsReturnStatus_t
+CyAsMapBadAddr(uint16_t val)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_INVALID_RESPONSE ;
+
+ switch(val)
+ {
+ case 0:
+ ret = CY_AS_ERROR_NO_SUCH_BUS ;
+ break ;
+ case 1:
+ ret = CY_AS_ERROR_NO_SUCH_DEVICE ;
+ break ;
+ case 2:
+ ret = CY_AS_ERROR_NO_SUCH_UNIT ;
+ break ;
+ case 3:
+ ret = CY_AS_ERROR_INVALID_BLOCK ;
+ break ;
+ }
+
+ return ret ;
+}
+
+static void
+MyStorageRequestCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *resp_p, CyAsReturnStatus_t ret)
+{
+ uint16_t val ;
+ uint16_t addr ;
+ CyAsBusNumber_t bus;
+ uint32_t device;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+ CyAsDmaEndPoint *ep_p = NULL ;
+
+ (void)resp_p ;
+ (void)context ;
+ (void)ret ;
+
+ switch(CyAsLLRequestResponse_GetCode(req_p))
+ {
+ case CY_RQT_MEDIA_CHANGED:
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+
+ /* Media has either been inserted or removed */
+ addr = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+
+ bus = CyAsStorageGetBusFromAddress(addr);
+ device = CyAsStorageGetDeviceFromAddress(addr);
+
+ /* Clear the entry for this device to force re-query later */
+ CyAsHalMemSet(&(dev_p->storage_device_info[bus][device]), 0,
+ sizeof(dev_p->storage_device_info[bus][device])) ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ if (dev_p->storage_event_cb_ms)
+ {
+ if (val == 1)
+ dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageRemoved, 0) ;
+ else
+ dev_p->storage_event_cb_ms(h, bus, device, CyAsStorageInserted, 0) ;
+ }
+ else if (dev_p->storage_event_cb)
+ {
+ if (val == 1)
+ dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageRemoved, 0) ; /*nxz*/
+ else
+ dev_p->storage_event_cb(h, (CyAsMediaType)bus, CyAsStorageInserted, 0) ; /*nxz*/
+ }
+
+ break ;
+
+ case CY_RQT_ANTIOCH_CLAIM:
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ if (dev_p->storage_event_cb || dev_p->storage_event_cb_ms)
+ {
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ if (dev_p->storage_event_cb_ms)
+ {
+ if (val & 0x0100)
+ dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageAntioch, 0) ;
+ if (val & 0x0200)
+ dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageAntioch, 0) ;
+ }
+ else
+ {
+ if (val & 0x01)
+ dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageAntioch, 0) ;
+ if (val & 0x02)
+ dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageAntioch, 0) ;
+ if (val & 0x04)
+ dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageAntioch, 0) ;
+ if (val & 0x08)
+ dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageAntioch, 0) ;
+ }
+ }
+ break ;
+
+ case CY_RQT_ANTIOCH_RELEASE:
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ if (dev_p->storage_event_cb_ms)
+ {
+ if (val & 0x0100)
+ dev_p->storage_event_cb_ms(h, 0, 0, CyAsStorageProcessor, 0) ;
+ if (val & 0x0200)
+ dev_p->storage_event_cb_ms(h, 1, 0, CyAsStorageProcessor, 0) ;
+ }
+ else if (dev_p->storage_event_cb)
+ {
+ if (val & 0x01)
+ dev_p->storage_event_cb(h, CyAsMediaNand, CyAsStorageProcessor, 0) ;
+ if (val & 0x02)
+ dev_p->storage_event_cb(h, CyAsMediaSDFlash, CyAsStorageProcessor, 0) ;
+ if (val & 0x04)
+ dev_p->storage_event_cb(h, CyAsMediaMMCFlash, CyAsStorageProcessor, 0) ;
+ if (val & 0x08)
+ dev_p->storage_event_cb(h, CyAsMediaCEATA, CyAsStorageProcessor, 0) ;
+ }
+ break ;
+
+
+ case CY_RQT_SDIO_INTR:
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ if (dev_p->storage_event_cb_ms)
+ {
+ if (val & 0x0100)
+ dev_p->storage_event_cb_ms(h, 1, 0, CyAsSdioInterrupt, 0) ;
+ else
+ dev_p->storage_event_cb_ms(h, 0, 0, CyAsSdioInterrupt, 0) ;
+
+ }
+ else if (dev_p->storage_event_cb)
+ {
+ dev_p->storage_event_cb(h, CyAsMediaSDIO, CyAsSdioInterrupt, 0) ;
+ }
+ break;
+
+ case CY_RQT_P2S_DMA_START:
+ /* Do the DMA setup for the waiting operation. This event is used only in
+ * the MTP mode firmware. */
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ if (dev_p->storage_oper == CyAsOpRead)
+ {
+ ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_READ_ENDPOINT) ;
+ CyAsDmaEndPointSetStopped(ep_p) ;
+ CyAsDmaKickStart(dev_p, CY_AS_P2S_READ_ENDPOINT) ;
+ }
+ else
+ {
+ ep_p = CY_AS_NUM_EP(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;
+ CyAsDmaEndPointSetStopped(ep_p) ;
+ CyAsDmaKickStart(dev_p, CY_AS_P2S_WRITE_ENDPOINT) ;
+ }
+ break ;
+
+ default:
+ CyAsHalPrintMessage("Invalid request received on storage context\n") ;
+ val = req_p->box0 ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;
+ break ;
+ }
+}
+
+static CyAsReturnStatus_t
+IsStorageActive(CyAsDevice *dev_p)
+{
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+CyAsStorageFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret) ;
+
+static CyAsReturnStatus_t
+MyHandleResponseNoData(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageStart(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (dev_p->storage_count > 0 && ret == CY_AS_ERROR_ALREADY_RUNNING)
+ ret = CY_AS_ERROR_SUCCESS ;
+
+ ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CyTrue, CyAsDirectionIn) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_WRITE_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = CyAsDmaEnableEndPoint(dev_p, CY_AS_P2S_READ_ENDPOINT, CyTrue, CyAsDirectionOut) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = CyAsDmaSetMaxDmaSize(dev_p, CY_AS_P2S_READ_ENDPOINT, CY_AS_STORAGE_EP_SIZE) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_STORAGE_RQT_CONTEXT, MyStorageRequestCallback) ;
+
+ /* Create the request/response used for storage reads and writes. */
+ dev_p->storage_rw_req_p = CyAsLLCreateRequest(dev_p, 0, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;
+ if (dev_p->storage_rw_req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY;
+ goto destroy;
+ }
+
+ dev_p->storage_rw_resp_p = CyAsLLCreateResponse(dev_p, 5) ;
+ if (dev_p->storage_rw_resp_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ /* Increment the storage count only if the above functionality succeeds.*/
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (dev_p->storage_count == 0)
+ {
+ CyAsHalMemSet(dev_p->storage_device_info, 0, sizeof(dev_p->storage_device_info)) ;
+ dev_p->is_storage_only_mode = CyFalse ;
+ }
+
+ dev_p->storage_count++ ;
+ }
+
+ CyAsDeviceClearSSSPending(dev_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageStart(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if(CyAsDeviceIsSSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ CyAsDeviceSetSSSPending(dev_p) ;
+
+ if (dev_p->storage_count == 0)
+ {
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ {
+ CyAsDeviceClearSSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsDeviceClearSSSPending(dev_p) ;
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseStorageStart(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_START,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else
+ {
+ dev_p->storage_count++ ;
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_STOR_START, 0) ;
+ }
+
+ CyAsDeviceClearSSSPending(dev_p) ;
+
+ return ret ;
+}
+
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageStop(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;
+ CyAsLLDestroyResponse(dev_p, dev_p->storage_rw_resp_p) ;
+ dev_p->storage_count-- ;
+ }
+
+ CyAsDeviceClearSSSPending(dev_p) ;
+
+ return ret ;
+}
+CyAsReturnStatus_t
+CyAsStorageStop(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsStorageAsyncPending(dev_p))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ if(CyAsDeviceIsSSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ CyAsDeviceSetSSSPending(dev_p) ;
+
+ if (dev_p->storage_count == 1)
+ {
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STOP_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ CyAsDeviceClearSSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsDeviceClearSSSPending(dev_p) ;
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseStorageStop(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_STOP,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else if(dev_p->storage_count > 1)
+ {
+ dev_p->storage_count-- ;
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_STOR_STOP, 0) ;
+ }
+
+ CyAsDeviceClearSSSPending(dev_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRegisterCallback(CyAsDeviceHandle handle, CyAsStorageEventCallback callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ dev_p->storage_event_cb = NULL ;
+ dev_p->storage_event_cb_ms = callback ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageClaim(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MEDIA_CLAIMED_RELEASED)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* The response must be about the address I am trying to claim or the firmware is broken */
+ if ((CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=
+ CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))) ||
+ (CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=
+ CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))))
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetWord(reply_p, 1) != 1)
+ ret = CY_AS_ERROR_NOT_ACQUIRED ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyStorageClaim(CyAsDevice *dev_p,
+ void* data,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint16_t req_flags,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if(dev_p->mtp_count > 0)
+ return CY_AS_ERROR_NOT_VALID_IN_MTP ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CLAIM_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 4) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseStorageClaim(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_CLAIM,
+ data, dev_p->func_cbs_stor, req_flags,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageClaim(CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ return MyStorageClaim(dev_p, NULL, bus, device, CY_AS_REQUEST_RESPONSE_MS, cb, client) ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageRelease(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_MEDIA_CLAIMED_RELEASED)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* The response must be about the address I am trying to release or the firmware is broken */
+ if ((CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=
+ CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))) ||
+ (CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=
+ CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0))))
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+
+ if (CyAsLLRequestResponse_GetWord(reply_p, 1) != 0)
+ ret = CY_AS_ERROR_NOT_RELEASED ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyStorageRelease(CyAsDevice* dev_p,
+ void* data,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint16_t req_flags,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if(dev_p->mtp_count > 0)
+ return CY_AS_ERROR_NOT_VALID_IN_MTP ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_RELEASE_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 4) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseStorageRelease(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_RELEASE,
+ data, dev_p->func_cbs_stor, req_flags,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRelease(CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ return MyStorageRelease(dev_p, NULL, bus, device, CY_AS_REQUEST_RESPONSE_MS, cb, client) ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageQueryBus(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ uint32_t* count)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code = CyAsLLRequestResponse_GetCode(reply_p) ;
+ uint16_t v ;
+
+ if (code == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CY_AS_ERROR_NO_SUCH_BUS ;
+ goto destroy ;
+ }
+
+ if (code != CY_RESP_BUS_DESCRIPTOR)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /*
+ * Verify that the response corresponds to the bus that was queried.
+ */
+ if (CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(req_p, 0)) !=
+ CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0)))
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ v = CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+ if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)
+ {
+ /*
+ * This request is only for the count of devices on the bus. There
+ * is no need to check the media type.
+ */
+ if (v)
+ *count = 1 ;
+ else
+ *count = 0 ;
+ }
+ else
+ {
+ /*
+ * This request is for the count of devices of a particular type. We need
+ * to check whether the media type found matches the queried type.
+ */
+ CyAsMediaType queried = (CyAsMediaType)CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ CyAsMediaType found = CyAsStorageGetMediaFromAddress(v) ;
+
+ if (queried == found)
+ *count = 1 ;
+ else
+ *count = 0 ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+MyStorageQueryBus(CyAsDevice *dev_p,
+ CyAsBusNumber_t bus,
+ CyAsMediaType type,
+ uint16_t req_flags,
+ uint32_t *count,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsFunctCBType cbType = CY_FUNCT_CB_STOR_QUERYBUS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Create the request to send to the Antioch device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_QUERY_BUS, CY_RQT_STORAGE_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, 0, 0)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)type) ;
+
+ /* Reserve space for the reply, the reply data will not exceed two words. */
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ req_p->flags |= req_flags;
+ return MyHandleResponseStorageQueryBus(dev_p, req_p, reply_p, count) ;
+ }
+ else
+ {
+ if (req_flags == CY_AS_REQUEST_RESPONSE_EX)
+ cbType = CY_FUNCT_CB_STOR_QUERYMEDIA ;
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, cbType,
+ count, dev_p->func_cbs_stor, req_flags,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryBus(CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t *count,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ return MyStorageQueryBus(dev_p, bus, CyAsMediaMaxMediaValue, CY_AS_REQUEST_RESPONSE_MS,
+ count, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryMedia(CyAsDeviceHandle handle,
+ CyAsMediaType type,
+ uint32_t *count,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsBusNumber_t bus ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return MyStorageQueryBus(dev_p, bus, type, CY_AS_REQUEST_RESPONSE_EX,
+ count, cb, client) ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageQueryDevice(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ void* data_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t v ;
+ CyAsBusNumber_t bus ;
+ CyAsMediaType type ;
+ uint32_t device ;
+ CyBool removable ;
+ CyBool writeable ;
+ CyBool locked ;
+ uint16_t block_size ;
+ uint32_t number_units ;
+ uint32_t number_eus ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_DEVICE_DESCRIPTOR)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* Unpack the response */
+ v = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ type = CyAsStorageGetMediaFromAddress(v) ;
+ bus = CyAsStorageGetBusFromAddress(v) ;
+ device = CyAsStorageGetDeviceFromAddress(v) ;
+
+ block_size = CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+
+ v = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ removable = (v & 0x8000) ? CyTrue : CyFalse ;
+ writeable = (v & 0x0100) ? CyTrue : CyFalse ;
+ locked = (v & 0x0200) ? CyTrue : CyFalse ;
+ number_units = (v & 0xff) ;
+
+ number_eus = (CyAsLLRequestResponse_GetWord(reply_p, 3) << 16) | CyAsLLRequestResponse_GetWord(reply_p, 4) ;
+
+ /* Store the results based on the version of originating function */
+ if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)
+ {
+ CyAsStorageQueryDeviceData *store_p = (CyAsStorageQueryDeviceData*)data_p ;
+
+ /* Make sure the response is about the address we asked about - if not, firmware error */
+ if ((bus != store_p->bus) || (device != store_p->device))
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ store_p->desc_p.type = type ;
+ store_p->desc_p.removable = removable ;
+ store_p->desc_p.writeable = writeable ;
+ store_p->desc_p.block_size = block_size ;
+ store_p->desc_p.number_units = number_units ;
+ store_p->desc_p.locked = locked ;
+ store_p->desc_p.erase_unit_size = number_eus ;
+ dev_p->storage_device_info[bus][device] = store_p->desc_p ;
+ }
+ else
+ {
+ CyAsStorageQueryDeviceData_dep *store_p = (CyAsStorageQueryDeviceData_dep*)data_p ;
+
+ /* Make sure the response is about the address we asked about - if not, firmware error */
+ if ((type != store_p->type) || (device != store_p->device))
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ store_p->desc_p.type = type ;
+ store_p->desc_p.removable = removable ;
+ store_p->desc_p.writeable = writeable ;
+ store_p->desc_p.block_size = block_size ;
+ store_p->desc_p.number_units = number_units ;
+ store_p->desc_p.locked = locked ;
+ store_p->desc_p.erase_unit_size = number_eus ;
+ dev_p->storage_device_info[bus][device] = store_p->desc_p ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyStorageQueryDevice(CyAsDevice *dev_p,
+ void* data_p,
+ uint16_t req_flags,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Create the request to send to the Antioch device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_QUERY_DEVICE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed five words. */
+ reply_p = CyAsLLCreateResponse(dev_p, 5) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ req_p->flags |= req_flags;
+ return MyHandleResponseStorageQueryDevice(dev_p, req_p, reply_p, data_p) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_QUERYDEVICE,
+ data_p, dev_p->func_cbs_stor, req_flags,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryDevice(CyAsDeviceHandle handle,
+ CyAsStorageQueryDeviceData* data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ return MyStorageQueryDevice(dev_p, data_p, CY_AS_REQUEST_RESPONSE_MS, data_p->bus,
+ data_p->device, cb, client) ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseStorageQueryUnit(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ void* data_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsBusNumber_t bus ;
+ uint32_t device ;
+ uint32_t unit ;
+ CyAsMediaType type ;
+ uint16_t block_size ;
+ uint32_t start_block ;
+ uint32_t unit_size ;
+ uint16_t v ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CyAsMapBadAddr(CyAsLLRequestResponse_GetWord(reply_p, 3)) ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_UNIT_DESCRIPTOR)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* Unpack the response */
+ v = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ bus = CyAsStorageGetBusFromAddress(v) ;
+ device = CyAsStorageGetDeviceFromAddress(v) ;
+ unit = GetUnitFromAddress(v) ;
+
+ type = CyAsStorageGetMediaFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 1));
+
+ block_size = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ start_block = CyAsLLRequestResponse_GetWord(reply_p, 3) | (CyAsLLRequestResponse_GetWord(reply_p, 4) << 16) ;
+ unit_size = CyAsLLRequestResponse_GetWord(reply_p, 5) | (CyAsLLRequestResponse_GetWord(reply_p, 6) << 16) ;
+
+ /* Store the results based on the version of originating function */
+ if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)
+ {
+ CyAsStorageQueryUnitData *store_p = (CyAsStorageQueryUnitData*)data_p ;
+
+ /* Make sure the response is about the address we asked about - if not, firmware error */
+ if (bus != store_p->bus || device != store_p->device || unit != store_p->unit)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ store_p->desc_p.type = type ;
+ store_p->desc_p.block_size = block_size ;
+ store_p->desc_p.start_block = start_block ;
+ store_p->desc_p.unit_size = unit_size ;
+ }
+ else
+ {
+ CyAsStorageQueryUnitData_dep *store_p = (CyAsStorageQueryUnitData_dep*)data_p ;
+
+ /* Make sure the response is about the media type we asked about - if not, firmware error */
+ if ((type != store_p->type) || (device != store_p->device) || (unit != store_p->unit) ) {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ store_p->desc_p.type = type ;
+ store_p->desc_p.block_size = block_size ;
+ store_p->desc_p.start_block = start_block ;
+ store_p->desc_p.unit_size = unit_size ;
+ }
+
+ dev_p->storage_device_info[bus][device].type = type ;
+ dev_p->storage_device_info[bus][device].block_size = block_size ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyStorageQueryUnit(CyAsDevice *dev_p,
+ void* data_p,
+ uint16_t req_flags,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint32_t unit,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_QUERY_UNIT, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ if (device > 255)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (unit > 255)
+ return CY_AS_ERROR_NO_SUCH_UNIT ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, (uint8_t)unit)) ;
+
+ /* Reserve space for the reply, the reply data will be of seven words. */
+ reply_p = CyAsLLCreateResponse(dev_p, 7) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ req_p->flags |= req_flags ;
+ return MyHandleResponseStorageQueryUnit(dev_p, req_p, reply_p, data_p) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_QUERYUNIT,
+ data_p, dev_p->func_cbs_stor, req_flags,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryUnit(CyAsDeviceHandle handle,
+ CyAsStorageQueryUnitData* data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ return MyStorageQueryUnit(dev_p, data_p, CY_AS_REQUEST_RESPONSE_MS, data_p->bus,
+ data_p->device, data_p->unit, cb, client) ;
+}
+
+
+static CyAsReturnStatus_t
+CyAsGetBlockSize(CyAsDevice *dev_p,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsFunctionCallback cb)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_QUERY_DEVICE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 4) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_NO_SUCH_ADDRESS)
+ {
+ ret = CY_AS_ERROR_NO_SUCH_BUS ;
+ goto destroy ;
+ }
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_DEVICE_DESCRIPTOR)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* Make sure the response is about the media type we asked about - if not, firmware error */
+ if ((CyAsStorageGetBusFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0)) != bus) ||
+ (CyAsStorageGetDeviceFromAddress(CyAsLLRequestResponse_GetWord(reply_p, 0)) != device) )
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+
+ dev_p->storage_device_info[bus][device].block_size = CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+ }
+ else
+ ret = CY_AS_ERROR_INVALID_REQUEST ;
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+MyStorageDeviceControl(
+ CyAsDevice *dev_p,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyBool card_detect_en,
+ CyBool write_prot_en,
+ CyAsStorageCardDetect config_detect,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret ;
+ CyBool use_gpio = CyFalse ;
+
+ (void)device ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ /* If SD is not supported on the specified bus, then return ERROR */
+ if((dev_p->media_supported[bus] ==0 ) || (dev_p->media_supported[bus] &(1<<CyAsMediaNand)))
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ if(config_detect == CyAsStorageDetect_GPIO)
+ use_gpio = CyTrue ;
+ else if(config_detect == CyAsStorageDetect_SDAT_3)
+ use_gpio = CyFalse ;
+ else
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SD_INTERFACE_CONTROL, CY_RQT_STORAGE_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, device, 0)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (((uint16_t)card_detect_en << 8) | ((uint16_t)use_gpio << 1) | (uint16_t)write_prot_en)) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+ else
+ {
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_DEVICECONTROL,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageDeviceControl(CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyBool card_detect_en,
+ CyBool write_prot_en,
+ CyAsStorageCardDetect config_detect,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ return MyStorageDeviceControl(dev_p, bus, device, card_detect_en, write_prot_en, config_detect, cb, client);
+}
+
+static void
+CyAsAsyncStorageCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t ret)
+{
+ CyAsStorageCallback_dep cb ;
+ CyAsStorageCallback cb_ms ;
+
+ (void)size ;
+ (void)buf_p ;
+ (void)ep ;
+
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+
+ /*
+ * If the LL request callback has already been called, the user
+ * callback has to be called from here.
+ */
+ if (!dev_p->storage_wait)
+ {
+ CyAsHalAssert(dev_p->storage_cb != NULL || dev_p->storage_cb_ms != NULL) ;
+ cb = dev_p->storage_cb ;
+ cb_ms = dev_p->storage_cb_ms ;
+
+ dev_p->storage_cb = 0 ;
+ dev_p->storage_cb_ms = 0 ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ ret = dev_p->storage_error ;
+
+ if (cb_ms)
+ {
+ cb_ms((CyAsDeviceHandle)dev_p, dev_p->storage_bus_index, dev_p->storage_device_index,
+ dev_p->storage_unit, dev_p->storage_block_addr, dev_p->storage_oper, ret) ;
+ }
+ else
+ {
+ cb((CyAsDeviceHandle)dev_p,
+ dev_p->storage_device_info[dev_p->storage_bus_index][dev_p->storage_device_index].type,
+ dev_p->storage_device_index, dev_p->storage_unit, dev_p->storage_block_addr, dev_p->storage_oper, ret) ;
+ }
+ }
+ else
+ dev_p->storage_error = ret ;
+}
+
+static void
+CyAsAsyncStorageReplyCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ CyAsStorageCallback_dep cb ;
+ CyAsStorageCallback cb_ms ;
+ uint8_t reqtype ;
+ (void)rqt ;
+ (void)context ;
+
+ reqtype = CyAsLLRequestResponse_GetCode(rqt) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp) == CY_RESP_ANTIOCH_DEFERRED_ERROR)
+ {
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) & 0x00FF ;
+ }
+ else if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ }
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if(reqtype == CY_RQT_READ_BLOCK)
+ CyAsDmaCancel(dev_p, dev_p->storage_read_endpoint, ret) ;
+ else
+ CyAsDmaCancel(dev_p, dev_p->storage_write_endpoint, ret) ;
+ }
+
+ dev_p->storage_wait = CyFalse ;
+
+ /*
+ * If the DMA callback has already been called, the user callback
+ * has to be called from here.
+ */
+ if (!CyAsDeviceIsStorageAsyncPending(dev_p))
+ {
+ CyAsHalAssert(dev_p->storage_cb != NULL || dev_p->storage_cb_ms != NULL) ;
+ cb = dev_p->storage_cb ;
+ cb_ms = dev_p->storage_cb_ms ;
+
+ dev_p->storage_cb = 0 ;
+ dev_p->storage_cb_ms = 0 ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ ret = dev_p->storage_error ;
+
+ if (cb_ms)
+ {
+ cb_ms((CyAsDeviceHandle)dev_p, dev_p->storage_bus_index, dev_p->storage_device_index,
+ dev_p->storage_unit, dev_p->storage_block_addr, dev_p->storage_oper, ret) ;
+ }
+ else
+ {
+ cb((CyAsDeviceHandle)dev_p,
+ dev_p->storage_device_info[dev_p->storage_bus_index][dev_p->storage_device_index].type,
+ dev_p->storage_device_index, dev_p->storage_unit, dev_p->storage_block_addr, dev_p->storage_oper, ret) ;
+ }
+ }
+ else
+ dev_p->storage_error = ret ;
+}
+
+static CyAsReturnStatus_t
+CyAsStorageAsyncOper(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, uint8_t reqtype, uint16_t req_flags,
+ CyAsBusNumber_t bus, uint32_t device, uint32_t unit,
+ uint32_t block, void *data_p, uint16_t num_blocks,
+ CyAsStorageCallback_dep callback, CyAsStorageCallback callback_ms)
+{
+ uint32_t mask ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (unit > 255)
+ return CY_AS_ERROR_NO_SUCH_UNIT ;
+
+ /* We are supposed to return sucess if the number of
+ * blocks is zero
+ */
+ if (num_blocks == 0)
+ {
+ if (callback_ms)
+ callback_ms((CyAsDeviceHandle)dev_p, bus, device, unit, block,
+ ((reqtype == CY_RQT_WRITE_BLOCK) ? CyAsOpWrite : CyAsOpRead),
+ CY_AS_ERROR_SUCCESS) ;
+ else
+ callback((CyAsDeviceHandle)dev_p, dev_p->storage_device_info[bus][device].type,
+ device, unit, block, ((reqtype == CY_RQT_WRITE_BLOCK) ? CyAsOpWrite : CyAsOpRead),
+ CY_AS_ERROR_SUCCESS) ;
+
+ return CY_AS_ERROR_SUCCESS ;
+ }
+
+ if (dev_p->storage_device_info[bus][device].block_size == 0)
+ return CY_AS_ERROR_QUERY_DEVICE_NEEDED ;
+
+ /*
+ * Since async operations can be triggered by interrupt code, we must
+ * insure that we do not get multiple async operations going at one time and
+ * protect this test and set operation from interrupts.
+ * Also need to check for pending Async MTP writes
+ */
+ mask = CyAsHalDisableInterrupts() ;
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait) || (CyAsDeviceIsUsbAsyncPending(dev_p, 6)))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+
+ CyAsDeviceSetStorageAsyncPending(dev_p) ;
+ CyAsHalEnableInterrupts(mask) ;
+
+ /*
+ * Storage information about the currently outstanding request
+ */
+ dev_p->storage_cb = callback ;
+ dev_p->storage_cb_ms = callback_ms ;
+ dev_p->storage_bus_index = bus ;
+ dev_p->storage_device_index = device ;
+ dev_p->storage_unit = unit ;
+ dev_p->storage_block_addr = block ;
+
+ /* Initialise the request to send to the West Bridge. */
+ req_p = dev_p->storage_rw_req_p ;
+ CyAsLLInitRequest(req_p, reqtype, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;
+
+ /* Initialise the space for reply from the West Bridge. */
+ reply_p = dev_p->storage_rw_resp_p ;
+ CyAsLLInitResponse(reply_p, 5) ;
+
+ /* Remember which version of the API originated the request */
+ req_p->flags |= req_flags ;
+
+ /* Setup the DMA request and adjust the storage operation if we are reading */
+ if (reqtype == CY_RQT_READ_BLOCK)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data_p, dev_p->storage_device_info[bus][device].block_size * num_blocks,
+ CyFalse, CyTrue, CyAsAsyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpRead ;
+ }
+ else if (reqtype == CY_RQT_WRITE_BLOCK)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data_p, dev_p->storage_device_info[bus][device].block_size * num_blocks,
+ CyFalse, CyFalse, CyAsAsyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpWrite ;
+ }
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ return ret ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, (uint8_t)unit)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((block >> 16) & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(block & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)((num_blocks >> 8) & 0x00ff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 4, (uint16_t)((num_blocks << 8) & 0xff00)) ;
+
+ /* Set the burst mode flag. */
+ if (dev_p->is_storage_only_mode)
+ req_p->data[4] |= 0x0001;
+
+ /* Send the request and wait for completion of storage request */
+ dev_p->storage_wait = CyTrue ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyTrue, CyAsAsyncStorageReplyCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ }
+
+ return ret ;
+}
+
+static void
+CyAsSyncStorageCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ (void)ep ;
+ (void)buf_p ;
+ (void)size ;
+
+ dev_p->storage_error = err ;
+}
+
+static void
+CyAsSyncStorageReplyCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ uint8_t reqtype ;
+ (void)rqt ;
+
+ reqtype = CyAsLLRequestResponse_GetCode(rqt) ;
+
+ if (CyAsLLRequestResponse_GetCode(resp) == CY_RESP_ANTIOCH_DEFERRED_ERROR)
+ {
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) & 0x00FF ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if(reqtype == CY_RQT_READ_BLOCK)
+ CyAsDmaCancel(dev_p, dev_p->storage_read_endpoint, ret) ;
+ else
+ CyAsDmaCancel(dev_p, dev_p->storage_write_endpoint, ret) ;
+ }
+ }
+ else if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+
+ dev_p->storage_wait = CyFalse ;
+ dev_p->storage_error = ret ;
+
+ /* Wake any threads/processes that are waiting on the read/write completion. */
+ CyAsHalWake (&dev_p->context[context]->channel) ;
+}
+
+static CyAsReturnStatus_t
+CyAsStorageSyncOper(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, uint8_t reqtype, CyAsBusNumber_t bus, uint32_t device,
+ uint32_t unit, uint32_t block, void *data_p, uint16_t num_blocks)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsContext *ctxt_p ;
+ uint32_t loopcount = 200 ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (unit > 255)
+ return CY_AS_ERROR_NO_SUCH_UNIT ;
+
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ /* Also need to check for pending Async MTP writes */
+ if(CyAsDeviceIsUsbAsyncPending(dev_p, 6))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ /* We are supposed to return sucess if the number of
+ * blocks is zero
+ */
+ if (num_blocks == 0)
+ return CY_AS_ERROR_SUCCESS ;
+
+ if (dev_p->storage_device_info[bus][device].block_size == 0)
+ {
+ /*
+ * Normally, a given device has been queried via the query device call before a
+ * read request is issued. Therefore, this normally will not be run.
+ */
+ ret = CyAsGetBlockSize(dev_p, bus, device, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ /* Initialise the request to send to the West Bridge. */
+ req_p = dev_p->storage_rw_req_p ;
+ CyAsLLInitRequest(req_p, reqtype, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;
+
+ /* Initialise the space for reply from the West Bridge. */
+ reply_p = dev_p->storage_rw_resp_p ;
+ CyAsLLInitResponse(reply_p, 5) ;
+
+ /* Setup the DMA request */
+ if (reqtype == CY_RQT_READ_BLOCK)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data_p, dev_p->storage_device_info[bus][device].block_size * num_blocks, CyFalse,
+ CyTrue, CyAsSyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpRead ;
+ }
+ else if (reqtype == CY_RQT_WRITE_BLOCK)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data_p, dev_p->storage_device_info[bus][device].block_size * num_blocks, CyFalse,
+ CyFalse, CyAsSyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpWrite ;
+ }
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, (uint8_t)unit)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((block >> 16) & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(block & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)((num_blocks >> 8) & 0x00ff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 4, (uint16_t)((num_blocks << 8) & 0xff00)) ;
+
+ /* Set the burst mode flag. */
+ if (dev_p->is_storage_only_mode)
+ req_p->data[4] |= 0x0001;
+
+ /* Send the request and wait for completion of storage request */
+ dev_p->storage_wait = CyTrue ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyTrue, CyAsSyncStorageReplyCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ }
+ else
+ {
+ /* Setup the DMA request */
+ ctxt_p = dev_p->context[CY_RQT_STORAGE_RQT_CONTEXT] ;
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyFalse) ;
+
+ while (loopcount-- > 0)
+ {
+ if (dev_p->storage_wait == CyFalse)
+ break ;
+ CyAsHalSleepOn(&ctxt_p->channel, 10) ;
+ }
+
+ if (dev_p->storage_wait == CyTrue)
+ {
+ dev_p->storage_wait = CyFalse ;
+ CyAsLLRemoveRequest(dev_p, ctxt_p, req_p, CyTrue) ;
+ ret = CY_AS_ERROR_TIMEOUT ;
+ }
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ ret = dev_p->storage_error ;
+ }
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRead(CyAsDeviceHandle handle, CyAsBusNumber_t bus, uint32_t device, uint32_t unit, uint32_t block,
+ void *data_p, uint16_t num_blocks)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ return CyAsStorageSyncOper(dev_p, dev_p->storage_read_endpoint, CY_RQT_READ_BLOCK, bus, device,
+ unit, block, data_p, num_blocks) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageWrite(CyAsDeviceHandle handle, CyAsBusNumber_t bus, uint32_t device, uint32_t unit, uint32_t block,
+ void *data_p, uint16_t num_blocks)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if(dev_p->mtp_turbo_active)
+ return CY_AS_ERROR_NOT_VALID_DURING_MTP ;
+
+ return CyAsStorageSyncOper(dev_p, dev_p->storage_write_endpoint, CY_RQT_WRITE_BLOCK, bus, device,
+ unit, block, data_p, num_blocks) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageReadAsync(CyAsDeviceHandle handle, CyAsBusNumber_t bus, uint32_t device, uint32_t unit,
+ uint32_t block, void *data_p, uint16_t num_blocks, CyAsStorageCallback callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (callback == 0)
+ return CY_AS_ERROR_NULL_CALLBACK ;
+
+ return CyAsStorageAsyncOper(dev_p, dev_p->storage_read_endpoint, CY_RQT_READ_BLOCK,
+ CY_AS_REQUEST_RESPONSE_MS, bus, device, unit, block, data_p, num_blocks, NULL, callback);
+}
+
+CyAsReturnStatus_t
+CyAsStorageWriteAsync(CyAsDeviceHandle handle, CyAsBusNumber_t bus, uint32_t device, uint32_t unit,
+ uint32_t block, void *data_p, uint16_t num_blocks, CyAsStorageCallback callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (callback == 0)
+ return CY_AS_ERROR_NULL_CALLBACK ;
+
+ if(dev_p->mtp_turbo_active)
+ return CY_AS_ERROR_NOT_VALID_DURING_MTP ;
+
+ return CyAsStorageAsyncOper(dev_p, dev_p->storage_write_endpoint, CY_RQT_WRITE_BLOCK,
+ CY_AS_REQUEST_RESPONSE_MS, bus, device, unit, block, data_p, num_blocks, NULL, callback);
+}
+
+
+static void
+MyStorageCancelCallback (
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ (void)context ;
+ (void)stat ;
+
+ /* Nothing to do here, except free up the request and response structures. */
+ CyAsLLDestroyResponse(dev_p, resp) ;
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageCancelAsync(CyAsDeviceHandle handle)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (!CyAsDeviceIsStorageAsyncPending(dev_p))
+ return CY_AS_ERROR_ASYNC_NOT_PENDING ;
+
+ /*
+ * Create and send a mailbox request to firmware asking it to abort processing
+ * of the current P2S operation. The rest of the cancel processing will be
+ * driven through the callbacks for the read/write call.
+ */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_ABORT_P2S_XFER, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, MyStorageCancelCallback) ;
+ if (ret)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+ * This function does all the API side clean-up associated with
+ * CyAsStorageStop, without any communication with the firmware.
+ */
+void CyAsStorageCleanup(CyAsDevice *dev_p)
+{
+ if (dev_p->storage_count)
+ {
+ CyAsLLDestroyRequest(dev_p, dev_p->storage_rw_req_p) ;
+ CyAsLLDestroyResponse(dev_p, dev_p->storage_rw_resp_p) ;
+ dev_p->storage_count = 0 ;
+ CyAsDeviceClearScsiMessages(dev_p) ;
+ CyAsHalMemSet(dev_p->storage_device_info, 0, sizeof(dev_p->storage_device_info)) ;
+
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ dev_p->storage_cb = 0 ;
+ dev_p->storage_cb_ms = 0 ;
+ dev_p->storage_wait = CyFalse ;
+ }
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseSDRegRead(
+ CyAsDevice *dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsStorageSDRegReadData *info)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t resp_type, i ;
+ uint16_t resp_len ;
+ uint8_t length = info->length ;
+ uint8_t *data_p = info->buf_p ;
+
+ resp_type = CyAsLLRequestResponse_GetCode(reply_p) ;
+ if (resp_type == CY_RESP_SD_REGISTER_DATA)
+ {
+ uint16_t *resp_p = reply_p->data + 1 ;
+ uint16_t temp ;
+
+ resp_len = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ CyAsHalAssert(resp_len >= length) ;
+
+ /*
+ * Copy the values into the output buffer after doing the
+ * necessary bit shifting. The bit shifting is required because
+ * the data comes out of the West Bridge with a 6 bit offset.
+ */
+ i = 0 ;
+ while (length)
+ {
+ temp = ((resp_p[i] << 6) | (resp_p[i + 1] >> 10)) ;
+ i++ ;
+
+ *data_p++ = (uint8_t)(temp >> 8) ;
+ length-- ;
+
+ if (length)
+ {
+ *data_p++ = (uint8_t)(temp & 0xFF) ;
+ length-- ;
+ }
+ }
+ }
+ else
+ {
+ if (resp_type == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageSDRegisterRead(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint8_t device,
+ CyAsSDCardRegType regType,
+ CyAsStorageSDRegReadData *data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t length ;
+
+ /*
+ * Sanity checks required before sending the request to the
+ * firmware.
+ */
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (regType > CyAsSDReg_CSD)
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ /* If SD/MMC media is not supported on the addressed bus, return error. */
+ if ((dev_p->media_supported[bus] & (1 << CyAsMediaSDFlash)) == 0)
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ /*
+ * Find the amount of data to be returned. This will be the minimum of
+ * the actual data length, and the length requested.
+ */
+ switch (regType)
+ {
+ case CyAsSDReg_OCR:
+ length = CY_AS_SD_REG_OCR_LENGTH ;
+ break ;
+
+ case CyAsSDReg_CID:
+ length = CY_AS_SD_REG_CID_LENGTH ;
+ break ;
+
+ case CyAsSDReg_CSD:
+ length = CY_AS_SD_REG_CSD_LENGTH ;
+ break ;
+
+ default:
+ length = 0 ;
+ CyAsHalAssert(0) ;
+ }
+
+ if (length < data_p->length)
+ data_p->length = length ;
+ length = data_p->length ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SD_REGISTER_READ, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (CreateAddress(bus, device, 0) | (uint16_t)regType)) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, CY_AS_SD_REG_MAX_RESP_LENGTH) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseSDRegRead(dev_p, req_p, reply_p, data_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_SDREGISTERREAD,
+ data_p, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the MiscFuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageCreatePPartition(
+ CyAsDeviceHandle handle, /* Handle to the device of interest */
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint32_t size, /* of P-port only partition in blocks */
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Partitions cannot be created or deleted while the USB stack is active. */
+ if (dev_p->usb_count)
+ return CY_AS_ERROR_USB_RUNNING ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_PARTITION_STORAGE, CY_RQT_STORAGE_RQT_CONTEXT, 3) ;
+ if (req_p == 0)
+ {
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0x00) );
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((size >> 16) & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(size & 0xffff)) ;
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_PARTITION,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRemovePPartition(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Partitions cannot be created or deleted while the USB stack is active. */
+ if (dev_p->usb_count)
+ return CY_AS_ERROR_USB_RUNNING ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_PARTITION_ERASE, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ {
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0x00) );
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_NODATA,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseGetTransferAmount(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsMSCProgressData *data)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code = CyAsLLRequestResponse_GetCode(reply_p) ;
+ uint16_t v1, v2 ;
+
+ if (code != CY_RESP_TRANSFER_COUNT)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ v1 = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ v2 = CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+ data->wr_count = (uint32_t)((v1 << 16) | v2) ;
+
+ v1 = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ v2 = CyAsLLRequestResponse_GetWord(reply_p, 3) ;
+ data->rd_count = (uint32_t)((v1 << 16) | v2) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageGetTransferAmount(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsMSCProgressData *data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* Check if the firmware image supports this feature. */
+ if ((dev_p->media_supported[0]) && (dev_p->media_supported[0] == (1 << CyAsMediaNand)))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_GET_TRANSFER_AMOUNT, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ {
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed four words. */
+ reply_p = CyAsLLCreateResponse(dev_p, 4) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0x00));
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseGetTransferAmount(dev_p, req_p, reply_p, data_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_GETTRANSFERAMOUNT,
+ (void *)data_p, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+
+}
+
+CyAsReturnStatus_t
+CyAsStorageErase(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint32_t erase_unit,
+ uint16_t num_erase_units,
+ CyAsFunctionCallback cb,
+ uint32_t client
+ )
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsStorageActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (dev_p->storage_device_info[bus][device].block_size == 0)
+ return CY_AS_ERROR_QUERY_DEVICE_NEEDED ;
+
+ /* If SD is not supported on the specified bus, then return ERROR */
+ if(dev_p->storage_device_info[bus][device].type != CyAsMediaSDFlash)
+ return CY_AS_ERROR_NOT_SUPPORTED;
+
+ if (num_erase_units == 0)
+ return CY_AS_ERROR_SUCCESS ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_ERASE, CY_RQT_STORAGE_RQT_CONTEXT, 5) ;
+ if (req_p == 0)
+ {
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed four words. */
+ reply_p = CyAsLLCreateResponse(dev_p, 4) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0x00));
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((erase_unit >> 16) & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(erase_unit & 0xffff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)((num_erase_units >> 8) & 0x00ff)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 4, (uint16_t)((num_erase_units << 8) & 0xff00)) ;
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+
+ /* If error = "invalid response", this (very likely) means that we are not using the SD-only firmware module
+ which is the only one supporting StorageErase. In this case force a "non supported" error code */
+ if (ret == CY_AS_ERROR_INVALID_RESPONSE)
+ ret = CY_AS_ERROR_NOT_SUPPORTED;
+
+ return ret ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_STOR_ERASE,
+ 0, dev_p->func_cbs_stor, CY_AS_REQUEST_RESPONSE_EX,
+ req_p, reply_p, CyAsStorageFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* The request and response are freed as part of the FuncCallback */
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static void
+CyAsStorageFuncCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)dev_p->func_cbs_stor->head_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyBool exRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX) == CY_AS_REQUEST_RESPONSE_EX ;
+ CyBool msRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS) == CY_AS_REQUEST_RESPONSE_MS ;
+ uint8_t code ;
+ uint8_t cntxt ;
+
+ CyAsHalAssert(exRequest || msRequest) ;
+ CyAsHalAssert(dev_p->func_cbs_stor->count != 0) ;
+ CyAsHalAssert(dev_p->func_cbs_stor->type == CYAS_FUNC_CB) ;
+ (void) exRequest;
+ (void) msRequest;
+
+ (void)context ;
+
+ cntxt = CyAsLLRequestResponse_GetContext(rqt) ;
+ CyAsHalAssert(cntxt == CY_RQT_STORAGE_RQT_CONTEXT) ;
+
+ code = CyAsLLRequestResponse_GetCode(rqt) ;
+ switch(code)
+ {
+ case CY_RQT_START_STORAGE:
+ ret = MyHandleResponseStorageStart(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_STOP_STORAGE:
+ ret = MyHandleResponseStorageStop(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_CLAIM_STORAGE:
+ ret = MyHandleResponseStorageClaim(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_RELEASE_STORAGE:
+ ret = MyHandleResponseStorageRelease(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_QUERY_MEDIA:
+ CyAsHalAssert(CyFalse) ; /* Not used any more. */
+ break ;
+ case CY_RQT_QUERY_BUS:
+ CyAsHalAssert(node->data != 0) ;
+ ret = MyHandleResponseStorageQueryBus(dev_p, rqt, resp, (uint32_t*)node->data) ;
+ break ;
+ case CY_RQT_QUERY_DEVICE:
+ CyAsHalAssert(node->data != 0) ;
+ ret = MyHandleResponseStorageQueryDevice(dev_p, rqt, resp, node->data) ;
+ break ;
+ case CY_RQT_QUERY_UNIT:
+ CyAsHalAssert(node->data != 0) ;
+ ret = MyHandleResponseStorageQueryUnit(dev_p, rqt, resp, node->data) ;
+ break ;
+ case CY_RQT_SD_INTERFACE_CONTROL:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_SD_REGISTER_READ:
+ CyAsHalAssert(node->data != 0) ;
+ ret = MyHandleResponseSDRegRead(dev_p, rqt, resp, (CyAsStorageSDRegReadData *)node->data) ;
+ break ;
+ case CY_RQT_PARTITION_STORAGE:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp);
+ break ;
+ case CY_RQT_PARTITION_ERASE:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_GET_TRANSFER_AMOUNT:
+ CyAsHalAssert(node->data != 0) ;
+ ret = MyHandleResponseGetTransferAmount(dev_p, rqt, resp, (CyAsMSCProgressData *)node->data) ;
+ break ;
+ case CY_RQT_ERASE:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+
+ /* If error = "invalid response", this (very likely) means that we are not using the SD-only firmware module
+ which is the only one supporting StorageErase. In this case force a "non supported" error code */
+ if (ret == CY_AS_ERROR_INVALID_RESPONSE)
+ ret = CY_AS_ERROR_NOT_SUPPORTED;
+
+ break ;
+
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /*
+ * If the low level layer returns a direct error, use the corresponding error code.
+ * If not, use the error code based on the response from firmware.
+ */
+ if (stat == CY_AS_ERROR_SUCCESS)
+ stat = ret ;
+
+ /* Call the user callback, if there is one */
+ if (node->cb_p)
+ node->cb_p((CyAsDeviceHandle)dev_p, stat, node->client_data, (CyAsFunctCBType)node->dataType, node->data) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_stor) ;
+}
+
+
+static void
+CyAsSdioSyncReplyCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ (void)rqt ;
+
+ if ((CyAsLLRequestResponse_GetCode(resp) == CY_RESP_SDIO_GET_TUPLE )||
+ (CyAsLLRequestResponse_GetCode(resp) == CY_RESP_SDIO_EXT))
+ {
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ if ((ret & 0x00FF) != CY_AS_ERROR_SUCCESS)
+ {
+ if(CyAsLLRequestResponse_GetCode(rqt) == CY_RQT_SDIO_READ_EXTENDED)
+ CyAsDmaCancel(dev_p, dev_p->storage_read_endpoint, ret) ;
+ else
+ CyAsDmaCancel(dev_p, dev_p->storage_write_endpoint, ret) ;
+ }
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+
+ dev_p->storage_rw_resp_p=resp;
+ dev_p->storage_wait = CyFalse ;
+ if(((ret & 0x00FF) == CY_AS_ERROR_IO_ABORTED) || ((ret & 0x00FF) == CY_AS_ERROR_IO_SUSPENDED))
+ dev_p->storage_error = (ret & 0x00FF);
+ else
+ dev_p->storage_error = (ret & 0x00FF)? CY_AS_ERROR_INVALID_RESPONSE : CY_AS_ERROR_SUCCESS ;
+
+ /* Wake any threads/processes that are waiting on the read/write completion. */
+ CyAsHalWake (&dev_p->context[context]->channel);
+}
+
+CyAsReturnStatus_t
+CyAsSdioDeviceCheck(
+ CyAsDevice* dev_p,
+ CyAsBusNumber_t bus,
+ uint32_t device)
+{
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (bus < 0 || bus >= CY_AS_MAX_BUSES)
+ return CY_AS_ERROR_NO_SUCH_BUS ;
+
+ if (device >= CY_AS_MAX_STORAGE_DEVICES)
+ return CY_AS_ERROR_NO_SUCH_DEVICE ;
+
+ if (!CyAsDeviceIsAstoriaDev(dev_p))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ return (IsStorageActive(dev_p)) ;
+}
+
+CyAsReturnStatus_t
+CyAsSdioDirectIo(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t isWrite,
+ uint8_t * data_p )
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t resp_data;
+
+ /*
+ * Sanity checks required before sending the request to the
+ * firmware.
+ */
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(CyAsSdioCheckFunctionSuspended(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_FUNCTION_SUSPENDED;
+
+ req_p = CyAsLLCreateRequest(dev_p, (isWrite==CyTrue)?CY_RQT_SDIO_WRITE_DIRECT:CY_RQT_SDIO_READ_DIRECT,
+ CY_RQT_STORAGE_RQT_CONTEXT, 3) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /*Setting up request*/
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo) ) ;
+ /* D1 */
+ if(isWrite==CyTrue)
+ {
+ CyAsLLRequestResponse_SetWord(req_p, 1, ((argument<<8)|0x0080|(nFunctionNo<<4)|
+ ((miscBuf&CY_SDIO_RAW)<<3)|((miscBuf&CY_SDIO_REARM_INT)>>5)|(uint16_t)(address>>15)));
+ }
+ else
+ {
+ CyAsLLRequestResponse_SetWord(req_p, 1, (nFunctionNo<<4)|((miscBuf&CY_SDIO_REARM_INT)>>5)|
+ (uint16_t)(address>>15));
+ }
+ /* D2 */
+ CyAsLLRequestResponse_SetWord(req_p, 2, ((uint16_t)((address&0x00007fff)<<1))) ;
+
+ /*Create response*/
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /*Sending the request*/
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /*Check reply type*/
+ if ( CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SDIO_DIRECT)
+ {
+ resp_data = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if(resp_data>>8)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ else if (data_p!=0)
+ *(uint8_t*)(data_p)=(uint8_t)(resp_data&0x00ff);
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+
+destroy:
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsSdioDirectRead(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint8_t * data_p)
+{
+ return (CyAsSdioDirectIo(handle,bus,device, nFunctionNo, address, miscBuf, 0x00, CyFalse, data_p));
+}
+
+CyAsReturnStatus_t
+CyAsSdioDirectWrite(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t * data_p)
+{
+ return (CyAsSdioDirectIo(handle,bus,device, nFunctionNo, address, miscBuf, argument, CyTrue, data_p));
+}
+
+/*Cmd53 IO*/
+CyAsReturnStatus_t
+CyAsSdioExtendedIO(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t isWrite,
+ uint8_t * data_p ,
+ uint8_t isResume)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t resp_type;
+ uint8_t reqtype;
+ uint16_t resp_data;
+ CyAsContext *ctxt_p ;
+ uint32_t dmasize,loopcount = 200;
+ CyAsEndPointNumber_t ep;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(CyAsSdioCheckFunctionSuspended(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_FUNCTION_SUSPENDED;
+
+
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+ /* Request for 0 bytes of blocks is returned as a success*/
+ if(argument == 0)
+ return CY_AS_ERROR_SUCCESS;
+
+ /* Initialise the request to send to the West Bridge device. */
+ if(isWrite == CyTrue)
+ {
+ reqtype =CY_RQT_SDIO_WRITE_EXTENDED;
+ ep=dev_p->storage_write_endpoint;
+ }
+ else
+ {
+ reqtype=CY_RQT_SDIO_READ_EXTENDED;
+ ep=dev_p->storage_read_endpoint;
+ }
+
+ req_p = dev_p->storage_rw_req_p ;
+ CyAsLLInitRequest(req_p, reqtype, CY_RQT_STORAGE_RQT_CONTEXT, 3) ;
+
+ /* Initialise the space for reply from the Antioch. */
+ reply_p = dev_p->storage_rw_resp_p ;
+ CyAsLLInitResponse(reply_p, 2) ;
+
+ /* Setup the DMA request */
+ if(!(miscBuf&CY_SDIO_BLOCKMODE))
+ {
+ if(argument > dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize)
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+
+ }
+ else
+ {
+ if( argument > 511)
+ {
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+ }
+ }
+
+ if(argument == 512)
+ argument =0;
+
+ dmasize=((miscBuf&CY_SDIO_BLOCKMODE) !=0)? dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize*argument:argument;
+
+ ret = CyAsDmaQueueRequest(dev_p, ep, (void*)(data_p), dmasize, CyFalse,
+ (isWrite & CyTrue)?CyFalse:CyTrue, CyAsSyncStorageCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo|((isResume)?0x80:0x00) )) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, ((uint16_t)nFunctionNo)<<12|
+ ((uint16_t)(miscBuf&(CY_SDIO_BLOCKMODE|CY_SDIO_OP_INCR)))<<9|
+ (uint16_t)(address>>7)|((isWrite==CyTrue)?0x8000:0x0000 )) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, ((uint16_t)(address&0x0000ffff)<<9) | argument) ;
+
+
+ /* Send the request and wait for completion of storage request */
+ dev_p->storage_wait = CyTrue ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyTrue, CyAsSdioSyncReplyCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ }
+ else
+ {
+ /* Setup the DMA request */
+ ctxt_p = dev_p->context[CY_RQT_STORAGE_RQT_CONTEXT] ;
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyTrue) ;
+
+ while (loopcount-- > 0)
+ {
+ if (dev_p->storage_wait == CyFalse)
+ break;
+ CyAsHalSleepOn(&ctxt_p->channel, 10) ;
+ }
+ if (dev_p->storage_wait == CyTrue)
+ {
+ dev_p->storage_wait = CyFalse ;
+ CyAsLLRemoveRequest(dev_p, ctxt_p, req_p, CyTrue) ;
+ dev_p->storage_error = CY_AS_ERROR_TIMEOUT ;
+ }
+
+ ret=dev_p->storage_error;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+
+
+ resp_type = CyAsLLRequestResponse_GetCode(dev_p->storage_rw_resp_p) ;
+ if (resp_type == CY_RESP_SDIO_EXT)
+ {
+ resp_data = CyAsLLRequestResponse_GetWord(reply_p, 0)&0x00ff ;
+ if(resp_data)
+ {
+ ret = CY_AS_ERROR_INVALID_REQUEST ;
+ }
+
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ }
+ return ret;
+
+}
+
+static void
+CyAsSdioAsyncReplyCallback(
+ CyAsDevice* dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse* rqt,
+ CyAsLLRequestResponse* resp,
+ CyAsReturnStatus_t ret )
+{
+ CyAsStorageCallback cb_ms ;
+ uint8_t reqtype ;
+ uint32_t pendingblocks;
+ (void)rqt ;
+ (void)context ;
+
+ pendingblocks = 0;
+ reqtype = CyAsLLRequestResponse_GetCode(rqt) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if ((CyAsLLRequestResponse_GetCode(resp) == CY_RESP_SUCCESS_FAILURE) ||
+ (CyAsLLRequestResponse_GetCode(resp) == CY_RESP_SDIO_EXT))
+ {
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ ret &= 0x00FF ;
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ }
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if(reqtype == CY_RQT_SDIO_READ_EXTENDED)
+ CyAsDmaCancel(dev_p, dev_p->storage_read_endpoint, ret) ;
+ else
+ CyAsDmaCancel(dev_p, dev_p->storage_write_endpoint, ret) ;
+
+ dev_p->storage_error = ret;
+ }
+
+
+
+ dev_p->storage_wait = CyFalse ;
+
+ /*
+ * If the DMA callback has already been called, the user callback
+ * has to be called from here.
+ */
+ if (!CyAsDeviceIsStorageAsyncPending(dev_p))
+ {
+ CyAsHalAssert(dev_p->storage_cb_ms != NULL) ;
+ cb_ms = dev_p->storage_cb_ms ;
+
+ dev_p->storage_cb = 0 ;
+ dev_p->storage_cb_ms = 0 ;
+
+ if ((ret == CY_AS_ERROR_SUCCESS) || (ret == CY_AS_ERROR_IO_ABORTED) || (ret == CY_AS_ERROR_IO_SUSPENDED))
+ {
+ ret = dev_p->storage_error ;
+ pendingblocks = ((uint32_t)CyAsLLRequestResponse_GetWord(resp, 1))<<16;
+ }
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE;
+
+ cb_ms((CyAsDeviceHandle)dev_p, dev_p->storage_bus_index, dev_p->storage_device_index,
+ (dev_p->storage_unit | pendingblocks), dev_p->storage_block_addr, dev_p->storage_oper, ret) ;
+ }
+ else
+ dev_p->storage_error = ret ;
+}
+
+
+CyAsReturnStatus_t
+CyAsSdioExtendedIOAsync(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t isWrite,
+ uint8_t * data_p,
+ CyAsStorageCallback callback )
+{
+
+ uint32_t mask ;
+ uint32_t dmasize;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ uint8_t reqtype;
+ CyAsEndPointNumber_t ep;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(CyAsSdioCheckFunctionSuspended(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_FUNCTION_SUSPENDED;
+
+ if (callback == 0)
+ return CY_AS_ERROR_NULL_CALLBACK ;
+
+ /* We are supposed to return sucess if the number of
+ * blocks is zero
+ */
+ if(((miscBuf&CY_SDIO_BLOCKMODE)!=0)&&(argument==0))
+ {
+ callback(handle, bus, device,nFunctionNo,address,((isWrite) ? CyAsOpWrite : CyAsOpRead), CY_AS_ERROR_SUCCESS) ;
+ return CY_AS_ERROR_SUCCESS ;
+ }
+
+
+ /*
+ * Since async operations can be triggered by interrupt code, we must
+ * insure that we do not get multiple async operations going at one time and
+ * protect this test and set operation from interrupts.
+ */
+ mask = CyAsHalDisableInterrupts() ;
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+ CyAsDeviceSetStorageAsyncPending(dev_p) ;
+ CyAsHalEnableInterrupts(mask) ;
+
+
+ /*
+ * Storage information about the currently outstanding request
+ */
+ dev_p->storage_cb_ms = callback ;
+ dev_p->storage_bus_index = bus ;
+ dev_p->storage_device_index = device ;
+ dev_p->storage_unit = nFunctionNo ;
+ dev_p->storage_block_addr = address ;
+
+ if(isWrite == CyTrue)
+ {
+ reqtype =CY_RQT_SDIO_WRITE_EXTENDED;
+ ep=dev_p->storage_write_endpoint;
+ }
+ else
+ {
+ reqtype=CY_RQT_SDIO_READ_EXTENDED;
+ ep=dev_p->storage_read_endpoint;
+ }
+
+ /* Initialise the request to send to the West Bridge. */
+ req_p = dev_p->storage_rw_req_p ;
+ CyAsLLInitRequest(req_p, reqtype, CY_RQT_STORAGE_RQT_CONTEXT, 3) ;
+
+ /* Initialise the space for reply from the West Bridge. */
+ reply_p = dev_p->storage_rw_resp_p ;
+ CyAsLLInitResponse(reply_p, 2) ;
+
+ if(!(miscBuf&CY_SDIO_BLOCKMODE))
+ {
+ if(argument > dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize)
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+
+ }
+ else
+ {
+ if( argument > 511)
+ {
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+ }
+ }
+
+ if(argument == 512)
+ argument =0;
+ dmasize=((miscBuf&CY_SDIO_BLOCKMODE) !=0)? dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize*argument:argument;
+
+ /* Setup the DMA request and adjust the storage operation if we are reading */
+ if (reqtype == CY_RQT_SDIO_READ_EXTENDED)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, (void*)data_p,dmasize , CyFalse, CyTrue,CyAsAsyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpRead ;
+ }
+ else if (reqtype == CY_RQT_SDIO_WRITE_EXTENDED)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, (void*)data_p, dmasize, CyFalse, CyFalse,CyAsAsyncStorageCallback) ;
+ dev_p->storage_oper = CyAsOpWrite ;
+ }
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ return ret ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo )) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, ((uint16_t)nFunctionNo)<<12|
+ ((uint16_t)(miscBuf&(CY_SDIO_BLOCKMODE|CY_SDIO_OP_INCR)))<<9|
+ (uint16_t)(address>>7)|((isWrite==CyTrue)?0x8000:0x0000 )) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, ((uint16_t)(address&0x0000ffff)<<9) | argument) ;
+
+
+ /* Send the request and wait for completion of storage request */
+ dev_p->storage_wait = CyTrue ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyTrue, CyAsSdioAsyncReplyCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ CyAsDeviceClearStorageAsyncPending(dev_p) ;
+ }
+ else
+ {
+ CyAsDmaKickStart(dev_p, ep) ;
+ }
+
+ return ret ;
+}
+
+/* CMD53 Extended Read*/
+CyAsReturnStatus_t
+CyAsSdioExtendedRead(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t * data_p,
+ CyAsSdioCallback callback )
+{
+ if (callback==0)
+ return CyAsSdioExtendedIO(handle,bus,device,nFunctionNo,address,miscBuf,argument,CyFalse,data_p,0);
+
+ return CyAsSdioExtendedIOAsync(handle,bus,device,nFunctionNo,address,miscBuf,argument,CyFalse,data_p,callback);
+}
+
+/* CMD53 Extended Write*/
+CyAsReturnStatus_t
+CyAsSdioExtendedWrite(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint32_t address,
+ uint8_t miscBuf,
+ uint16_t argument,
+ uint8_t * data_p,
+ CyAsSdioCallback callback )
+{
+ if (callback==0)
+ return CyAsSdioExtendedIO(handle,bus,device,nFunctionNo,address,miscBuf,argument,CyTrue,data_p,0);
+
+ return CyAsSdioExtendedIOAsync(handle,bus,device,nFunctionNo,address,miscBuf,argument,CyTrue,data_p,callback);
+}
+
+
+/* Read the CIS info tuples for the given function and Tuple ID*/
+CyAsReturnStatus_t
+CyAsSdioGetCISInfo(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint16_t tupleId,
+ uint8_t * data_p )
+{
+
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t resp_data;
+ CyAsContext *ctxt_p ;
+ uint32_t loopcount = 200;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!( CyAsSdioCheckFunctionInitialized(handle,bus,0) ))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ return CY_AS_ERROR_ASYNC_PENDING ;
+
+
+ /* Initialise the request to send to the Antioch. */
+ req_p = dev_p->storage_rw_req_p ;
+ CyAsLLInitRequest(req_p, CY_RQT_SDIO_GET_TUPLE, CY_RQT_STORAGE_RQT_CONTEXT, 2) ;
+
+ /* Initialise the space for reply from the Antioch. */
+ reply_p = dev_p->storage_rw_resp_p ;
+ CyAsLLInitResponse(reply_p, 3) ;
+
+ /* Setup the DMA request */
+ ret = CyAsDmaQueueRequest(dev_p, dev_p->storage_read_endpoint, data_p+1, 255, CyFalse, CyTrue,
+ CyAsSyncStorageCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo )) ;
+
+ /* Set tuple id to fetch. */
+ CyAsLLRequestResponse_SetWord(req_p, 1, tupleId<<8) ;
+
+ /* Send the request and wait for completion of storage request */
+ dev_p->storage_wait = CyTrue ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyTrue, CyAsSdioSyncReplyCallback) ;
+
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, dev_p->storage_read_endpoint, CY_AS_ERROR_CANCELED) ;
+ }
+ else
+ {
+ /* Setup the DMA request */
+ ctxt_p = dev_p->context[CY_RQT_STORAGE_RQT_CONTEXT] ;
+ ret = CyAsDmaDrainQueue(dev_p, dev_p->storage_read_endpoint, CyTrue) ;
+
+ while (loopcount-- > 0)
+ {
+ if (dev_p->storage_wait == CyFalse)
+ break;
+ CyAsHalSleepOn(&ctxt_p->channel, 10) ;
+ }
+
+ if (dev_p->storage_wait == CyTrue)
+ {
+ dev_p->storage_wait = CyFalse ;
+ CyAsLLRemoveRequest(dev_p, ctxt_p, req_p, CyTrue) ;
+ return CY_AS_ERROR_TIMEOUT ;
+ }
+ ret = dev_p->storage_error ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ return ret ;
+ }
+
+ if ( CyAsLLRequestResponse_GetCode(dev_p->storage_rw_resp_p) == CY_RESP_SDIO_GET_TUPLE)
+ {
+ resp_data = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if(resp_data)
+ {
+ ret = CY_AS_ERROR_INVALID_REQUEST ;
+ }
+ else if (data_p!=0)
+ *(uint8_t*)data_p=(uint8_t)(CyAsLLRequestResponse_GetWord(reply_p, 0)&0x00ff);
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ }
+ return ret;
+}
+
+/*Query Device*/
+CyAsReturnStatus_t
+CyAsSdioQueryCard(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsSDIOCard* data_p )
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ uint8_t resp_type;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ /* Allocating memory to the SDIO device structure in dev_p */
+
+ CyAsHalMemSet(& dev_p->sdiocard[bus],0,sizeof(CyAsSDIODevice));
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_QUERY_CARD, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0 )) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 5) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ resp_type = CyAsLLRequestResponse_GetCode(reply_p);
+ if ( resp_type == CY_RESP_SDIO_QUERY_CARD)
+ {
+ dev_p->sdiocard[bus].card.num_functions = (uint8_t)((reply_p->data[0]&0xff00)>>8);
+ dev_p->sdiocard[bus].card.memory_present = (uint8_t)reply_p->data[0]&0x0001;
+ dev_p->sdiocard[bus].card.manufacturer_Id = reply_p->data[1];
+ dev_p->sdiocard[bus].card.manufacturer_info = reply_p->data[2];
+ dev_p->sdiocard[bus].card.blocksize = reply_p->data[3];
+ dev_p->sdiocard[bus].card.maxblocksize = reply_p->data[3];
+ dev_p->sdiocard[bus].card.card_capability = (uint8_t)((reply_p->data[4]&0xff00)>>8);
+ dev_p->sdiocard[bus].card.sdio_version = (uint8_t)(reply_p->data[4]&0x00ff);
+ dev_p->sdiocard[bus].function_init_map = 0x01;
+ data_p->num_functions = dev_p->sdiocard[bus].card.num_functions;
+ data_p->memory_present = dev_p->sdiocard[bus].card.memory_present;
+ data_p->manufacturer_Id = dev_p->sdiocard[bus].card.manufacturer_Id;
+ data_p->manufacturer_info = dev_p->sdiocard[bus].card.manufacturer_info;
+ data_p->blocksize = dev_p->sdiocard[bus].card.blocksize;
+ data_p->maxblocksize = dev_p->sdiocard[bus].card.maxblocksize;
+ data_p->card_capability = dev_p->sdiocard[bus].card.card_capability;
+ data_p->sdio_version = dev_p->sdiocard[bus].card.sdio_version;
+ }
+ else
+ {
+ if (resp_type == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+destroy:
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+/*Reset SDIO card. */
+CyAsReturnStatus_t
+CyAsSdioResetCard(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device )
+{
+
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t resp_type;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(dev_p->sdiocard != 0)
+ {
+ dev_p->sdiocard[bus].function_init_map=0;
+ dev_p->sdiocard[bus].function_suspended_map = 0;
+ }
+
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_RESET_DEV, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /*Setup mailbox */
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, 0) ) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+
+ resp_type = CyAsLLRequestResponse_GetCode(reply_p) ;
+
+
+ if (resp_type == CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if(ret == CY_AS_ERROR_SUCCESS)
+ {
+ ret = CyAsSdioQueryCard(handle,bus,device,0);
+ }
+ }
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+
+destroy:
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+/* Initialise an IO function*/
+CyAsReturnStatus_t
+CyAsSdioInitFunction(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint8_t miscBuf )
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t resp_type;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,0)))
+ return CY_AS_ERROR_NOT_RUNNING;
+
+ if((CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ {
+ if(miscBuf&CY_SDIO_FORCE_INIT)
+ dev_p->sdiocard[bus].function_init_map&=(~(1<<nFunctionNo));
+ else
+ return CY_AS_ERROR_ALREADY_RUNNING;
+ }
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_INIT_FUNCTION, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo )) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 5) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ resp_type = CyAsLLRequestResponse_GetCode(reply_p) ;
+
+ if (resp_type == CY_RESP_SDIO_INIT_FUNCTION)
+ {
+
+ dev_p->sdiocard[bus].function[nFunctionNo-1].function_code = (uint8_t)((reply_p->data[0]&0xff00)>>8);
+ dev_p->sdiocard[bus].function[nFunctionNo-1].extended_func_code = (uint8_t)reply_p->data[0]&0x00ff;
+ dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize = reply_p->data[1];
+ dev_p->sdiocard[bus].function[nFunctionNo-1].maxblocksize = reply_p->data[1];
+ dev_p->sdiocard[bus].function[nFunctionNo-1].card_psn = (uint32_t)(reply_p->data[2])<<16;
+ dev_p->sdiocard[bus].function[nFunctionNo-1].card_psn |=(uint32_t)(reply_p->data[3]);
+ dev_p->sdiocard[bus].function[nFunctionNo-1].csa_bits = (uint8_t)((reply_p->data[4]&0xff00)>>8);
+ dev_p->sdiocard[bus].function[nFunctionNo-1].wakeup_support = (uint8_t)(reply_p->data[4]&0x0001);
+ dev_p->sdiocard[bus].function_init_map |= (1<<nFunctionNo);
+ CyAsSdioClearFunctionSuspended(handle,bus,nFunctionNo);
+
+ }
+ else
+ {
+ if (resp_type == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_FUNCTION ;
+ }
+
+destroy:
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+/*Query individual functions. */
+CyAsReturnStatus_t
+CyAsSdioQueryFunction(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ CyAsSDIOFunc* data_p )
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsReturnStatus_t ret;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ data_p->blocksize = dev_p->sdiocard[bus].function[nFunctionNo-1].blocksize;
+ data_p->card_psn = dev_p->sdiocard[bus].function[nFunctionNo-1].card_psn;
+ data_p->csa_bits = dev_p->sdiocard[bus].function[nFunctionNo-1].csa_bits;
+ data_p->extended_func_code = dev_p->sdiocard[bus].function[nFunctionNo-1].extended_func_code;
+ data_p->function_code = dev_p->sdiocard[bus].function[nFunctionNo-1].function_code;
+ data_p->maxblocksize = dev_p->sdiocard[bus].function[nFunctionNo-1].maxblocksize;
+ data_p->wakeup_support = dev_p->sdiocard[bus].function[nFunctionNo-1].wakeup_support;
+
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+/* Abort the Current Extended IO Operation*/
+CyAsReturnStatus_t
+CyAsSdioAbortFunction(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t resp_type;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ if ((CyAsDeviceIsStorageAsyncPending(dev_p)) || (dev_p->storage_wait))
+ {
+ if(!(CyAsSdioGetCardCapability(handle,bus) & CY_SDIO_SDC ))
+ {
+ return CY_AS_ERROR_INVALID_COMMAND;
+ }
+ }
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_ABORT_IO, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /*Setup mailbox */
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo) ) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ resp_type = CyAsLLRequestResponse_GetCode(reply_p) ;
+
+ if (resp_type == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+
+
+destroy:
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+}
+
+/* Suspend IO to current function*/
+CyAsReturnStatus_t
+CyAsSdioSuspend(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(!(CyAsSdioCheckSupportBusSuspend(handle,bus)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(!(CyAsSdioGetCardCapability(handle,bus) & CY_SDIO_SDC))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if(CyAsSdioCheckFunctionSuspended(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_FUNCTION_SUSPENDED;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_SUSPEND, CY_RQT_GENERAL_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /*Setup mailbox */
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo) ) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ ret = CyAsLLRequestResponse_GetCode(reply_p) ;
+ CyAsSdioSetFunctionSuspended(handle,bus,nFunctionNo);
+ }
+
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*Resume suspended function*/
+CyAsReturnStatus_t
+CyAsSdioResume(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ CyAsOperType op,
+ uint8_t miscBuf,
+ uint16_t pendingblockcount,
+ uint8_t *data_p
+ )
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t resp_data, ret = CY_AS_ERROR_SUCCESS ;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ /* If suspend resume is not supported return */
+ if(!(CyAsSdioCheckSupportBusSuspend(handle,bus)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ /* if the function is not suspended return. */
+ if(!(CyAsSdioCheckFunctionSuspended(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SDIO_RESUME, CY_RQT_STORAGE_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /*Setup mailbox */
+ CyAsLLRequestResponse_SetWord(req_p, 0, CreateAddress(bus, (uint8_t)device, nFunctionNo) ) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 2) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+
+ if ( CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SDIO_RESUME)
+ {
+ resp_data = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if(resp_data & 0x00ff)
+ {
+ /* Send extended read request to resume the read. */
+ if(op == CyAsOpRead)
+ {
+ ret = CyAsSdioExtendedIO(handle,bus,device,nFunctionNo,0,miscBuf,pendingblockcount,CyFalse,data_p,1);
+ }
+ else
+ {
+ ret = CyAsSdioExtendedIO(handle,bus,device,nFunctionNo,0,miscBuf,pendingblockcount,CyTrue,data_p,1);
+ }
+ }
+ else
+ {
+ ret= CY_AS_ERROR_SUCCESS;
+ }
+
+ }
+ else
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+
+destroy:
+ CyAsSdioClearFunctionSuspended(handle,bus,nFunctionNo);
+ if(req_p!=0)
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ if(reply_p!=0)
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+
+}
+
+/*Set function blocksize. Size cannot exceed max block size for the function*/
+CyAsReturnStatus_t
+CyAsSdioSetBlocksize(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo,
+ uint16_t blocksize)
+{
+ CyAsReturnStatus_t ret;
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ ret = CyAsSdioDeviceCheck(dev_p,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_INVALID_FUNCTION;
+ if( nFunctionNo == 0)
+ {
+ if ( blocksize > CyAsSdioGetCardMaxBlocksize(handle,bus))
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+ else if (blocksize == CyAsSdioGetCardBlocksize(handle,bus))
+ return CY_AS_ERROR_SUCCESS;
+ }
+ else
+ {
+ if ( blocksize > CyAsSdioGetFunctionMaxBlocksize(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_INVALID_BLOCKSIZE;
+ else if (blocksize == CyAsSdioGetFunctionBlocksize(handle,bus,nFunctionNo))
+ return CY_AS_ERROR_SUCCESS;
+ }
+
+ ret = CyAsSdioDirectWrite(handle,bus,device,0,(uint16_t)(nFunctionNo<<8)|0x10,0,blocksize&0x00ff,0);
+ if(ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+ ret = CyAsSdioDirectWrite(handle,bus,device,0,(uint16_t)(nFunctionNo<<8)|0x11,0,(blocksize&0xff00)>>8,0);
+ if (ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(nFunctionNo ==0)
+ CyAsSdioSetCardBlockSize(handle,bus,blocksize);
+ else
+ CyAsSdioSetFunctionBlockSize(handle,bus,nFunctionNo,blocksize);
+ return ret;
+}
+
+/* Deinitialize an SDIO function*/
+CyAsReturnStatus_t
+CyAsSdioDeInitFunction(
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ uint8_t nFunctionNo)
+{
+ CyAsReturnStatus_t ret;
+ uint8_t temp;
+
+ if(nFunctionNo == 0)
+ return CY_AS_ERROR_INVALID_FUNCTION;
+
+ ret = CyAsSdioDeviceCheck((CyAsDevice*)handle,bus,device);
+ if( ret != CY_AS_ERROR_SUCCESS )
+ return ret;
+
+ if(!(CyAsSdioCheckFunctionInitialized(handle,bus,nFunctionNo)))
+ return CY_AS_ERROR_SUCCESS;
+
+ temp =(uint8_t)(((CyAsDevice*)handle)->sdiocard[bus].function_init_map & (~(1<<nFunctionNo)));
+ CyAsSdioDirectWrite(handle,bus,device,0,0x02,0,temp,0);
+ ((CyAsDevice*)handle)->sdiocard[bus].function_init_map &= (~(1<<nFunctionNo));
+
+ return CY_AS_ERROR_SUCCESS;
+}
+
+/* This includes the implementation of the deprecated functions for backward
+ * compatibility
+ */
+#include "cyasstorage_dep_impl.h"
+
+/*[]*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasstorage_dep_impl.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,396 @@
+/* Cypress West Bridge API source file (cyasstorage_dep_impl.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/* This c file will contain Antioch specific implementation
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility
+ */
+CyAsReturnStatus_t
+CyAsStorageRegisterCallback_dep(CyAsDeviceHandle handle, CyAsStorageEventCallback_dep callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->storage_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ dev_p->storage_event_cb = callback ;
+ dev_p->storage_event_cb_ms = NULL ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageClaim_dep_EX(CyAsDeviceHandle handle,
+ CyAsMediaType* type,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsReturnStatus_t ret ;
+ CyAsBusNumber_t bus ;
+
+ if (*type == CyAsMediaSDIO)
+ return CY_AS_ERROR_SUCCESS;
+
+ if (*type != CyAsMediaNand && *type != CyAsMediaSDFlash && *type != CyAsMediaMMCFlash && *type != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, *type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return MyStorageClaim(dev_p, type, bus, 0, CY_AS_REQUEST_RESPONSE_EX, cb, client) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageRelease_dep_EX(CyAsDeviceHandle handle,
+ CyAsMediaType* type,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (*type != CyAsMediaNand && *type != CyAsMediaSDFlash && *type != CyAsMediaMMCFlash && *type != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, *type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return MyStorageRelease(dev_p, type, bus, 0, CY_AS_REQUEST_RESPONSE_EX, cb, client) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageQueryDevice_dep_EX(CyAsDeviceHandle handle,
+ CyAsStorageQueryDeviceData_dep* data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, data_p->type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return MyStorageQueryDevice(dev_p, data_p, CY_AS_REQUEST_RESPONSE_EX, bus, data_p->device, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryUnit_dep_EX(CyAsDeviceHandle handle,
+ CyAsStorageQueryUnitData_dep* data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus;
+ CyAsReturnStatus_t ret ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, data_p->type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return MyStorageQueryUnit(dev_p, data_p, CY_AS_REQUEST_RESPONSE_EX, bus,
+ data_p->device, data_p->unit, cb, client) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageRead_dep(CyAsDeviceHandle handle, CyAsMediaType media, uint32_t device, uint32_t unit, uint32_t block,
+ void *data_p, uint16_t num_blocks)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (media != CyAsMediaNand && media != CyAsMediaSDFlash && media != CyAsMediaMMCFlash && media != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageSyncOper(dev_p, dev_p->storage_read_endpoint, CY_RQT_READ_BLOCK, bus, device,
+ unit, block, data_p, num_blocks) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageWrite_dep(CyAsDeviceHandle handle, CyAsMediaType media, uint32_t device, uint32_t unit, uint32_t block,
+ void *data_p, uint16_t num_blocks)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (media != CyAsMediaNand && media != CyAsMediaSDFlash && media != CyAsMediaMMCFlash && media != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageSyncOper(dev_p, dev_p->storage_write_endpoint, CY_RQT_WRITE_BLOCK, bus, device,
+ unit, block, data_p, num_blocks) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageReadAsync_dep(CyAsDeviceHandle handle, CyAsMediaType media, uint32_t device, uint32_t unit,
+ uint32_t block, void *data_p, uint16_t num_blocks, CyAsStorageCallback_dep callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (media != CyAsMediaNand && media != CyAsMediaSDFlash && media != CyAsMediaMMCFlash && media != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ if (callback == 0)
+ return CY_AS_ERROR_NULL_CALLBACK ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageAsyncOper(dev_p, dev_p->storage_read_endpoint, CY_RQT_READ_BLOCK,
+ CY_AS_REQUEST_RESPONSE_EX, bus, device, unit, block, data_p, num_blocks, callback, NULL);
+}
+
+CyAsReturnStatus_t
+CyAsStorageWriteAsync_dep(CyAsDeviceHandle handle, CyAsMediaType media, uint32_t device, uint32_t unit,
+ uint32_t block, void *data_p, uint16_t num_blocks, CyAsStorageCallback_dep callback)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (media != CyAsMediaNand && media != CyAsMediaSDFlash && media != CyAsMediaMMCFlash && media != CyAsMediaCEATA)
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ if (callback == 0)
+ return CY_AS_ERROR_NULL_CALLBACK ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageAsyncOper(dev_p, dev_p->storage_write_endpoint, CY_RQT_WRITE_BLOCK,
+ CY_AS_REQUEST_RESPONSE_EX, bus, device, unit, block, data_p, num_blocks, callback, NULL);
+}
+
+CyAsReturnStatus_t
+CyAsStorageSDRegisterRead_dep_EX(
+ CyAsDeviceHandle handle,
+ CyAsMediaType type,
+ uint8_t device,
+ CyAsSDCardRegType regType,
+ CyAsStorageSDRegReadData *data_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus;
+ CyAsReturnStatus_t ret ;
+
+ if (type != CyAsMediaSDFlash && type != CyAsMediaMMCFlash)
+ return CY_AS_ERROR_INVALID_PARAMETER ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, type, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageSDRegisterRead(handle, bus, device, regType, data_p, cb, client);
+}
+
+
+CyAsReturnStatus_t
+CyAsStorageSDRegisterRead_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType type,
+ uint8_t device,
+ CyAsSDCardRegType regType,
+ uint8_t readLen,
+ uint8_t *data_p)
+{
+ CyAsStorageSDRegReadData info ;
+ CyAsReturnStatus_t ret ;
+
+ info.buf_p = data_p ;
+ info.length = readLen ;
+
+ ret = CyAsStorageSDRegisterRead_dep_EX(handle, type, device, regType, &info, 0, 0) ;
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRelease_dep(CyAsDeviceHandle handle,
+ CyAsMediaType type)
+{
+ CyAsMediaType* t = &type ;
+ return CyAsStorageRelease_dep_EX(handle, t, 0, 0) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryUnit_dep(CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ uint32_t unit,
+ CyAsUnitDesc *desc_p)
+{
+ CyAsReturnStatus_t status ;
+ CyAsStorageQueryUnitData_dep data ;
+ data.device = device ;
+ data.type = media ;
+ data.unit = unit ;
+
+ status = CyAsStorageQueryUnit_dep_EX(handle, &data, 0, 0) ;
+
+ desc_p->block_size = data.desc_p.block_size ;
+ desc_p->start_block = data.desc_p.start_block ;
+ desc_p->type = data.desc_p.type ;
+ desc_p->unit_size = data.desc_p.unit_size ;
+
+ return status ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageQueryDevice_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsDeviceDesc *desc_p)
+{
+ CyAsReturnStatus_t status ;
+ CyAsStorageQueryDeviceData_dep data ;
+ data.device = device ;
+ data.type = media ;
+
+ status = CyAsStorageQueryDevice_dep_EX(handle, &data, 0, 0) ;
+
+ desc_p->block_size = data.desc_p.block_size ;
+ desc_p->number_units = data.desc_p.number_units ;
+ desc_p->removable = data.desc_p.removable ;
+ desc_p->type = data.desc_p.type ;
+ desc_p->writeable = data.desc_p.writeable ;
+ desc_p->locked = data.desc_p.locked ;
+ desc_p->erase_unit_size = data.desc_p.erase_unit_size ;
+
+ return status ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageClaim_dep(CyAsDeviceHandle handle,
+ CyAsMediaType type)
+{
+ CyAsMediaType* t = &type ;
+
+ return CyAsStorageClaim_dep_EX(handle, t, 0, 0) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageDeviceControl_dep(CyAsDeviceHandle handle,
+ CyBool card_detect_en,
+ CyBool write_prot_en,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ return MyStorageDeviceControl(dev_p, CyAsBus_1, 0, card_detect_en, write_prot_en, CyAsStorageDetect_GPIO, cb, client);
+}
+
+CyAsReturnStatus_t
+CyAsStorageCreatePPartition_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ uint32_t size,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsReturnStatus_t ret ;
+ CyAsBusNumber_t bus ;
+
+ if ((media == CyAsMediaSDIO) || (media == CyAsMediaCEATA))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ if ((media != CyAsMediaNand) && (media != CyAsMediaSDFlash) && (media != CyAsMediaMMCFlash))
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageCreatePPartition(handle, bus, device, size, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsStorageRemovePPartition_dep(
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsReturnStatus_t ret ;
+ CyAsBusNumber_t bus ;
+
+ if ((media == CyAsMediaSDIO) || (media == CyAsMediaCEATA))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ if ((media != CyAsMediaNand) && (media != CyAsMediaSDFlash) && (media != CyAsMediaMMCFlash))
+ return CY_AS_ERROR_NO_SUCH_MEDIA ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsStorageRemovePPartition(handle, bus, device, cb, client) ;
+}
+
+/*[]*/
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasusb.c Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,3613 @@
+/* Cypress West Bridge API source file (cyasusb.c)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+#include "cyashal.h"
+#include "cyasusb.h"
+#include "cyaserr.h"
+#include "cyasdma.h"
+#include "cyaslowlevel.h"
+#include "cyaslep2pep.h"
+#include "cyasregs.h"
+#include "cyasstorage.h"
+
+extern CyAsMediaType
+CyAsStorageGetMediaFromAddress(uint16_t v) ;
+
+extern CyAsBusNumber_t
+CyAsStorageGetBusFromAddress(uint16_t v) ;
+
+extern uint32_t
+CyAsStorageGetDeviceFromAddress(uint16_t v) ;
+
+static CyAsReturnStatus_t
+CyAsUsbAckSetupPacket(
+ CyAsDeviceHandle handle, /* Handle to the West Bridge device */
+ CyAsFunctionCallback cb, /* The callback if async call */
+ uint32_t client /* Client supplied data */
+ ) ;
+
+static void
+CyAsUsbFuncCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret) ;
+/*
+* Reset the USB EP0 state
+*/
+static void
+CyAsUsbResetEP0State(CyAsDevice *dev_p)
+{
+ CyAsLogDebugMessage(6, "CyAsUsbResetEP0State called") ;
+
+ CyAsDeviceClearAckDelayed(dev_p) ;
+ CyAsDeviceClearSetupPacket(dev_p) ;
+ if (CyAsDeviceIsUsbAsyncPending(dev_p, 0))
+ CyAsUsbCancelAsync((CyAsDeviceHandle)dev_p, 0) ;
+
+ dev_p->usb_pending_buffer = 0 ;
+}
+
+/*
+* External function to map logical endpoints to physical endpoints
+*/
+static CyAsReturnStatus_t
+IsUsbActive(CyAsDevice *dev_p)
+{
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (dev_p->usb_count == 0)
+ return CY_AS_ERROR_NOT_RUNNING ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+UsbAckCallback(CyAsDeviceHandle h,
+ CyAsReturnStatus_t status,
+ uint32_t client,
+ CyAsFunctCBType type,
+ void* data)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)h ;
+
+ (void)client ;
+ (void)status ;
+ (void)data ;
+
+ CyAsHalAssert(type == CY_FUNCT_CB_NODATA) ;
+
+ if (dev_p->usb_pending_buffer)
+ {
+ CyAsUsbIoCallback cb ;
+
+ cb = dev_p->usb_cb[0] ;
+ dev_p->usb_cb[0] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, 0) ;
+ if (cb)
+ cb(h, 0, dev_p->usb_pending_size, dev_p->usb_pending_buffer, dev_p->usb_error) ;
+
+ dev_p->usb_pending_buffer = 0 ;
+ }
+
+ CyAsDeviceClearSetupPacket(dev_p) ;
+}
+
+static void
+MyUsbRequestCallbackUsbEvent(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ uint16_t ev ;
+ uint16_t val ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+
+ ev = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ switch(ev)
+ {
+ case 0: /* Reserved */
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;
+ break ;
+
+ case 1: /* Reserved */
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;
+ break ;
+
+ case 2: /* USB Suspend */
+ dev_p->usb_last_event = CyAsEventUsbSuspend ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbSuspend, 0) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbSuspend, 0) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ break;
+
+ case 3: /* USB Resume */
+ dev_p->usb_last_event = CyAsEventUsbResume ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbResume, 0) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbResume, 0) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ break ;
+
+ case 4: /* USB Reset */
+ /*
+ * If we get a USB reset, the USB host did not understand our response
+ * or we timed out for some reason. Reset our internal state to be ready for
+ * another set of enumeration based requests.
+ */
+ if (CyAsDeviceIsAckDelayed(dev_p))
+ {
+ CyAsUsbResetEP0State(dev_p) ;
+ }
+
+ dev_p->usb_last_event = CyAsEventUsbReset ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbReset, 0) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbReset, 0) ;
+
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ CyAsDeviceClearUsbHighSpeed(dev_p) ;
+ CyAsUsbSetDmaSizes(dev_p) ;
+ dev_p->usb_max_tx_size = 0x40 ;
+ CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x40) ;
+ break ;
+
+ case 5: /* USB Set Configuration */
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ; /* The configuration to set */
+ dev_p->usb_last_event = CyAsEventUsbSetConfig ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbSetConfig, &val) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbSetConfig, &val) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ break ;
+
+ case 6: /* USB Speed change */
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ; /* Connect speed */
+ dev_p->usb_last_event = CyAsEventUsbSpeedChange ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbSpeedChange, &val) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbSpeedChange, &val) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ CyAsDeviceSetUsbHighSpeed(dev_p) ;
+ CyAsUsbSetDmaSizes(dev_p) ;
+ dev_p->usb_max_tx_size = 0x200 ;
+ CyAsDmaSetMaxDmaSize(dev_p, 0x06, 0x200) ;
+ break ;
+
+ case 7: /* USB Clear Feature */
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ; /* EP Number */
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbClearFeature, &val) ;
+ if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbClearFeature, &val) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ break ;
+
+ default:
+ CyAsHalPrintMessage("Invalid event type\n") ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_USB_INVALID_EVENT, sizeof(ev), &ev) ;
+ break ;
+ }
+}
+
+static void
+MyUsbRequestCallbackUsbData(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ CyAsEndPointNumber_t ep ;
+ uint8_t type ;
+ uint16_t len ;
+ uint16_t val ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ ep = (CyAsEndPointNumber_t)((val >> 13) & 0x01) ;
+ len = (val & 0x1ff) ;
+
+ CyAsHalAssert(len <= 64) ;
+ CyAsLLRequestResponse_Unpack(req_p, 1, len, dev_p->usb_ep_data) ;
+
+ type = (uint8_t)((val >> 14) & 0x03) ;
+ if (type == 0)
+ {
+ if (CyAsDeviceIsAckDelayed(dev_p))
+ {
+ /*
+ * A setup packet has arrived while we are processing a previous setup packet.
+ * Reset our state with respect to EP0 to be ready to process the new packet.
+ */
+ CyAsUsbResetEP0State(dev_p) ;
+ }
+
+ if (len != 8)
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;
+ else
+ {
+ CyAsDeviceClearEp0Stalled(dev_p) ;
+ CyAsDeviceSetSetupPacket(dev_p) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;
+ else
+ dev_p->usb_event_cb(h, CyAsEventUsbSetupPacket, dev_p->usb_ep_data) ;
+
+ if ((!CyAsDeviceIsAckDelayed(dev_p)) && (!CyAsDeviceIsEp0Stalled(dev_p)))
+ {
+ CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;
+ }
+ }
+ }
+ else if (type == 2)
+ {
+ if (len != 0)
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_INVALID_REQUEST, 0) ;
+ else
+ {
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbStatusPacket, 0) ;
+ else
+ dev_p->usb_event_cb(h, CyAsEventUsbStatusPacket, 0) ;
+
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ }
+ }
+ else if (type == 1)
+ {
+ /*
+ * We need to hand the data associated with these endpoints to the DMA
+ * module.
+ */
+ CyAsDmaReceivedData(dev_p, ep, len, dev_p->usb_ep_data) ;
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+ }
+}
+
+static void
+MyUsbRequestCallbackInquiry(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ CyAsUsbInquiryData_dep cbdata ;
+ CyAsUsbInquiryData cbdata_ms ;
+ void *data ;
+ uint16_t val ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+ uint8_t def_inq_data[64] ;
+ uint8_t evpd ;
+ uint8_t codepage ;
+ CyBool updated ;
+ uint16_t length ;
+
+ CyAsBusNumber_t bus ;
+ uint32_t device ;
+ CyAsMediaType media ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ bus = CyAsStorageGetBusFromAddress(val) ;
+ device = CyAsStorageGetDeviceFromAddress(val) ;
+ media = CyAsStorageGetMediaFromAddress(val) ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ evpd = (uint8_t)((val >> 8) & 0x01) ;
+ codepage = (uint8_t)(val & 0xff) ;
+
+ length = CyAsLLRequestResponse_GetWord(req_p, 2) ;
+ data = (void *)def_inq_data ;
+
+ updated = CyFalse ;
+
+ if (dev_p->usb_event_cb_ms)
+ {
+ cbdata_ms.bus = bus ;
+ cbdata_ms.device = device ;
+ cbdata_ms.updated = updated ;
+ cbdata_ms.evpd = evpd ;
+ cbdata_ms.codepage = codepage ;
+ cbdata_ms.length = length ;
+ cbdata_ms.data = data ;
+
+ CyAsHalAssert(cbdata_ms.length <= sizeof(def_inq_data)) ;
+ CyAsLLRequestResponse_Unpack(req_p, 3, cbdata_ms.length, cbdata_ms.data) ;
+
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryBefore, &cbdata_ms) ;
+
+ updated = cbdata_ms.updated;
+ data = cbdata_ms.data ;
+ length = cbdata_ms.length ;
+ }
+ else if (dev_p->usb_event_cb)
+ {
+ cbdata.media = media ;
+ cbdata.updated = updated ;
+ cbdata.evpd = evpd ;
+ cbdata.codepage = codepage ;
+ cbdata.length = length ;
+ cbdata.data = data ;
+
+ CyAsHalAssert(cbdata.length <= sizeof(def_inq_data)) ;
+ CyAsLLRequestResponse_Unpack(req_p, 3, cbdata.length, cbdata.data) ;
+
+ dev_p->usb_event_cb(h, CyAsEventUsbInquiryBefore, &cbdata) ;
+
+ updated = cbdata.updated ;
+ data = cbdata.data ;
+ length = cbdata.length ;
+ }
+
+ if (updated && length > 192)
+ CyAsHalPrintMessage("An inquiry result from a CyAsEventUsbInquiryBefore event was greater than 192 bytes.") ;
+
+ /* Now send the reply with the data back to the West Bridge device */
+ if (updated && length <= 192)
+ {
+ /*
+ * The callback function modified the inquiry data, ship the data back
+ * to the West Bridge firmware.
+ */
+ CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_INQUIRY_DATA, length, data) ;
+ }
+ else
+ {
+ /*
+ * The callback did not modify the data, just acknowledge that we
+ * processed the request
+ */
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;
+ }
+
+ if (dev_p->usb_event_cb_ms)
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbInquiryAfter, &cbdata_ms) ;
+ else if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbInquiryAfter, &cbdata) ;
+}
+
+static void
+MyUsbRequestCallbackStartStop(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ CyAsBusNumber_t bus ;
+ CyAsMediaType media ;
+ uint32_t device ;
+ uint16_t val ;
+
+ if (dev_p->usb_event_cb_ms || dev_p->usb_event_cb)
+ {
+ CyBool loej ;
+ CyBool start ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ bus = CyAsStorageGetBusFromAddress(val) ;
+ device = CyAsStorageGetDeviceFromAddress(val) ;
+ media = CyAsStorageGetMediaFromAddress(val) ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ loej = (val & 0x02) ? CyTrue : CyFalse ;
+ start = (val & 0x01) ? CyTrue: CyFalse ;
+
+ if (dev_p->usb_event_cb_ms)
+ {
+ CyAsUsbStartStopData cbdata_ms ;
+
+ cbdata_ms.bus = bus ;
+ cbdata_ms.device = device ;
+ cbdata_ms.loej = loej ;
+ cbdata_ms.start = start ;
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbStartStop, &cbdata_ms) ;
+ }
+ else if (dev_p->usb_event_cb)
+ {
+ CyAsUsbStartStopData_dep cbdata ;
+
+ cbdata.media = media ;
+ cbdata.loej = loej ;
+ cbdata.start = start ;
+ dev_p->usb_event_cb(h, CyAsEventUsbStartStop, &cbdata) ;
+ }
+ }
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 1) ;
+}
+
+static void
+MyUsbRequestCallbackUknownCBW(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ uint16_t val ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+ uint8_t buf[16] ;
+
+ uint8_t response[4] ;
+ uint16_t reqlen ;
+ void *request ;
+ uint8_t status ;
+ uint8_t key ;
+ uint8_t asc ;
+ uint8_t ascq ;
+
+ val = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ status = 1 ; /* Failed by default */
+ key = 0x05 ; /* Invalid command */
+ asc = 0x20 ; /* Invalid command */
+ ascq = 0x00 ; /* Invalid command */
+ reqlen = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ request = buf ;
+
+ CyAsHalAssert(reqlen <= sizeof(buf)) ;
+ CyAsLLRequestResponse_Unpack(req_p, 2, reqlen, request) ;
+
+ if (dev_p->usb_event_cb_ms)
+ {
+ CyAsUsbUnknownCommandData cbdata_ms ;
+ cbdata_ms.bus = CyAsStorageGetBusFromAddress(val) ;
+ cbdata_ms.device = CyAsStorageGetDeviceFromAddress(val) ;
+ cbdata_ms.reqlen = reqlen ;
+ cbdata_ms.request = request ;
+ cbdata_ms.status = status ;
+ cbdata_ms.key = key ;
+ cbdata_ms.asc = asc ;
+ cbdata_ms.ascq = ascq ;
+
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbUnknownStorage, &cbdata_ms) ;
+ status = cbdata_ms.status ;
+ key = cbdata_ms.key ;
+ asc = cbdata_ms.asc ;
+ ascq = cbdata_ms.ascq ;
+ }
+ else if (dev_p->usb_event_cb)
+ {
+ CyAsUsbUnknownCommandData_dep cbdata ;
+ cbdata.media = CyAsStorageGetMediaFromAddress(val) ;
+ cbdata.reqlen = reqlen ;
+ cbdata.request = request ;
+ cbdata.status = status ;
+ cbdata.key = key ;
+ cbdata.asc = asc ;
+ cbdata.ascq = ascq ;
+
+ dev_p->usb_event_cb(h, CyAsEventUsbUnknownStorage, &cbdata) ;
+ status = cbdata.status ;
+ key = cbdata.key ;
+ asc = cbdata.asc ;
+ ascq = cbdata.ascq ;
+ }
+
+ response[0] = status ;
+ response[1] = key ;
+ response[2] = asc ;
+ response[3] = ascq ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_UNKNOWN_SCSI_COMMAND, sizeof(response), response) ;
+}
+
+static void
+MyUsbRequestCallbackMSCProgress(CyAsDevice *dev_p, CyAsLLRequestResponse *req_p)
+{
+ uint16_t val1, val2 ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+
+ if ((dev_p->usb_event_cb) || (dev_p->usb_event_cb_ms))
+ {
+ CyAsMSCProgressData cbdata ;
+
+ val1 = CyAsLLRequestResponse_GetWord(req_p, 0) ;
+ val2 = CyAsLLRequestResponse_GetWord(req_p, 1) ;
+ cbdata.wr_count = (uint32_t)((val1 << 16) | val2) ;
+
+ val1 = CyAsLLRequestResponse_GetWord(req_p, 2) ;
+ val2 = CyAsLLRequestResponse_GetWord(req_p, 3) ;
+ cbdata.rd_count = (uint32_t)((val1 << 16) | val2) ;
+
+ if (dev_p->usb_event_cb)
+ dev_p->usb_event_cb(h, CyAsEventUsbMSCProgress, &cbdata) ;
+ else
+ dev_p->usb_event_cb_ms(h, CyAsEventUsbMSCProgress, &cbdata) ;
+ }
+
+ CyAsLLSendStatusResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_AS_ERROR_SUCCESS, 0) ;
+}
+
+/*
+* This function processes the requests delivered from the firmware within the West Bridge
+* device that are delivered in the USB context. These requests generally are EP0 and
+* EP1 related requests or USB events.
+*/
+static void
+MyUsbRequestCallback(CyAsDevice *dev_p, uint8_t context, CyAsLLRequestResponse *req_p, CyAsLLRequestResponse *resp_p,
+ CyAsReturnStatus_t ret)
+{
+ uint16_t val ;
+ uint8_t code = CyAsLLRequestResponse_GetCode(req_p) ;
+
+ (void)resp_p ;
+ (void)context ;
+ (void)ret ;
+
+ switch(code)
+ {
+ case CY_RQT_USB_EVENT:
+ MyUsbRequestCallbackUsbEvent(dev_p, req_p) ;
+ break ;
+
+ case CY_RQT_USB_EP_DATA:
+ dev_p->usb_last_event = CyAsEventUsbSetupPacket ;
+ MyUsbRequestCallbackUsbData(dev_p, req_p) ;
+ break ;
+
+ case CY_RQT_SCSI_INQUIRY_COMMAND:
+ dev_p->usb_last_event = CyAsEventUsbInquiryAfter ;
+ MyUsbRequestCallbackInquiry(dev_p, req_p) ;
+ break ;
+
+ case CY_RQT_SCSI_START_STOP_COMMAND:
+ dev_p->usb_last_event = CyAsEventUsbStartStop ;
+ MyUsbRequestCallbackStartStop(dev_p, req_p) ;
+ break ;
+
+ case CY_RQT_SCSI_UNKNOWN_COMMAND:
+ dev_p->usb_last_event = CyAsEventUsbUnknownStorage ;
+ MyUsbRequestCallbackUknownCBW(dev_p, req_p) ;
+ break ;
+
+ case CY_RQT_USB_ACTIVITY_UPDATE:
+ dev_p->usb_last_event = CyAsEventUsbMSCProgress ;
+ MyUsbRequestCallbackMSCProgress(dev_p, req_p) ;
+ break ;
+
+ default:
+ CyAsHalPrintMessage("Invalid request received on USB context\n") ;
+ val = req_p->box0 ;
+ CyAsLLSendDataResponse(dev_p, CY_RQT_USB_RQT_CONTEXT, CY_RESP_INVALID_REQUEST, sizeof(val), &val) ;
+ break ;
+ }
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseUsbStart(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /*
+ * Mark EP 0 and EP1 as 64 byte endpoints
+ */
+ CyAsDmaSetMaxDmaSize(dev_p, 0, 64) ;
+ CyAsDmaSetMaxDmaSize(dev_p, 1, 64) ;
+
+ dev_p->usb_count++ ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, 0) ;
+ }
+
+ CyAsDeviceClearUSSPending(dev_p) ;
+
+ return ret ;
+
+}
+
+/*
+* This function starts the USB stack. The stack is reference counted so if the stack is already
+* started, this function just increments the count. If the stack has not been started, a start
+* request is sent to the West Bridge device.
+*
+* Note: Starting the USB stack does not cause the USB signals to be connected to the USB pins. To do
+* this and therefore initiate enumeration, CyAsUsbConnect() must be called.
+*/
+CyAsReturnStatus_t
+CyAsUsbStart(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p, *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbStart called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if(CyAsDeviceIsUSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ CyAsDeviceSetUSSPending(dev_p) ;
+
+ if (dev_p->usb_count == 0)
+ {
+ /*
+ * Since we are just starting the stack, mark USB as not connected to the
+ * remote host
+ */
+ CyAsDeviceClearUsbConnected(dev_p) ;
+ dev_p->usb_phy_config = 0 ;
+
+ /* Queue for 1.0 Async Requests, kept for backwards compatibility */
+ dev_p->usb_func_cbs = CyAsCreateCBQueue(CYAS_USB_FUNC_CB) ;
+ if(dev_p->usb_func_cbs == 0)
+ {
+ CyAsDeviceClearUSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reset the EP0 state */
+ CyAsUsbResetEP0State(dev_p) ;
+
+ /*
+ * We register here becuase the start request may cause events to occur before the
+ * response to the start request.
+ */
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, MyUsbRequestCallback) ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_START_USB, CY_RQT_USB_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;
+ dev_p->usb_func_cbs = 0 ;
+ CyAsDeviceClearUSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;
+ dev_p->usb_func_cbs = 0 ;
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsDeviceClearUSSPending(dev_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseUsbStart(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_START,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else
+ {
+ dev_p->usb_count++ ;
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_USB_START, 0) ;
+ }
+
+ CyAsDeviceClearUSSPending(dev_p) ;
+
+ return ret ;
+}
+
+void
+CyAsUsbReset(CyAsDevice *dev_p)
+{
+ int i ;
+
+ CyAsDeviceClearUsbConnected(dev_p) ;
+
+ for(i = 0 ; i < sizeof(dev_p->usb_config)/sizeof(dev_p->usb_config[0]) ; i++)
+ {
+ /*
+ * Cancel all pending USB read/write operations, as it is possible
+ * that the USB stack comes up in a different configuration with a
+ * different set of endpoints.
+ */
+ if (CyAsDeviceIsUsbAsyncPending(dev_p, i))
+ CyAsUsbCancelAsync(dev_p, (CyAsEndPointNumber_t)i) ;
+
+ dev_p->usb_cb[i] = 0 ;
+ dev_p->usb_config[i].enabled = CyFalse ;
+ }
+
+ dev_p->usb_phy_config = 0 ;
+}
+
+/*
+ * This function does all the API side clean-up associated with CyAsUsbStop,
+ * without any communication with firmware. This needs to be done when the
+ * device is being reset while the USB stack is active.
+ */
+void
+CyAsUsbCleanup(CyAsDevice *dev_p)
+{
+ if (dev_p->usb_count)
+ {
+ CyAsUsbResetEP0State(dev_p) ;
+ CyAsUsbReset(dev_p) ;
+ CyAsHalMemSet(dev_p->usb_config, 0, sizeof(dev_p->usb_config)) ;
+ CyAsDestroyCBQueue(dev_p->usb_func_cbs) ;
+
+ dev_p->usb_count = 0 ;
+ }
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseUsbStop(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /*
+ * We sucessfully shutdown the stack, so decrement to make the count
+ * zero.
+ */
+ CyAsUsbCleanup(dev_p) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsLLRegisterRequestCallback(dev_p, CY_RQT_USB_RQT_CONTEXT, 0) ;
+
+ CyAsDeviceClearUSSPending(dev_p) ;
+
+ return ret ;
+}
+
+/*
+* This function stops the USB stack. The USB stack is reference counted so first is reference count is
+* decremented. If the reference count is then zero, a request is sent to the West Bridge device to stop the USB
+* stack on the West Bridge device.
+*/
+CyAsReturnStatus_t
+CyAsUsbStop(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p = 0, *reply_p = 0 ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbStop called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if(CyAsDeviceIsUSSPending(dev_p))
+ return CY_AS_ERROR_STARTSTOP_PENDING ;
+
+ CyAsDeviceSetUSSPending(dev_p) ;
+
+ if (dev_p->usb_count == 1)
+ {
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_STOP_USB, CY_RQT_USB_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseUsbStop(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_STOP,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+ else if (dev_p->usb_count > 1)
+ {
+ /*
+ * Reset all LEPs to inactive state, after cleaning up any
+ * pending async read/write calls.
+ */
+ CyAsUsbReset(dev_p) ;
+ dev_p->usb_count-- ;
+
+ if (cb)
+ cb(handle, ret, client, CY_FUNCT_CB_USB_STOP, 0) ;
+ }
+
+ CyAsDeviceClearUSSPending(dev_p) ;
+
+ return ret ;
+}
+
+/*
+* This function registers a callback to be called when USB events are processed
+*/
+CyAsReturnStatus_t
+CyAsUsbRegisterCallback(CyAsDeviceHandle handle, CyAsUsbEventCallback callback)
+{
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbRegisterCallback called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ dev_p->usb_event_cb = NULL ;
+ dev_p->usb_event_cb_ms = callback ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+
+static CyAsReturnStatus_t
+MyHandleResponseNoData(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseConnect(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ CyAsDeviceSetUsbConnected(dev_p) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+
+/*
+* This method asks the West Bridge device to connect the internal USB D+ and D- signals to the USB
+* pins, thus starting the enumeration processes if the external pins are connnected to a USB host.
+* If the external pins are not connect to a USB host, enumeration will begin as soon as the USB
+* pins are connected to a host.
+*/
+CyAsReturnStatus_t
+CyAsUsbConnect(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbConnect called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* 1 = Connect request */
+ CyAsLLRequestResponse_SetWord(req_p, 0, 1) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseConnect(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_CONNECT,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseDisconnect(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsReturnStatus_t ret)
+{
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ CyAsDeviceClearUsbConnected(dev_p) ;
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+/*
+* This method forces a disconnect of the D+ and D- pins external to the West Bridge device from the
+* D+ and D- signals internally, effectively disconnecting the West Bridge device from any connectec
+* USB host.
+*/
+CyAsReturnStatus_t
+CyAsUsbDisconnect(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbDisconnect called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if (!CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_NOT_CONNECTED ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_CONNECT_STATE, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, 0) ;
+
+ /* Reserve space for the reply, the reply data will not exceed two bytes */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseDisconnect(dev_p, req_p, reply_p, ret) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_DISCONNECT,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseSetEnumConfig(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ /*
+ * We configured the West Bridge device and enumeration is going to happen
+ * on the P port processor. Now we must enable endpoint zero
+ */
+ CyAsUsbEndPointConfig config ;
+
+ config.dir = CyAsUsbInOut ;
+ config.type = CyAsUsbControl ;
+ config.enabled = CyTrue ;
+
+ ret = CyAsUsbSetEndPointConfig((CyAsDeviceHandle*)dev_p, 0, &config) ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+* This method sets how the USB is enumerated and should be called before the
+* CyAsUsbConnect() is called.
+*/
+static CyAsReturnStatus_t
+MyUsbSetEnumConfig(CyAsDevice *dev_p,
+ uint8_t bus_mask,
+ uint8_t media_mask,
+ CyBool use_antioch_enumeration,
+ uint8_t mass_storage_interface,
+ uint8_t mtp_interface,
+ CyBool mass_storage_callbacks,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbSetEnumConfig called") ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* if we are using MTP firmware: */
+ if (dev_p->is_mtp_firmware == 1)
+ {
+ if (mass_storage_interface != 0) /* we can not enemurate MSC */
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (bus_mask == 0)
+ {
+ if (mtp_interface != 0)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+ }
+ else if (bus_mask == 2)
+ {
+ /* enable EP 1 as it will be used */
+ CyAsDmaEnableEndPoint(dev_p, 1, CyTrue, CyAsDirectionIn) ;
+ dev_p->usb_config[1].enabled = CyTrue ;
+ dev_p->usb_config[1].dir = CyAsUsbIn ;
+ dev_p->usb_config[1].type = CyAsUsbInt ;
+ }
+ else
+ {
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+ }
+ }
+ else if (mtp_interface != 0) /* if we are not using MTP firmware, we can not enumerate MTP */
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ /*
+ * If we are not enumerating mass storage, we should not be providing an interface
+ * number.
+ */
+ if (bus_mask == 0 && mass_storage_interface != 0)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ /*
+ * If we are going to use mtp_interface, bus mask must be 2.
+ */
+ if (mtp_interface != 0 && bus_mask != 2)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 4) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Marshal the structure */
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((media_mask << 8) | bus_mask)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)use_antioch_enumeration) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, dev_p->is_mtp_firmware ? mtp_interface : mass_storage_interface) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)mass_storage_callbacks) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseSetEnumConfig(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_SETENUMCONFIG,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+ * This method sets how the USB is enumerated and should be called before the
+ * CyAsUsbConnect() is called.
+ */
+CyAsReturnStatus_t
+CyAsUsbSetEnumConfig(CyAsDeviceHandle handle,
+ CyAsUsbEnumControl *config_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ uint8_t bus_mask, media_mask ;
+ uint32_t bus, device ;
+ CyAsReturnStatus_t ret ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if ((CyAsDeviceIsInCallback(dev_p)) && (cb != 0))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Since we are mapping the media types to bus with NAND to 0 and the rest
+ * to 1, and we are only allowing for enumerating all the devices on a bus
+ * we just scan the array for any positions where there a device is enabled
+ * and mark the bus to be enumerated.
+ */
+ bus_mask = 0 ;
+ media_mask = 0 ;
+ media_mask = 0 ;
+ for( bus = 0; bus < CY_AS_MAX_BUSES; bus++)
+ {
+ for( device = 0; device < CY_AS_MAX_STORAGE_DEVICES; device++)
+ {
+ if (config_p->devices_to_enumerate[bus][device] == CyTrue)
+ {
+ bus_mask |= (0x01 << bus) ;
+ media_mask |= dev_p->media_supported[bus] ;
+ media_mask |= dev_p->media_supported[bus] ;
+ }
+ }
+ }
+
+ return MyUsbSetEnumConfig(dev_p, bus_mask,media_mask,
+ config_p->antioch_enumeration,
+ config_p->mass_storage_interface,
+ config_p->mtp_interface,
+ config_p->mass_storage_callbacks,
+ cb,
+ client
+ ) ;
+}
+
+
+static CyAsReturnStatus_t
+MyHandleResponseGetEnumConfig(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ void* config_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t val ;
+ uint8_t bus_mask ;
+ uint32_t bus ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_USB_CONFIG)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ /* Marshal the reply */
+ if (req_p->flags & CY_AS_REQUEST_RESPONSE_MS)
+ {
+ uint32_t device ;
+ CyBool state;
+ CyAsUsbEnumControl *ms_config_p = (CyAsUsbEnumControl*)config_p;
+
+ bus_mask = (uint8_t)(CyAsLLRequestResponse_GetWord(reply_p, 0) & 0xFF) ;
+ for( bus = 0; bus < CY_AS_MAX_BUSES; bus++)
+ {
+ if (bus_mask & (1 << bus))
+ state = CyTrue ;
+ else
+ state = CyFalse ;
+
+ for( device = 0; device < CY_AS_MAX_STORAGE_DEVICES; device++)
+ {
+ ms_config_p->devices_to_enumerate[bus][device] = state ;
+ }
+ }
+
+ ms_config_p->antioch_enumeration = (CyBool)CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+
+ val = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ if (dev_p->is_mtp_firmware)
+ {
+ ms_config_p->mass_storage_interface = 0 ;
+ ms_config_p->mtp_interface = (uint8_t)(val & 0xFF) ;
+ }
+ else
+ {
+ ms_config_p->mass_storage_interface = (uint8_t)(val & 0xFF) ;
+ ms_config_p->mtp_interface = 0 ;
+ }
+ ms_config_p->mass_storage_callbacks = (CyBool)(val >> 8) ;
+
+ /*
+ * Firmware returns an invalid interface number for mass storage,
+ * if mass storage is not enabled. This needs to be converted to zero
+ * to match the input configuration.
+ */
+ if (bus_mask == 0)
+ {
+ if (dev_p->is_mtp_firmware)
+ ms_config_p->mtp_interface = 0 ;
+ else
+ ms_config_p->mass_storage_interface = 0 ;
+ }
+ }
+ else
+ {
+ CyAsUsbEnumControl_dep *ex_config_p = (CyAsUsbEnumControl_dep*)config_p;
+
+ ex_config_p->enum_mass_storage = (uint8_t)((CyAsLLRequestResponse_GetWord(reply_p, 0) >> 8) & 0xFF) ;
+ ex_config_p->antioch_enumeration = (CyBool)CyAsLLRequestResponse_GetWord(reply_p, 1) ;
+
+ val = CyAsLLRequestResponse_GetWord(reply_p, 2) ;
+ ex_config_p->mass_storage_interface = (uint8_t)(val & 0xFF) ;
+ ex_config_p->mass_storage_callbacks = (CyBool)(val >> 8) ;
+
+ /*
+ * Firmware returns an invalid interface number for mass storage,
+ * if mass storage is not enabled. This needs to be converted to zero
+ * to match the input configuration.
+ */
+ if (ex_config_p->enum_mass_storage == 0)
+ ex_config_p->mass_storage_interface = 0 ;
+ }
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+* This sets up the request for the enumerateion configuration information, based on if the request is from
+* the old pre-1.2 functions.
+*/
+static CyAsReturnStatus_t
+MyUsbGetEnumConfig(CyAsDeviceHandle handle,
+ uint16_t req_flags,
+ void* config_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbGetEnumConfig called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_GET_USB_CONFIG, CY_RQT_USB_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Reserve space for the reply, the reply data will not exceed two bytes */
+ reply_p = CyAsLLCreateResponse(dev_p, 3) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ /* we need to know the type of request to know how to manage the data */
+ req_p->flags |= req_flags;
+ return MyHandleResponseGetEnumConfig(dev_p, req_p, reply_p, config_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_GETENUMCONFIG,
+ config_p, dev_p->func_cbs_usb, req_flags, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+ * This method returns the enumerateion configuration information from the West Bridge device.
+ * Generally this is not used by client software but is provided mostly for debug information.
+ * We want a method to read all state information from the device.
+ */
+CyAsReturnStatus_t
+CyAsUsbGetEnumConfig(CyAsDeviceHandle handle,
+ CyAsUsbEnumControl *config_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ return MyUsbGetEnumConfig(handle, CY_AS_REQUEST_RESPONSE_MS, config_p, cb, client);
+}
+
+
+/*
+* This method sets the USB descriptor for a given entity.
+*/
+CyAsReturnStatus_t
+CyAsUsbSetDescriptor(CyAsDeviceHandle handle,
+ CyAsUsbDescType type,
+ uint8_t index,
+ void *desc_p,
+ uint16_t length,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint16_t pktlen ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbSetDescriptor called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if (length > CY_AS_MAX_USB_DESCRIPTOR_SIZE)
+ return CY_AS_ERROR_INVALID_DESCRIPTOR ;
+
+ pktlen = (uint16_t)length / 2 ;
+ if (length % 2)
+ pktlen++ ;
+ pktlen += 2 ; /* 1 for type, 1 for length */
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_DESCRIPTOR, CY_RQT_USB_RQT_CONTEXT, (uint16_t)pktlen) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((uint8_t)type | (index << 8))) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)length) ;
+ CyAsLLRequestResponse_Pack(req_p, 2, length, desc_p) ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_SETDESCRIPTOR,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+ * This method clears all descriptors that were previously stored on the West Bridge
+ * through CyAsUsbSetDescriptor calls.
+ */
+CyAsReturnStatus_t
+CyAsUsbClearDescriptors(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbClearDescriptors called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if ((CyAsDeviceIsInCallback(dev_p)) && (cb == 0))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CLEAR_DESCRIPTORS, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_CLEARDESCRIPTORS,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseGetDescriptor(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyAsGetDescriptorData* data)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint32_t retlen ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ goto destroy ;
+ }
+ else if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_USB_DESCRIPTOR)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ retlen = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ if (retlen > data->length)
+ {
+ ret = CY_AS_ERROR_INVALID_SIZE ;
+ goto destroy ;
+ }
+
+ ret = CY_AS_ERROR_SUCCESS ;
+ CyAsLLRequestResponse_Unpack(reply_p, 1, retlen, data->desc_p) ;
+
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+/*
+* This method retreives the USB descriptor for a given type.
+*/
+CyAsReturnStatus_t
+CyAsUsbGetDescriptor(CyAsDeviceHandle handle,
+ CyAsUsbDescType type,
+ uint8_t index,
+ CyAsGetDescriptorData* data,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbGetDescriptor called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_GET_DESCRIPTOR, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((uint8_t)type | (index << 8))) ;
+
+ /* Add one for the length field */
+ reply_p = CyAsLLCreateResponse(dev_p, CY_AS_MAX_USB_DESCRIPTOR_SIZE + 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return MyHandleResponseGetDescriptor(dev_p, req_p, reply_p, data) ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_GETDESCRIPTOR,
+ data, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetPhysicalConfiguration(CyAsDeviceHandle handle, uint8_t config)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbSetPhysicalConfiguration called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ if (config < 1 || config > 12)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ dev_p->usb_phy_config = config ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static CyBool
+IsPhysicalValid(uint8_t config, CyAsEndPointNumber_t ep)
+{
+ static uint8_t validmask[12] =
+ {
+ 0x0f, /* Config 1 - 1, 2, 3, 4 */
+ 0x07, /* Config 2 - 1, 2, 3 */
+ 0x07, /* Config 3 - 1, 2, 3 */
+ 0x0d, /* Config 4 - 1, 3, 4 */
+ 0x05, /* Config 5 - 1, 3 */
+ 0x05, /* Config 6 - 1, 3 */
+ 0x0d, /* Config 7 - 1, 3, 4 */
+ 0x05, /* Config 8 - 1, 3 */
+ 0x05, /* Config 9 - 1, 3 */
+ 0x0d, /* Config 10 - 1, 3, 4 */
+ 0x09, /* Config 11 - 1, 4 */
+ 0x01 /* Config 12 - 1 */
+ } ;
+
+ return (validmask[config - 1] & (1 << (ep - 1))) ? CyTrue : CyFalse ;
+}
+
+/*
+* This method sets the configuration for an endpoint
+*/
+CyAsReturnStatus_t
+CyAsUsbSetEndPointConfig(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbEndPointConfig *config_p)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbSetEndPointConfig called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ if (ep == 0)
+ {
+ /* Endpoint 0 must be 64 byte, dir IN/OUT, and control type */
+ if (config_p->dir != CyAsUsbInOut || config_p->type != CyAsUsbControl)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+ }
+ else if (ep == 1)
+ {
+ if ((dev_p->is_mtp_firmware == 1) && (dev_p->usb_config[1].enabled == CyTrue))
+ {
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+ }
+
+ /*
+ * EP1 can only be used either as an OUT ep, or as an IN ep.
+ */
+ if ((config_p->type == CyAsUsbControl) || (config_p->type == CyAsUsbIso) || (config_p->dir == CyAsUsbInOut))
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+ }
+ else
+ {
+ if (config_p->dir == CyAsUsbInOut || config_p->type == CyAsUsbControl)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (!IsPhysicalValid(dev_p->usb_phy_config, config_p->physical))
+ return CY_AS_ERROR_INVALID_PHYSICAL_ENDPOINT ;
+
+ /*
+ * ISO endpoints must be on EPs 3, 5, 7 or 9 as they need to align directly
+ * with the underlying physical endpoint.
+ */
+ if (config_p->type == CyAsUsbIso)
+ {
+ if (ep != 3 && ep != 5 && ep != 7 && ep != 9)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (ep == 3 && config_p->physical != 1)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (ep == 5 && config_p->physical != 2)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (ep == 7 && config_p->physical != 3)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+
+ if (ep == 9 && config_p->physical != 4)
+ return CY_AS_ERROR_INVALID_CONFIGURATION ;
+ }
+ }
+
+ /* Store the configuration information until a CyAsUsbCommitConfig is done */
+ dev_p->usb_config[ep] = *config_p ;
+
+ /* If the endpoint is enabled, enable DMA associated with the endpoint */
+ /*
+ * We make some assumptions that we check here. We assume that the direction fields for the
+ * DMA module are the same values as the direction values for the USB module. At some point these should
+ * be consolidated into a single enumerated type. - BWG
+ */
+ CyAsHalAssert((int)CyAsUsbIn == (int)CyAsDirectionIn);
+ CyAsHalAssert((int)CyAsUsbOut == (int)CyAsDirectionOut);
+ CyAsHalAssert((int)CyAsUsbInOut == (int)CyAsDirectionInOut) ;
+
+ return CyAsDmaEnableEndPoint(dev_p, ep, config_p->enabled, (CyAsDmaDirection)config_p->dir) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbGetEndPointConfig(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbEndPointConfig *config_p)
+{
+ CyAsReturnStatus_t ret ;
+
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbGetEndPointConfig called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (ep >= 16 || ep == 2 || ep == 4 || ep == 6 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ *config_p = dev_p->usb_config[ep] ;
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* Commit the configuration of the various endpoints to the hardware.
+*/
+CyAsReturnStatus_t
+CyAsUsbCommitConfig(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ uint32_t i ;
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ CyAsDevice*dev_p ;
+ uint16_t data ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbCommitConfig called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsUsbConnected(dev_p))
+ return CY_AS_ERROR_USB_CONNECTED ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /*
+ * This performs the mapping based on informatation that was previously
+ * stored on the device about the various endpoints and how they are configured. The
+ * output of this mapping is setting the the 14 register values contained in usb_lepcfg
+ * and usb_pepcfg
+ */
+ ret = CyAsUsbMapLogical2Physical(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /*
+ * Now, package the information about the various logical and physical
+ * endpoint configuration registers and send it across to the West Bridge
+ * device.
+ */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_SET_USB_CONFIG_REGISTERS, CY_RQT_USB_RQT_CONTEXT, 8) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsHalPrintMessage("USB Configuration: %d\n", dev_p->usb_phy_config) ;
+ CyAsHalPrintMessage("EP1OUT: 0x%02x EP1IN: 0x%02x\n", dev_p->usb_ep1cfg[0], dev_p->usb_ep1cfg[1]) ;
+ CyAsHalPrintMessage("PEP Registers: 0x%02x 0x%02x 0x%02x 0x%02x\n", dev_p->usb_pepcfg[0],
+ dev_p->usb_pepcfg[1], dev_p->usb_pepcfg[2], dev_p->usb_pepcfg[3]) ;
+
+ CyAsHalPrintMessage("LEP Registers: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
+ dev_p->usb_lepcfg[0],dev_p->usb_lepcfg[1], dev_p->usb_lepcfg[2], dev_p->usb_lepcfg[3],
+ dev_p->usb_lepcfg[4],dev_p->usb_lepcfg[5], dev_p->usb_lepcfg[6], dev_p->usb_lepcfg[7],
+ dev_p->usb_lepcfg[8],dev_p->usb_lepcfg[9]) ;
+
+ /* Write the EP1OUTCFG and EP1INCFG data in the first word. */
+ data = (uint16_t)((dev_p->usb_ep1cfg[0] << 8) | dev_p->usb_ep1cfg[1]) ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, data) ;
+
+ /* Write the PEP CFG data in the next 2 words */
+ for(i = 0 ; i < 4 ; i += 2)
+ {
+ data = (uint16_t)((dev_p->usb_pepcfg[i] << 8) | dev_p->usb_pepcfg[i + 1]) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1 + i / 2, data) ;
+ }
+
+ /* Write the LEP CFG data in the next 5 words */
+ for(i = 0 ; i < 10 ; i += 2)
+ {
+ data = (uint16_t)((dev_p->usb_lepcfg[i] << 8) | dev_p->usb_lepcfg[i + 1]) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3 + i / 2, data) ;
+ }
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ ret = MyHandleResponseNoData(dev_p, req_p, reply_p) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ ret = CyAsUsbSetupDma(dev_p) ;
+
+ return ret ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_COMMITCONFIG,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static void
+SyncRequestCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ (void)ep ;
+ (void)buf_p ;
+
+ dev_p->usb_error = err ;
+ dev_p->usb_actual_cnt = size ;
+}
+
+static void
+AsyncReadRequestCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ CyAsDeviceHandle h ;
+
+ CyAsLogDebugMessage(6, "AsyncReadRequestCallback called") ;
+
+ h = (CyAsDeviceHandle)dev_p ;
+
+ if (ep == 0 && CyAsDeviceIsAckDelayed(dev_p))
+ {
+ dev_p->usb_pending_buffer = buf_p ;
+ dev_p->usb_pending_size = size ;
+ dev_p->usb_error = err ;
+ CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;
+ }
+ else
+ {
+ CyAsUsbIoCallback cb ;
+
+ cb = dev_p->usb_cb[ep] ;
+ dev_p->usb_cb[ep] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, ep) ;
+ if (cb)
+ cb(h, ep, size, buf_p, err) ;
+ }
+}
+
+static void
+AsyncWriteRequestCallback(CyAsDevice *dev_p, CyAsEndPointNumber_t ep, void *buf_p, uint32_t size, CyAsReturnStatus_t err)
+{
+ CyAsDeviceHandle h ;
+
+ CyAsLogDebugMessage(6, "AsyncWriteRequestCallback called") ;
+
+ h = (CyAsDeviceHandle)dev_p ;
+
+ if (ep == 0 && CyAsDeviceIsAckDelayed(dev_p))
+ {
+ dev_p->usb_pending_buffer = buf_p ;
+ dev_p->usb_pending_size = size ;
+ dev_p->usb_error = err ;
+
+ /* The west bridge protocol generates ZLPs as required. */
+ CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;
+ }
+ else
+ {
+ CyAsUsbIoCallback cb ;
+
+ cb = dev_p->usb_cb[ep] ;
+ dev_p->usb_cb[ep] = 0 ;
+
+ CyAsDeviceClearUsbAsyncPending(dev_p, ep) ;
+ if (cb)
+ cb(h, ep, size, buf_p, err) ;
+ }
+}
+
+static void
+MyTurboRqtCallback(CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ uint8_t code ;
+
+ (void)context ;
+ (void)stat ;
+
+ /* The Handlers are responsible for Deleting the rqt and resp when
+ * they are finished
+ */
+ code = CyAsLLRequestResponse_GetCode(rqt) ;
+ switch(code)
+ {
+ case CY_RQT_TURBO_SWITCH_ENDPOINT:
+ CyAsHalAssert(stat == CY_AS_ERROR_SUCCESS) ;
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+ CyAsLLDestroyResponse(dev_p, resp) ;
+ break;
+ default:
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+}
+
+/* Send a mailbox request to prepare the endpoint for switching */
+static CyAsReturnStatus_t
+MySendTurboSwitch(CyAsDevice* dev_p, uint32_t size, CyBool pktread)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+
+ /* Create the request to send to the West Bridge device */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_TURBO_SWITCH_ENDPOINT, CY_RQT_TUR_RQT_CONTEXT, 3) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)pktread) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((size >> 16) & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(size & 0xFFFF)) ;
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, MyTurboRqtCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyRequest(dev_p, reply_p) ;
+ return ret ;
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbReadData(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyBool pktread, uint32_t dsize, uint32_t *dataread, void *data)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbReadData called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if (ep >= 16 || ep == 4 || ep == 6 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* EP2 is available for reading when MTP is active */
+ if(dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* If the endpoint is disabled, we cannot write data to the endpoint */
+ if (!dev_p->usb_config[ep].enabled)
+ return CY_AS_ERROR_ENDPOINT_DISABLED ;
+
+ if (dev_p->usb_config[ep].dir != CyAsUsbOut)
+ return CY_AS_ERROR_USB_BAD_DIRECTION ;
+
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, pktread, CyTrue, SyncRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (ep == CY_AS_MTP_READ_ENDPOINT )
+ {
+ ret = MySendTurboSwitch(dev_p, dsize, pktread) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, ret) ;
+ return ret ;
+ }
+
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyFalse) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+ else
+ {
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyTrue) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ ret = dev_p->usb_error ;
+ *dataread = dev_p->usb_actual_cnt ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbReadDataAsync(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyBool pktread, uint32_t dsize, void *data, CyAsUsbIoCallback cb)
+{
+ CyAsReturnStatus_t ret ;
+ uint32_t mask ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbReadDataAsync called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (ep >= 16 || ep == 4 || ep == 6 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* EP2 is available for reading when MTP is active */
+ if(dev_p->mtp_count == 0 && ep == CY_AS_MTP_READ_ENDPOINT)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* If the endpoint is disabled, we cannot write data to the endpoint */
+ if (!dev_p->usb_config[ep].enabled)
+ return CY_AS_ERROR_ENDPOINT_DISABLED ;
+
+ if (dev_p->usb_config[ep].dir != CyAsUsbOut && dev_p->usb_config[ep].dir != CyAsUsbInOut)
+ return CY_AS_ERROR_USB_BAD_DIRECTION ;
+
+ /*
+ * Since async operations can be triggered by interrupt code, we must
+ * insure that we do not get multiple async operations going at one time and
+ * protect this test and set operation from interrupts.
+ */
+ mask = CyAsHalDisableInterrupts() ;
+ if (CyAsDeviceIsUsbAsyncPending(dev_p, ep))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+ CyAsDeviceSetUsbAsyncPending(dev_p, ep) ;
+
+ /*
+ * If this is for EP0, we set this bit to delay the ACK response
+ * until after this read has completed.
+ */
+ if (ep == 0)
+ CyAsDeviceSetAckDelayed(dev_p) ;
+
+ CyAsHalEnableInterrupts(mask) ;
+
+ CyAsHalAssert(dev_p->usb_cb[ep] == 0) ;
+ dev_p->usb_cb[ep] = cb ;
+
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, pktread, CyTrue, AsyncReadRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (ep == CY_AS_MTP_READ_ENDPOINT)
+ {
+ ret = MySendTurboSwitch(dev_p, dsize, pktread) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, ret) ;
+ return ret ;
+ }
+ }
+ else
+ {
+ /* Kick start the queue if it is not running */
+ CyAsDmaKickStart(dev_p, ep) ;
+ }
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbWriteData(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, uint32_t dsize, void *data)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbWriteData called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if (ep >= 16 || ep == 2 || ep == 4 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* EP6 is available for writing when MTP is active */
+ if(dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* If the endpoint is disabled, we cannot write data to the endpoint */
+ if (!dev_p->usb_config[ep].enabled)
+ return CY_AS_ERROR_ENDPOINT_DISABLED ;
+
+ if (dev_p->usb_config[ep].dir != CyAsUsbIn && dev_p->usb_config[ep].dir != CyAsUsbInOut)
+ return CY_AS_ERROR_USB_BAD_DIRECTION ;
+
+ /* Write on Turbo endpoint */
+ if (ep == CY_AS_MTP_WRITE_ENDPOINT)
+ {
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST, CY_RQT_TUR_RQT_CONTEXT, 3) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, 0x0006) ; /* EP number to use. */
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((dsize >> 16) & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(dsize & 0xFFFF)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (dsize)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, CyFalse, CyFalse, SyncRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ }
+
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if (dsize)
+ CyAsDmaCancel(dev_p, ep, ret) ;
+ return ret ;
+ }
+
+ /* If this is a zero-byte write, firmware will handle it.
+ * There is no need to do any work here.
+ */
+ if (!dsize)
+ return CY_AS_ERROR_SUCCESS ;
+ }
+ else
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, CyFalse, CyFalse, SyncRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ if (ep != CY_AS_MTP_WRITE_ENDPOINT)
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyTrue) ;
+ else
+ ret = CyAsDmaDrainQueue(dev_p, ep, CyFalse) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ ret = dev_p->usb_error ;
+ return ret ;
+}
+
+static void
+MtpWriteCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ CyAsUsbIoCallback cb ;
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+
+ CyAsHalAssert(context == CY_RQT_TUR_RQT_CONTEXT) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ }
+
+ /* If this was a zero byte transfer request, we can call the callback from
+ * here. */
+ if ((CyAsLLRequestResponse_GetWord(rqt, 1) == 0) &&
+ (CyAsLLRequestResponse_GetWord(rqt, 2) == 0))
+ {
+ cb = dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] ;
+ dev_p->usb_cb[CY_AS_MTP_WRITE_ENDPOINT] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, CY_AS_MTP_WRITE_ENDPOINT) ;
+ if (cb)
+ cb(h, CY_AS_MTP_WRITE_ENDPOINT, 0, 0, ret) ;
+
+ goto destroy ;
+ }
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ /* Firmware failed the request. Cancel the DMA transfer. */
+ CyAsDmaCancel(dev_p, 0x06, CY_AS_ERROR_CANCELED) ;
+ dev_p->usb_cb[0x06] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, 0x06) ;
+ }
+
+destroy:
+ CyAsLLDestroyResponse(dev_p, resp) ;
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbWriteDataAsync(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, uint32_t dsize, void *data, CyBool spacket, CyAsUsbIoCallback cb)
+{
+ uint32_t mask ;
+ CyAsReturnStatus_t ret ;
+ CyAsDevice *dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbWriteDataAsync called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (ep >= 16 || ep == 2 || ep == 4 || ep == 8)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* EP6 is available for writing when MTP is active */
+ if(dev_p->mtp_count == 0 && ep == CY_AS_MTP_WRITE_ENDPOINT)
+ return CY_AS_ERROR_INVALID_ENDPOINT ;
+
+ /* If the endpoint is disabled, we cannot write data to the endpoint */
+ if (!dev_p->usb_config[ep].enabled)
+ return CY_AS_ERROR_ENDPOINT_DISABLED ;
+
+ if (dev_p->usb_config[ep].dir != CyAsUsbIn && dev_p->usb_config[ep].dir != CyAsUsbInOut)
+ return CY_AS_ERROR_USB_BAD_DIRECTION ;
+
+ /*
+ * Since async operations can be triggered by interrupt code, we must
+ * insure that we do not get multiple async operations going at one time and
+ * protect this test and set operation from interrupts.
+ */
+ mask = CyAsHalDisableInterrupts() ;
+ if (CyAsDeviceIsUsbAsyncPending(dev_p, ep))
+ {
+ CyAsHalEnableInterrupts(mask) ;
+ return CY_AS_ERROR_ASYNC_PENDING ;
+ }
+
+ CyAsDeviceSetUsbAsyncPending(dev_p, ep) ;
+
+ if (ep == 0)
+ CyAsDeviceSetAckDelayed(dev_p) ;
+
+ CyAsHalEnableInterrupts(mask) ;
+
+ CyAsHalAssert(dev_p->usb_cb[ep] == 0) ;
+ dev_p->usb_cb[ep] = cb ;
+ dev_p->usb_spacket[ep] = spacket ;
+
+ /* Write on Turbo endpoint */
+ if (ep == CY_AS_MTP_WRITE_ENDPOINT)
+ {
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_TURBO_SEND_RESP_DATA_TO_HOST, CY_RQT_TUR_RQT_CONTEXT, 3) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, 0x0006) ; /* EP number to use. */
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)((dsize >> 16) & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)(dsize & 0xFFFF)) ;
+
+ /* Reserve space for the reply, the reply data will not exceed one word */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (dsize)
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, CyFalse, CyFalse, AsyncWriteRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, MtpWriteCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if (dsize)
+ CyAsDmaCancel(dev_p, ep, ret) ;
+ return ret ;
+ }
+
+ /* Firmware will handle a zero byte transfer without any DMA transfers. */
+ if (!dsize)
+ return CY_AS_ERROR_SUCCESS ;
+ }
+ else
+ {
+ ret = CyAsDmaQueueRequest(dev_p, ep, data, dsize, CyFalse, CyFalse, AsyncWriteRequestCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+ }
+
+ /* Kick start the queue if it is not running */
+ if (ep != CY_AS_MTP_WRITE_ENDPOINT)
+ {
+ CyAsDmaKickStart(dev_p, ep) ;
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+MyUsbCancelAsyncCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ uint8_t ep ;
+ (void)context ;
+
+ ep = (uint8_t)CyAsLLRequestResponse_GetWord(rqt, 0) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ }
+
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+ CyAsLLDestroyResponse(dev_p, resp) ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ dev_p->usb_cb[ep] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, ep) ;
+ }
+}
+
+CyAsReturnStatus_t
+CyAsUsbCancelAsync(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p, *reply_p ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ep &= 0x7F; /* Remove the direction bit. */
+ if (!CyAsDeviceIsUsbAsyncPending(dev_p, ep))
+ return CY_AS_ERROR_ASYNC_NOT_PENDING;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInSuspendMode(dev_p))
+ return CY_AS_ERROR_IN_SUSPEND ;
+
+ if ((ep == CY_AS_MTP_WRITE_ENDPOINT) || (ep == CY_AS_MTP_READ_ENDPOINT))
+ {
+ /* Need firmware support for the cancel operation. */
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_CANCEL_ASYNC_TRANSFER, CY_RQT_TUR_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)ep) ;
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, MyUsbCancelAsyncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ return ret ;
+ }
+ }
+ else
+ {
+ ret = CyAsDmaCancel(dev_p, ep, CY_AS_ERROR_CANCELED) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ dev_p->usb_cb[ep] = 0 ;
+ CyAsDeviceClearUsbAsyncPending(dev_p, ep) ;
+ }
+
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+static void
+CyAsUsbAckCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t ret)
+{
+ CyAsFuncCBNode* node = (CyAsFuncCBNode*)dev_p->func_cbs_usb->head_p ;
+
+ (void)context ;
+
+ if (ret == CY_AS_ERROR_SUCCESS)
+ {
+ if (CyAsLLRequestResponse_GetCode(resp) != CY_RESP_SUCCESS_FAILURE)
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ else
+ ret = CyAsLLRequestResponse_GetWord(resp, 0) ;
+ }
+
+ node->cb_p((CyAsDeviceHandle)dev_p, ret, node->client_data, (CyAsFunctCBType)node->dataType, node->data) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_usb) ;
+
+ CyAsLLDestroyRequest(dev_p, rqt) ;
+ CyAsLLDestroyResponse(dev_p, resp) ;
+ CyAsDeviceClearAckDelayed(dev_p) ;
+}
+
+static CyAsReturnStatus_t
+CyAsUsbAckSetupPacket(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p ;
+ CyAsLLRequestResponse *reply_p ;
+ CyAsFuncCBNode* cbnode ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p) && cb == 0)
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ CyAsHalAssert(cb != 0) ;
+
+ cbnode = CyAsCreateFuncCBNode(cb, client);
+ if( cbnode == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ req_p = CyAsLLCreateRequest(dev_p, 0, CY_RQT_USB_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if(reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ CyAsLLInitRequest(req_p, CY_RQT_ACK_SETUP_PACKET, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ CyAsLLInitResponse(reply_p, 1) ;
+
+ req_p->flags |= CY_AS_REQUEST_RESPONSE_EX ;
+
+ CyAsInsertCBNode(dev_p->func_cbs_usb, cbnode) ;
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, CyAsUsbAckCallback) ;
+
+ return ret ;
+}
+
+/*
+ * Flush all data in logical EP that is being NAK-ed or Stall-ed,
+ * so that this does not continue to block data on other LEPs that
+ * use the same physical EP.
+ */
+static void
+CyAsUsbFlushLogicalEP(
+ CyAsDevice *dev_p,
+ uint16_t ep)
+{
+ uint16_t addr, val, count ;
+
+ addr = CY_AS_MEM_P0_EP2_DMA_REG + ep - 2 ;
+ val = CyAsHalReadRegister(dev_p->tag, addr) ;
+
+ while (val)
+ {
+ count = ((val & 0xFFF) + 1) / 2 ;
+ while (count--)
+ {
+ val = CyAsHalReadRegister(dev_p->tag, ep) ;
+ }
+
+ CyAsHalWriteRegister(dev_p->tag, addr, 0) ;
+ val = CyAsHalReadRegister(dev_p->tag, addr) ;
+ }
+}
+
+static CyAsReturnStatus_t
+CyAsUsbNakStallRequest(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ uint16_t request,
+ CyBool state,
+ CyAsUsbFunctionCallback cb,
+ CyAsFunctionCallback fcb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ uint16_t data ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if(cb)
+ CyAsHalAssert(fcb == 0) ;
+ if(fcb)
+ CyAsHalAssert(cb == 0) ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p) && cb == 0 && fcb == 0)
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ req_p = CyAsLLCreateRequest(dev_p, request, CY_RQT_USB_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Set the endpoint */
+ data = (uint8_t)ep ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, data) ;
+
+ /* Set stall state to stalled */
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint8_t)state) ;
+
+ if (cb || fcb)
+ {
+ void * cbnode ;
+ CyAsCBQueue* queue ;
+ if(cb)
+ {
+ cbnode = CyAsCreateUsbFuncCBNode(cb, client) ;
+ queue = dev_p->usb_func_cbs ;
+ }
+ else
+ {
+ cbnode = CyAsCreateFuncCBNode(fcb, client) ;
+ queue = dev_p->func_cbs_usb ;
+ req_p->flags |= CY_AS_REQUEST_RESPONSE_EX ;
+ }
+
+ if(cbnode == 0)
+ {
+ ret = CY_AS_ERROR_OUT_OF_MEMORY ;
+ goto destroy ;
+ }
+ else
+ CyAsInsertCBNode(queue, cbnode) ;
+
+
+ if (CyAsDeviceIsSetupPacket(dev_p))
+ {
+ /* No Ack is needed on a stall request on EP0 */
+ if ((state == CyTrue) && (ep == 0))
+ {
+ CyAsDeviceSetEp0Stalled(dev_p) ;
+ }
+ else
+ {
+ CyAsDeviceSetAckDelayed(dev_p) ;
+ req_p->flags |= CY_AS_REQUEST_RESPONSE_DELAY_ACK ;
+ }
+ }
+
+ ret = CyAsLLSendRequest(dev_p, req_p, reply_p, CyFalse, CyAsUsbFuncCallback) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ if (req_p->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK)
+ CyAsDeviceRemAckDelayed(dev_p) ;
+ CyAsRemoveCBTailNode(queue) ;
+
+ goto destroy ;
+ }
+ }
+ else
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) != CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+
+ if ((ret == CY_AS_ERROR_SUCCESS) && (request == CY_RQT_STALL_ENDPOINT))
+ {
+ if ((ep > 1) && (state != 0) && (dev_p->usb_config[ep].dir == CyAsUsbOut))
+ CyAsUsbFlushLogicalEP(dev_p, ep) ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+ }
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseGetStall(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyBool *state_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code = CyAsLLRequestResponse_GetCode(reply_p) ;
+
+ if (code == CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ goto destroy ;
+ }
+ else if (code != CY_RESP_ENDPOINT_STALL)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ *state_p = (CyBool)CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ ret = CY_AS_ERROR_SUCCESS ;
+
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+MyHandleResponseGetNak(CyAsDevice* dev_p,
+ CyAsLLRequestResponse *req_p,
+ CyAsLLRequestResponse *reply_p,
+ CyBool *state_p)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+ uint8_t code = CyAsLLRequestResponse_GetCode(reply_p) ;
+
+ if (code == CY_RESP_SUCCESS_FAILURE)
+ {
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ goto destroy ;
+ }
+ else if (code != CY_RESP_ENDPOINT_NAK)
+ {
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ goto destroy ;
+ }
+
+ *state_p = (CyBool)CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ ret = CY_AS_ERROR_SUCCESS ;
+
+
+destroy :
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static CyAsReturnStatus_t
+CyAsUsbGetNakStall(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ uint16_t request,
+ uint16_t response,
+ CyBool *state_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ uint16_t data ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+
+ (void)response ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p) && !cb)
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ req_p = CyAsLLCreateRequest(dev_p, request, CY_RQT_USB_RQT_CONTEXT, 1) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* Set the endpoint */
+ data = (uint8_t)ep ;
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)ep) ;
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if(cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if(request == CY_RQT_GET_STALL)
+ return MyHandleResponseGetStall(dev_p, req_p, reply_p, state_p) ;
+ else
+ return MyHandleResponseGetNak(dev_p, req_p, reply_p, state_p) ;
+
+ }
+ else
+ {
+ CyAsFunctCBType type ;
+
+ if(request == CY_RQT_GET_STALL)
+ type = CY_FUNCT_CB_USB_GETSTALL ;
+ else
+ type = CY_FUNCT_CB_USB_GETNAK ;
+
+ ret = CyAsMiscSendRequest(dev_p, cb, client, type,
+ state_p, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetNak(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_count > 0)
+ return CY_AS_ERROR_NOT_VALID_IN_MTP ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_ENDPOINT_SET_NAK, CyTrue, 0, cb, client) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsUsbClearNak(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_count > 0)
+ return CY_AS_ERROR_NOT_VALID_IN_MTP ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_ENDPOINT_SET_NAK, CyFalse, 0, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbGetNak(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyBool *nak_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_count > 0)
+ return CY_AS_ERROR_NOT_VALID_IN_MTP ;
+
+ return CyAsUsbGetNakStall(handle, ep, CY_RQT_GET_ENDPOINT_NAK, CY_RESP_ENDPOINT_NAK, nak_p, cb, client ) ;
+}
+
+
+CyAsReturnStatus_t
+CyAsUsbSetStall(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_turbo_active)
+ return CY_AS_ERROR_NOT_VALID_DURING_MTP ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_STALL_ENDPOINT, CyTrue, 0, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbClearStall(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_turbo_active)
+ return CY_AS_ERROR_NOT_VALID_DURING_MTP ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_STALL_ENDPOINT, CyFalse, 0, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbGetStall(CyAsDeviceHandle handle,
+ CyAsEndPointNumber_t ep,
+ CyBool *stall_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ if(dev_p->mtp_turbo_active)
+ return CY_AS_ERROR_NOT_VALID_DURING_MTP ;
+
+ return CyAsUsbGetNakStall(handle, ep, CY_RQT_GET_STALL, CY_RESP_ENDPOINT_STALL, stall_p, cb, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSignalRemoteWakeup(CyAsDeviceHandle handle,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if (CyAsDeviceIsInCallback(dev_p))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ if (dev_p->usb_last_event != CyAsEventUsbSuspend)
+ return CY_AS_ERROR_NOT_IN_SUSPEND ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_USB_REMOTE_WAKEUP, CY_RQT_USB_RQT_CONTEXT, 0) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_SIGNALREMOTEWAKEUP,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetMSReportThreshold(CyAsDeviceHandle handle,
+ uint32_t wr_sectors,
+ uint32_t rd_sectors,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ if ((cb == 0) && (CyAsDeviceIsInCallback(dev_p)))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ /* Check if the firmware version supports this feature. */
+ if ((dev_p->media_supported[0]) && (dev_p->media_supported[0] == (1 << CyAsMediaNand)))
+ return CY_AS_ERROR_NOT_SUPPORTED ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_USB_STORAGE_MONITOR, CY_RQT_USB_RQT_CONTEXT, 4) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Set the read and write count parameters into the request structure. */
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((wr_sectors >> 16) & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 1, (uint16_t)(wr_sectors & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 2, (uint16_t)((rd_sectors >> 16) & 0xFFFF)) ;
+ CyAsLLRequestResponse_SetWord(req_p, 3, (uint16_t)(rd_sectors & 0xFFFF)) ;
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_USB_SET_MSREPORT_THRESHOLD,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSelectMSPartitions (
+ CyAsDeviceHandle handle,
+ CyAsBusNumber_t bus,
+ uint32_t device,
+ CyAsUsbMSType_t type,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsLLRequestResponse *req_p , *reply_p ;
+ uint16_t val ;
+
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = IsUsbActive(dev_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ /* This API has to be made before SetEnumConfig is called. */
+ if (dev_p->usb_config[0].enabled)
+ return CY_AS_ERROR_INVALID_CALL_SEQUENCE ;
+
+ if ((cb == 0) && (CyAsDeviceIsInCallback(dev_p)))
+ return CY_AS_ERROR_INVALID_IN_CALLBACK ;
+
+ req_p = CyAsLLCreateRequest(dev_p, CY_RQT_MS_PARTITION_SELECT, CY_RQT_USB_RQT_CONTEXT, 2) ;
+ if (req_p == 0)
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+
+ /* A single status word response type */
+ reply_p = CyAsLLCreateResponse(dev_p, 1) ;
+ if (reply_p == 0)
+ {
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ return CY_AS_ERROR_OUT_OF_MEMORY ;
+ }
+
+ /* Set the read and write count parameters into the request structure. */
+ CyAsLLRequestResponse_SetWord(req_p, 0, (uint16_t)((bus << 8) | device)) ;
+
+ val = 0 ;
+ if ((type == CyAsUsbMSUnit0) || (type == CyAsUsbMSBoth))
+ val |= 1 ;
+ if ((type == CyAsUsbMSUnit1) || (type == CyAsUsbMSBoth))
+ val |= (1 << 8) ;
+
+ CyAsLLRequestResponse_SetWord(req_p, 1, val) ;
+
+ if (cb == 0)
+ {
+ ret = CyAsLLSendRequestWaitReply(dev_p, req_p, reply_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+
+ if (CyAsLLRequestResponse_GetCode(reply_p) == CY_RESP_SUCCESS_FAILURE)
+ ret = CyAsLLRequestResponse_GetWord(reply_p, 0) ;
+ else
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ }
+ else
+ {
+ ret = CyAsMiscSendRequest(dev_p, cb, client, CY_FUNCT_CB_NODATA,
+ 0, dev_p->func_cbs_usb, CY_AS_REQUEST_RESPONSE_EX, req_p, reply_p,
+ CyAsUsbFuncCallback) ;
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ goto destroy ;
+ return ret ;
+ }
+
+destroy:
+ CyAsLLDestroyRequest(dev_p, req_p) ;
+ CyAsLLDestroyResponse(dev_p, reply_p) ;
+
+ return ret ;
+}
+
+static void
+CyAsUsbFuncCallback(
+ CyAsDevice *dev_p,
+ uint8_t context,
+ CyAsLLRequestResponse *rqt,
+ CyAsLLRequestResponse *resp,
+ CyAsReturnStatus_t stat)
+{
+ CyAsUsbFuncCBNode* node = (CyAsUsbFuncCBNode*)dev_p->usb_func_cbs->head_p ;
+ CyAsFuncCBNode* fnode = (CyAsFuncCBNode*)dev_p->func_cbs_usb->head_p ;
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;
+
+ CyAsDeviceHandle h = (CyAsDeviceHandle)dev_p ;
+ CyBool delayed_ack = (rqt->flags & CY_AS_REQUEST_RESPONSE_DELAY_ACK) == CY_AS_REQUEST_RESPONSE_DELAY_ACK;
+ CyBool exRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_EX) == CY_AS_REQUEST_RESPONSE_EX ;
+ CyBool msRequest = (rqt->flags & CY_AS_REQUEST_RESPONSE_MS) == CY_AS_REQUEST_RESPONSE_MS ;
+ uint8_t code ;
+ uint8_t ep, state ;
+
+ if(!exRequest && !msRequest)
+ {
+ CyAsHalAssert(dev_p->usb_func_cbs->count != 0) ;
+ CyAsHalAssert(dev_p->usb_func_cbs->type == CYAS_USB_FUNC_CB) ;
+ }
+ else
+ {
+ CyAsHalAssert(dev_p->func_cbs_usb->count != 0) ;
+ CyAsHalAssert(dev_p->func_cbs_usb->type == CYAS_FUNC_CB) ;
+ }
+
+ (void)context ;
+
+ /* The Handlers are responsible for Deleting the rqt and resp when
+ * they are finished
+ */
+ code = CyAsLLRequestResponse_GetCode(rqt) ;
+ switch(code)
+ {
+ case CY_RQT_START_USB:
+ ret = MyHandleResponseUsbStart(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_STOP_USB:
+ ret = MyHandleResponseUsbStop(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_SET_CONNECT_STATE:
+ if(!CyAsLLRequestResponse_GetWord(rqt, 0))
+ ret = MyHandleResponseDisconnect(dev_p, rqt, resp, stat) ;
+ else
+ ret = MyHandleResponseConnect(dev_p, rqt, resp, stat) ;
+ break ;
+ case CY_RQT_GET_CONNECT_STATE:
+ break ;
+ case CY_RQT_SET_USB_CONFIG:
+ ret = MyHandleResponseSetEnumConfig(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_GET_USB_CONFIG:
+ CyAsHalAssert(fnode->data != 0) ;
+ ret = MyHandleResponseGetEnumConfig(dev_p, rqt, resp, fnode->data) ;
+ break ;
+ case CY_RQT_STALL_ENDPOINT:
+ ep = (uint8_t)CyAsLLRequestResponse_GetWord(rqt, 0) ;
+ state = (uint8_t)CyAsLLRequestResponse_GetWord(rqt, 1) ;
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ if ((ret == CY_AS_ERROR_SUCCESS) && (ep > 1) && (state != 0) && (dev_p->usb_config[ep].dir == CyAsUsbOut))
+ CyAsUsbFlushLogicalEP(dev_p, ep) ;
+ break ;
+ case CY_RQT_GET_STALL:
+ CyAsHalAssert(fnode->data != 0) ;
+ ret = MyHandleResponseGetStall(dev_p, rqt, resp, (CyBool*)fnode->data) ;
+ break ;
+ case CY_RQT_SET_DESCRIPTOR:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_GET_DESCRIPTOR:
+ CyAsHalAssert(fnode->data != 0) ;
+ ret = MyHandleResponseGetDescriptor(dev_p, rqt, resp, (CyAsGetDescriptorData*)fnode->data) ;
+ break;
+ case CY_RQT_SET_USB_CONFIG_REGISTERS:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ if (ret == CY_AS_ERROR_SUCCESS)
+ ret = CyAsUsbSetupDma(dev_p) ;
+ break ;
+ case CY_RQT_ENDPOINT_SET_NAK:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_GET_ENDPOINT_NAK:
+ CyAsHalAssert(fnode->data != 0) ;
+ ret = MyHandleResponseGetNak(dev_p, rqt, resp, (CyBool*)fnode->data) ;
+ break ;
+ case CY_RQT_ACK_SETUP_PACKET:
+ break ;
+ case CY_RQT_USB_REMOTE_WAKEUP:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_CLEAR_DESCRIPTORS:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_USB_STORAGE_MONITOR:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ case CY_RQT_MS_PARTITION_SELECT:
+ ret = MyHandleResponseNoData(dev_p, rqt, resp) ;
+ break ;
+ default:
+ ret = CY_AS_ERROR_INVALID_RESPONSE ;
+ CyAsHalAssert(CyFalse) ;
+ break ;
+ }
+
+ /*
+ * If the low level layer returns a direct error, use the corresponding error code.
+ * If not, use the error code based on the response from firmware.
+ */
+ if (stat == CY_AS_ERROR_SUCCESS)
+ stat = ret ;
+
+ if(exRequest || msRequest)
+ {
+ fnode->cb_p((CyAsDeviceHandle)dev_p, stat, fnode->client_data, (CyAsFunctCBType)fnode->dataType, fnode->data) ;
+ CyAsRemoveCBNode(dev_p->func_cbs_usb) ;
+ }
+ else
+ {
+ node->cb_p((CyAsDeviceHandle)dev_p, stat, node->client_data) ;
+ CyAsRemoveCBNode(dev_p->usb_func_cbs) ;
+ }
+
+ if(delayed_ack)
+ {
+ CyAsHalAssert(CyAsDeviceIsAckDelayed(dev_p)) ;
+ CyAsDeviceRemAckDelayed(dev_p) ;
+
+ /*
+ * Send the ACK if required.
+ */
+ if (!CyAsDeviceIsAckDelayed(dev_p))
+ CyAsUsbAckSetupPacket(h, UsbAckCallback, 0) ;
+ }
+}
+
+/* This includes the implementation of the deprecated functions for backward
+ * compatibility
+ */
+#include "cyasusb_dep_impl.h"
+
+/*[]*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/api/src/cyasusb_dep_impl.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,230 @@
+/* Cypress West Bridge API source file (cyasusb_dep_impl.h)
+## ===========================
+##
+## Copyright Cypress Semiconductor Corporation, 2006-2009,
+## All Rights Reserved
+## UNPUBLISHED, LICENSED SOFTWARE.
+##
+## CONFIDENTIAL AND PROPRIETARY INFORMATION
+## WHICH IS THE PROPERTY OF CYPRESS.
+##
+## Use of this file is governed
+## by the license agreement included in the file
+##
+## <install>/license/license.txt
+##
+## where <install> is the Cypress software
+## installation root directory path.
+##
+## ===========================
+*/
+
+/* This c file will contain Antioch specific implementation
+ * of the APIs that are deprecated in Astoria SDK. This is
+ * for maintaining backward compatibility
+ */
+
+#include "cyasusb.h"
+/*
+* This function registers a callback to be called when USB events are processed
+*/
+CyAsReturnStatus_t
+CyAsUsbRegisterCallback_dep(CyAsDeviceHandle handle, CyAsUsbEventCallback_dep callback)
+{
+ CyAsDevice*dev_p ;
+
+ CyAsLogDebugMessage(6, "CyAsUsbRegisterCallback called") ;
+
+ dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ dev_p->usb_event_cb = callback ;
+ dev_p->usb_event_cb_ms = NULL ;
+ return CY_AS_ERROR_SUCCESS ;
+}
+
+/*
+* This method sets how the USB is enumerated and should be called before the
+* CyAsUsbConnect() is called.
+*/
+CyAsReturnStatus_t
+CyAsUsbSetEnumConfig_dep(CyAsDeviceHandle handle,
+ CyAsUsbEnumControl_dep *config_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ uint8_t enum_bus = 0 ;
+ uint8_t bus ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ if (!CyAsDeviceIsConfigured(dev_p))
+ return CY_AS_ERROR_NOT_CONFIGURED ;
+
+ if (!CyAsDeviceIsFirmwareLoaded(dev_p))
+ return CY_AS_ERROR_NO_FIRMWARE ;
+
+ /*
+ * Map the storage devices to be enumerated to the storage
+ * buses to be enumerated.
+ */
+ for (bus = 0; bus < CY_AS_MAX_BUSES; bus++)
+ {
+ if (config_p->enum_mass_storage & dev_p->media_supported[bus])
+ enum_bus |= (0x01 << bus) ;
+ }
+
+ return MyUsbSetEnumConfig(dev_p, enum_bus,
+ config_p->enum_mass_storage,
+ config_p->antioch_enumeration,
+ config_p->mass_storage_interface,
+ 0,
+ config_p->mass_storage_callbacks,
+ cb,
+ client
+ ) ;
+}
+
+/*
+* This method returns the enumerateion configuration information from the Antioch device. Generally this is not
+* used by client software but is provided mostly for debug information. We want a method to read all state information
+* from the Antioch device.
+*/
+CyAsReturnStatus_t
+CyAsUsbGetEnumConfig_dep(CyAsDeviceHandle handle,
+ CyAsUsbEnumControl_dep *config_p,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ return MyUsbGetEnumConfig(handle, CY_AS_REQUEST_RESPONSE_EX, config_p, cb, client);
+}
+
+
+CyAsReturnStatus_t
+CyAsUsbGetDescriptor_dep(CyAsDeviceHandle handle,
+ CyAsUsbDescType type,
+ uint8_t index,
+ void *desc_p,
+ uint32_t *length_p)
+{
+ CyAsGetDescriptorData data ;
+ CyAsReturnStatus_t status;
+
+ data.desc_p = desc_p;
+ data.length = *length_p;
+ status = CyAsUsbGetDescriptor(handle, type, index, &data, 0, 0) ;
+ *length_p = data.length ;
+
+ return status ;
+}
+
+
+CyAsReturnStatus_t
+CyAsUsbSetNak_dep(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbFunctionCallback cb, uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_ENDPOINT_SET_NAK, CyTrue, cb, 0, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbClearNak_dep(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbFunctionCallback cb, uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_ENDPOINT_SET_NAK, CyFalse, cb, 0, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbSetStall_dep(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbFunctionCallback cb, uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_STALL_ENDPOINT, CyTrue, cb, 0, client) ;
+}
+
+CyAsReturnStatus_t
+CyAsUsbClearStall_dep(CyAsDeviceHandle handle, CyAsEndPointNumber_t ep, CyAsUsbFunctionCallback cb, uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ /*
+ * We send the firmware the EP# with the appropriate direction bit, regardless
+ * of what the user gave us.
+ */
+ ep &= 0x0f ;
+ if (dev_p->usb_config[ep].dir == CyAsUsbIn)
+ ep |= 0x80 ;
+
+ return CyAsUsbNakStallRequest(handle, ep, CY_RQT_STALL_ENDPOINT, CyFalse, cb, 0, client) ;
+}
+
+extern CyAsReturnStatus_t
+CyAnMapBusFromMediaType (
+ CyAsDevice *dev_p,
+ CyAsMediaType type,
+ CyAsBusNumber_t *bus) ;
+
+CyAsReturnStatus_t
+CyAsUsbSelectMSPartitions_dep (
+ CyAsDeviceHandle handle,
+ CyAsMediaType media,
+ uint32_t device,
+ CyAsUsbMSType_t type,
+ CyAsFunctionCallback cb,
+ uint32_t client)
+{
+ CyAsDevice *dev_p = (CyAsDevice *)handle ;
+ CyAsBusNumber_t bus ;
+ CyAsReturnStatus_t ret ;
+
+ if (!dev_p ||(dev_p->sig != CY_AS_DEVICE_HANDLE_SIGNATURE))
+ return CY_AS_ERROR_INVALID_HANDLE ;
+
+ ret = CyAnMapBusFromMediaType(dev_p, media, &bus) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ return ret ;
+
+ return CyAsUsbSelectMSPartitions(handle, bus, device, type, cb, client) ;
+}
+
+/*[]*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/bld.inf Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,19 @@
+// ===========================
+//
+// Copyright Cypress Semiconductor Corporation, 2006-2009,
+// All Rights Reserved
+// UNPUBLISHED, LICENSED SOFTWARE.
+//
+// CONFIDENTIAL AND PROPRIETARY INFORMATION
+// WHICH IS THE PROPERTY OF CYPRESS.
+//
+// ===========================
+
+PRJ_PLATFORMS
+ARMV5
+
+PRJ_EXPORTS
+./drivers/CyAsSymbianStorageDriver.h assp/omap3530_assp/
+
+PRJ_MMPFILES
+wb
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/def/eabi/wbu.def Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,18 @@
+EXPORTS
+ _ZN24CyAsSymbianStorageDriver4OpenEv @ 1 NONAME
+ _ZN24CyAsSymbianStorageDriver5CloseEv @ 2 NONAME
+ _ZN24CyAsSymbianStorageDriver4ReadEiiPv @ 3 NONAME
+ _ZN24CyAsSymbianStorageDriver5WriteEiiPv @ 4 NONAME
+
+ _ZN24CyAsSymbianStorageDriver12GetMediaTypeEv @ 5 NONAME
+ _ZN24CyAsSymbianStorageDriver14GetIsRemovableEv @ 6 NONAME
+ _ZN24CyAsSymbianStorageDriver14GetIsWriteableEv @ 7 NONAME
+ _ZN24CyAsSymbianStorageDriver12GetBlockSizeEv @ 8 NONAME
+ _ZN24CyAsSymbianStorageDriver16GetNumberOfUnitsEv @ 9 NONAME
+ _ZN24CyAsSymbianStorageDriver11GetIsLockedEv @ 10 NONAME
+ _ZN24CyAsSymbianStorageDriver17GetEraseBlockSizeEv @ 11 NONAME
+ _ZN24CyAsSymbianStorageDriver11GetUnitSizeEv @ 12 NONAME
+ _ZN24CyAsSymbianStorageDriver13GetStartBlockEv @ 13 NONAME
+ _ZN24CyAsSymbianStorageDriver12GetMediaSizeEv @ 14 NONAME
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/drivers/CyAsSymbianStorageDriver.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,233 @@
+
+#include <kern_priv.h>
+//#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+//#include <assp/omap3530_assp/omap3530_assp_priv.h>
+//#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+//#include <assp/omap3530_assp/omap3530_gpio.h>
+
+//#include <assp.h> // Required for definition of TIsr
+
+#include <cyastoria.h>
+#include <cyasmtp.h>
+#include <cyasusbinit.h>
+//#include <cyasusbdescs.h>
+#include "CyAsSymbianStorageDriver.h"
+
+extern TmtpAstDev g_AstDevice;
+extern TmtpAstDev * g_pAstDevice;
+
+_LIT(KLitWbAPIMutex,"WBAPIMutex");
+static DMutex *WbApiMutex;
+const TUint8 KMutexOrdWB = 0x11; /**< @internalComponent */
+
+TInt64 iMediaTotalSize;
+EXPORT_C int CyAsSymbianStorageDriver::Open(void)
+{
+ //CyAsHalDeviceTag tag;
+ CyAsDeviceHandle h;
+ CyAsReturnStatus_t ret ;
+ char *media_name = "SD";
+ uint32_t count = 0 ;
+
+ Kern::MutexCreate(WbApiMutex, KLitWbAPIMutex, KMutexOrdWB);
+ //tag = g_pAstDevice->astHalTag ;
+ h = g_pAstDevice->astDevHandle ;
+
+ Kern::Printf("*** CyAsStorageStart...\n") ;
+ ret = CyAsStorageStart(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageOpen: CyAsStorageStart returned error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ Kern::Printf("*** CyAsStorageQueryMedia...\n") ;
+ ret = CyAsStorageQueryMedia(h, CyAsMediaSDFlash, &count, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device count - Reason code %d\n", media_name, ret) ;
+ return 0 ;
+ }
+ Kern::Printf("%d %s device(s) found\n", count, media_name) ;
+
+ Kern::Printf("*** CyAsStorageClaim...\n") ;
+ ret = CyAsStorageClaim(h, CyAsBus_1, 0, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageOpen: Cannot claim %s media - Reason code %d\n", media_name, ret) ;
+ return 0;
+ }
+
+ /* We know that there is only one */
+ g_pAstDevice->dev_data.bus = CyAsBus_1 ;
+ g_pAstDevice->dev_data.device = 0 ;
+ ret = CyAsStorageQueryDevice(h, &(g_pAstDevice->dev_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device - Reason code %d\n", media_name, ret) ;
+ return 0 ;
+ }
+
+ g_pAstDevice->unit_data.bus = CyAsBus_1 ;
+ g_pAstDevice->unit_data.device = 0 ;
+ g_pAstDevice->unit_data.unit = 0 ;
+
+ /* We know that there is only one */
+ ret = CyAsStorageQueryUnit(h, &(g_pAstDevice->unit_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageOpen: Cannot query %s device unit - Reason code %d\n", media_name, ret) ;
+ return 0 ;
+ }
+
+ iMediaTotalSize = (TInt64)g_pAstDevice->dev_data.desc_p.block_size * (TInt64)g_pAstDevice->unit_data.desc_p.unit_size;
+
+#if 0
+ Kern::Printf("========================================================") ;
+ Kern::Printf("WBStorageInfo.type - %d", g_pAstDevice->dev_data.desc_p.type) ;
+ Kern::Printf("WBStorageInfo.removable - %d", g_pAstDevice->dev_data.desc_p.removable) ;
+ Kern::Printf("WBStorageInfo.writeable - %d", g_pAstDevice->dev_data.desc_p.writeable) ;
+ Kern::Printf("WBStorageInfo.block_size - %d Bytes", g_pAstDevice->dev_data.desc_p.block_size) ;
+ Kern::Printf("WBStorageInfo.number_units - %d", g_pAstDevice->dev_data.desc_p.number_units) ;
+ Kern::Printf("WBStorageInfo.locked - %d", g_pAstDevice->dev_data.desc_p.locked) ;
+ Kern::Printf("WBStorageInfo.erase_unit_size - %d Bytes", g_pAstDevice->dev_data.desc_p.erase_unit_size) ;
+ Kern::Printf("WBStorageInfo.unit_size - %d", g_pAstDevice->unit_data.desc_p.unit_size) ;
+ Kern::Printf("WBStorageInfo.start_block - %d", g_pAstDevice->unit_data.desc_p.start_block) ;
+ Kern::Printf("WBStorageInfo.totalsize - %d Bytes", iMediaTotalSize) ;
+ Kern::Printf("========================================================\n") ;
+#endif
+ return 1;
+}
+EXPORT_C int CyAsSymbianStorageDriver::Close(void)
+{
+ CyAsDeviceHandle h;
+ CyAsReturnStatus_t ret ;
+
+ //tag = g_pAstDevice->astHalTag ;
+ h = g_pAstDevice->astDevHandle ;
+ Kern::Printf("*** CyAsStorageStop...\n") ;
+ ret = CyAsStorageStop(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsStorageStop: CyAsStorageStop returned error code %d\n", ret) ;
+ return 0 ;
+ }
+ return 1;
+}
+
+EXPORT_C int CyAsSymbianStorageDriver::Read(int pos, int num_block, void* cybuf)
+{
+ //CyAsHalDeviceTag tag;
+ CyAsDeviceHandle h;
+ CyAsReturnStatus_t ret ;
+ char *tmpbuf;
+
+ Kern::MutexWait(*WbApiMutex);
+
+ tmpbuf = (char *)cybuf;
+ //tag = g_pAstDevice->astHalTag ;
+ h = g_pAstDevice->astDevHandle ;
+ //CyAsHalPrintMessage("Read SD card\n");
+ ret = CyAsStorageRead( h, 1, 0, 0, pos, tmpbuf, num_block);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ Kern::Printf("CyAsSymbianStorageRead: Cannot read sector %d (%d@%d)\n", ret, num_block, pos) ;
+ return 0 ;
+ }
+ Kern::MutexSignal(*WbApiMutex);
+
+ return 1;
+}
+
+
+EXPORT_C int CyAsSymbianStorageDriver::Write(int pos, int num_block, void* cybuf)
+{
+ //CyAsHalDeviceTag tag;
+ CyAsDeviceHandle h;
+ CyAsReturnStatus_t ret ;
+ char *tmpbuf;
+
+ Kern::MutexWait(*WbApiMutex);
+
+ tmpbuf = (char *)cybuf;
+ //tag = g_pAstDevice->astHalTag ;
+ h = g_pAstDevice->astDevHandle ;
+
+ ret = CyAsStorageWrite(h, 1, 0, 0, pos, tmpbuf, num_block);
+ if ( ret != CY_AS_ERROR_SUCCESS )
+ {
+ Kern::Printf("CyAsSymbianStorageWrite: Cannot write to first sector of SD card\n") ;
+ return 0 ;
+ }
+ Kern::MutexSignal(*WbApiMutex);
+
+ return 1;
+}
+
+EXPORT_C TInt CyAsSymbianStorageDriver::GetMediaType(void)
+{
+ /* Type of device */
+ return (TInt)g_pAstDevice->dev_data.desc_p.type;
+}
+
+EXPORT_C TInt CyAsSymbianStorageDriver::GetIsRemovable(void)
+{
+ /* Is the device removable */
+ return g_pAstDevice->dev_data.desc_p.removable;
+}
+
+EXPORT_C TInt CyAsSymbianStorageDriver::GetIsWriteable(void)
+{
+ /* Is the device writeable */
+ return g_pAstDevice->dev_data.desc_p.writeable;
+}
+
+EXPORT_C TUint16 CyAsSymbianStorageDriver::GetBlockSize(void)
+{
+ /* Basic block size for device */
+ return g_pAstDevice->dev_data.desc_p.block_size;
+}
+
+EXPORT_C TUint CyAsSymbianStorageDriver::GetNumberOfUnits(void)
+{
+ /* Number of LUNs on the device */
+ return g_pAstDevice->dev_data.desc_p.number_units;
+}
+
+EXPORT_C TInt CyAsSymbianStorageDriver::GetIsLocked(void)
+{
+ /* Is the device password locked */
+ return g_pAstDevice->dev_data.desc_p.locked;
+}
+
+EXPORT_C TUint CyAsSymbianStorageDriver::GetEraseBlockSize(void)
+{
+ /* Size in bytes of an Erase Unit. Block erase operation is only supported for SD storage,
+ and the erase_unit_size is invalid for all other kinds of storage. */
+ return g_pAstDevice->dev_data.desc_p.erase_unit_size;
+}
+
+EXPORT_C TUint CyAsSymbianStorageDriver::GetUnitSize(void)
+{
+ /* Number of blocks in the LUN */
+ return g_pAstDevice->unit_data.desc_p.unit_size;
+}
+
+EXPORT_C TUint CyAsSymbianStorageDriver::GetStartBlock(void)
+{
+ /* Physical start block for LUN */
+ return g_pAstDevice->unit_data.desc_p.start_block;
+}
+
+EXPORT_C TInt64 CyAsSymbianStorageDriver::GetMediaSize(void)
+{
+
+ /*(Basic block size for device x Number of LUNs on the device)
+ g_pAstDevice->dev_data.desc_p.block_size * g_pAstDevice->dev_data.desc_p.number_units */
+ return iMediaTotalSize;
+}
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/drivers/CyAsSymbianStorageDriver.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,28 @@
+
+#ifndef ASTORIAAPISTORAGE_H
+#define ASTORIAAPISTORAGE_H
+
+
+class CyAsSymbianStorageDriver
+{
+
+public:
+ IMPORT_C static int Open(void);
+ IMPORT_C static int Close(void);
+ IMPORT_C static int Read(int, int, void*);
+ IMPORT_C static int Write(int, int, void*);
+
+ IMPORT_C static TInt GetMediaType(void);
+ IMPORT_C static TInt GetIsRemovable(void);
+ IMPORT_C static TInt GetIsWriteable(void);
+ IMPORT_C static TUint16 GetBlockSize(void);
+ IMPORT_C static TUint GetNumberOfUnits(void);
+ IMPORT_C static TInt GetIsLocked(void);
+ IMPORT_C static TUint GetEraseBlockSize(void);
+ IMPORT_C static TUint GetUnitSize(void);
+ IMPORT_C static TUint GetStartBlock(void);
+ IMPORT_C static TInt64 GetMediaSize(void);
+
+};
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/drivers/cyasusbinit.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,1306 @@
+#include <kern_priv.h>
+#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+#include <assp/omap3530_assp/omap3530_assp_priv.h>
+#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+#include <assp/omap3530_assp/omap3530_gpio.h>
+
+#include <assp.h> // Required for definition of TIsr
+
+#include <cyastoria.h>
+#include <cyasmtp.h>
+#include <cyasusbinit.h>
+#include <cyasusbdescs.h>
+
+TmtpAstDev g_AstDevice;
+TmtpAstDev * g_pAstDevice = &g_AstDevice ;
+
+static uint16_t replybuf[512] ;
+static uint8_t *replyptr = (uint8_t *) replybuf ;
+
+static uint8_t *
+GetReplyArea(void)
+{
+ /*assert(replyptr != 0) ;*/
+ replyptr = 0 ;
+ return (uint8_t *) replybuf ;
+}
+
+static void
+RestoreReplyArea(void)
+{
+ replyptr = (uint8_t *) replybuf ;
+}
+
+/* Globals */
+/*static uint8_t pktbuffer3[512] ;*/
+
+#ifdef CY_AS_USB_TB_FOUR
+static uint8_t pktbuffer7[512] ;
+#endif
+
+#ifdef CY_AS_USB_TB_SIX
+static uint8_t pktbuffer11[512] ;
+#endif
+
+/*static uint8_t turbopktbuffer[512] ;*/
+
+static CyBool gUsbTestDone = CyFalse ;
+static volatile CyBool gSetConfig = CyFalse ;
+static volatile CyBool gAsyncStallDone = CyFalse ;
+
+static volatile CyBool gStorageReleaseBus0 = CyFalse ;
+static volatile CyBool gStorageReleaseBus1 = CyFalse ;
+
+static volatile CyAsHalDeviceTag g_tag ;
+
+static uint8_t MyConfiguration = 0 ;
+static CyCh9ConfigurationDesc *desc_p = 0 ;
+static CyCh9ConfigurationDesc *other_p = 0 ;
+static CyBool gSetupPending = CyFalse ;
+
+static volatile uint8_t gAsyncStallStale = 0;
+
+/* Forward declarations */
+static int SetupUSBPPort(CyAsDeviceHandle h, uint8_t media, CyBool isTurbo) ;
+static void MyUsbEventCallbackMS(CyAsDeviceHandle h, CyAsUsbEvent ev, void *evdata) ;
+static void PrintData(const char *name, uint8_t *data, uint16_t size) ;
+
+static void
+StallCallback(CyAsDeviceHandle h, CyAsReturnStatus_t status, uint32_t tag, CyAsFunctCBType cbtype, void *cbdata)
+{
+ (void)h ;
+ (void)cbtype ;
+ (void)cbdata ;
+
+ if (tag == 1)
+ CyAsHalPrintMessage("*** Nak callback - status = %d\n", status) ;
+ else
+ CyAsHalPrintMessage("*** Stall callback - status = %d\n", status) ;
+}
+
+static void
+StallCallbackEX(CyAsDeviceHandle h,
+ CyAsReturnStatus_t status,
+ uint32_t tag,
+ CyAsFunctCBType type,
+ void* data)
+{
+ (void)h ;
+ (void)type ;
+ (void)data ;
+ (void)status ;
+
+ if(tag == 18)
+ {
+ CyAsReturnStatus_t ret = CyAsUsbClearStall(h, 3, StallCallbackEX, 21);
+ CyAsHalAssert(ret == CY_AS_ERROR_SUCCESS) ;
+ }
+ else
+ gAsyncStallDone = CyTrue ;
+}
+
+static void
+StallCallbackAsync(CyAsDeviceHandle h, CyAsReturnStatus_t status, uint32_t tag, CyAsFunctCBType cbtype, void *cbdata)
+{
+ CyAsReturnStatus_t ret ;
+ (void)cbtype ;
+ (void)cbdata ;
+ (void)tag ;
+ (void)status ;
+
+ if(gAsyncStallStale == 0)
+ {
+ gAsyncStallStale++;
+ ret = CyAsUsbClearStall(h, 3, StallCallbackAsync, 21);
+ CyAsHalAssert(ret == CY_AS_ERROR_SUCCESS) ;
+ }
+ else
+ {
+ gAsyncStallDone = CyTrue ;
+ }
+}
+
+static void
+MyStorageEventCBMS(CyAsDeviceHandle h, CyAsBusNumber_t bus, uint32_t device, CyAsStorageEvent evtype, void *evdata)
+{
+ (void)h ;
+ (void)evdata ;
+
+ switch (evtype)
+ {
+ case CyAsStorageAntioch:
+ CyAsHalPrintMessage("CyAsStorageAntioch Event: bus=%d, device=%d\n", bus, device) ;
+ switch (bus)
+ {
+ case 0:
+ gStorageReleaseBus0 = CyTrue ;
+ break;
+ case 1:
+ gStorageReleaseBus1 = CyTrue ;
+ break;
+ default:
+ break;
+ }
+ break;
+
+ case CyAsStorageProcessor:
+ CyAsHalPrintMessage("CyAsStorageProcessor Event: bus=%d, device %d\n", bus, device) ;
+ break;
+
+ case CyAsStorageRemoved:
+ CyAsHalPrintMessage("Bus %d, device %d has been removed\n", bus, device) ;
+ break;
+
+ case CyAsStorageInserted:
+ CyAsHalPrintMessage("Bus %d, device %d has been inserted\n", bus, device) ;
+ break;
+
+ default:
+ break;
+ }
+}
+
+
+/*
+* This function exercises the USB module
+*/
+int CyAsAPIUsbInit(const char *pgm, CyAsDeviceHandle h, CyAsHalDeviceTag tag)
+{
+ CyAsReturnStatus_t ret ;
+ /*char buffer[16] ;*/
+
+ g_tag = tag ;
+ memset(g_pAstDevice,0, sizeof(g_AstDevice));
+ g_pAstDevice->astHalTag = tag ;
+ g_pAstDevice->astDevHandle = h ;
+
+ /*
+ * Give a delay to allow any equipment to be ready (e.g. CATC)
+ */
+ /*CyAsHalPrintMessage("Press enter to begin USB operation (%s): ", "P Port Enumeration") ;
+ fgets(buffer, sizeof(buffer), stdin) ;*/
+
+ CyAsHalPrintMessage("*** CyAsStorageStart...\n") ;
+ ret = CyAsStorageStart(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: CyAsStorageStart returned error code %d\n", pgm, ret) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("*** CyAsStorageStart...Done\n") ;
+ /*
+ * Register a storage event call-back so that the USB attached storage can be
+ * release when the USB connection has been made.
+ */
+ CyAsHalPrintMessage("*** CyAsStorageRegisterCallback...\n") ;
+ ret = CyAsStorageRegisterCallback(h, MyStorageEventCBMS) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: CyAsStorageRegisterCallbackMS returned error code %d\n", pgm, ret) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("*** CyAsStorageRegisterCallback...Done\n") ;
+
+ ret = CyAsStorageRelease(h, 1, 0, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsStorageReleaseMS returned error code %d\n", ret) ;
+ return 0 ;
+ }
+ gStorageReleaseBus1 = CyFalse ;
+
+ /*
+ * Use the 24 MHz operating frequency, if the SD card is a low speed one.
+ */
+ ret = CyAsMiscSetLowSpeedSDFreq(h, CY_AS_SD_RATED_FREQ, 0, 0) ;
+ if ((ret != CY_AS_ERROR_SUCCESS) && (ret != CY_AS_ERROR_INVALID_RESPONSE))
+ {
+ CyAsHalPrintMessage("%s: CyAsMiscSetLowSpeedSDFreq returned error code %d\n", pgm, ret) ;
+ return 0 ;
+ }
+
+ /*
+ * We are using P Port based enumeration
+ */
+#ifdef DEBUG_ZERO
+ if (!SetupUSBPPort(h, 2, 0))
+#else
+ if (!SetupUSBPPort(h, 2, 1))
+#endif
+ return 0 ;
+ /*
+ * Now we let the enumeration process happen via callbacks. When the set configuration
+ * request is processed, we are done with enumeration and ready to perform our function.
+ */
+ while (!gSetConfig)
+ CyAsHalSleep(100) ;
+
+ CyAsHalPrintMessage("*** Configuration complete, starting echo function\n") ;
+
+ return 1 ;
+}
+
+static void
+MyCyAsMTPEventCallback(
+ CyAsDeviceHandle handle,
+ CyAsMTPEvent evtype,
+ void* evdata)
+{
+ (void) handle;
+ switch(evtype)
+ {
+ case CyAsMTPSendObjectComplete:
+ {
+ CyAsMTPSendObjectCompleteData* sendObjData = (CyAsMTPSendObjectCompleteData*) evdata ;
+ CyAsHalPrintMessage("MTP EVENT: SendObjectComplete\n");
+ CyAsHalPrintMessage("Bytes sent = %d\nSend status = %d",sendObjData->byte_count,sendObjData->status);
+ g_pAstDevice->tmtpSendCompleteData.byte_count = sendObjData->byte_count;
+ g_pAstDevice->tmtpSendCompleteData.status = sendObjData->status;
+ g_pAstDevice->tmtpSendCompleteData.transaction_id = sendObjData->transaction_id ;
+ g_pAstDevice->tmtpSendComplete = CyTrue ;
+ break;
+ }
+ case CyAsMTPGetObjectComplete:
+ {
+ CyAsMTPGetObjectCompleteData* getObjData = (CyAsMTPGetObjectCompleteData*) evdata ;
+ CyAsHalPrintMessage("MTP EVENT: GetObjectComplete\n");
+ CyAsHalPrintMessage("Bytes got = %d\nGet status = %d",getObjData->byte_count,getObjData->status);
+ g_pAstDevice->tmtpGetCompleteData.byte_count = getObjData->byte_count;
+ g_pAstDevice->tmtpGetCompleteData.status = getObjData->status ;
+ g_pAstDevice->tmtpGetComplete = CyTrue ;
+ break;
+ }
+ case CyAsMTPBlockTableNeeded:
+ g_pAstDevice->tmtpNeedNewBlkTbl = CyTrue ;
+ break;
+ default:
+ ;
+ }
+
+}
+/*
+* This function is responsible for initializing the USB function within West Bridge. This
+* function initializes West Bridge for P port based enumeration.
+*/
+int SetupUSBPPort(CyAsDeviceHandle h, uint8_t bus, CyBool isTurbo)
+{
+ CyAsReturnStatus_t ret ;
+ CyAsUsbEnumControl config ;
+#ifdef DEBUG_ZERO
+ CyAsUsbEndPointConfig epconfig ;
+#endif
+ uint32_t count = 0 ;
+ char *media_name = "SD";
+
+ gUsbTestDone = CyFalse ;
+
+ CyAsHalPrintMessage("*** SetupUSBPPort...\n") ;
+ /*
+ * Intialize the primary descriptor to be the full speed descriptor and the
+ * other descriptor to by the high speed descriptor. This will swap if we see a
+ * high speed event.
+ */
+#ifdef DEBUG_ZERO
+ desc_p = (CyCh9ConfigurationDesc *)&ConfigFSDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ConfigHSDesc ;
+#else
+ desc_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+#endif
+ /* Step 1: Release the USB D+ and D- pins
+ *
+ * This code releases control of the D+ and D- pins if they have been previously
+ * acquired by the P Port processor. The physical D+ and D- pins are controlled either by
+ * West Bridge, or by some other hardware external to West Bridge. If external hardware is using
+ * these pins, West Bridge must put these pins in a high impedence state in order to insure there
+ * is no coflict over the use of the pins. Before we can initialize the USB capabilities of
+ * West Bridge, we must be sure West Bridge has ownership of the D+ and D- signals. West Bridge will take
+ * ownership of these pins as long as the P port processor has released them. This call
+ * releases control of these pins. Before calling the CyAsMiscReleaseResource(), the P port API
+ * must configure the hardware to release control of the D+ and D- pins by any external hardware.
+ *
+ * Note that this call can be made anywhere in the intialization sequence as long as it is done
+ * before the call to CyAsUsbConnect(). If not, when the CyAsUsbConnect() call is made, West Bridge
+ * will detect that it does not own the D+ and D- pins and the call to CyAsUsbConnect will fail.
+ */
+ ret = CyAsMiscReleaseResource(h, CyAsBusUSB) ;
+ if (ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_RESOURCE_NOT_OWNED)
+ {
+ CyAsHalPrintMessage("Cannot Release USB reousrce: CyAsMiscReleaseResourceMS failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ /*
+ * Step 2: Start the USB stack
+ *
+ * This code initializes the USB stack. It takes a handle to an West Bridge device
+ * previously created with a call to CyAsMiscCreateDevice().
+ */
+ ret = CyAsUsbStart(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbStart failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ /*
+ * Step 3: Register a callback
+ *
+ * This code registers a callback to handle USB events. This callback function will handle
+ * all setup packets during enumeration as well as other USB events (SUSPEND, RESUME, CONNECT,
+ * DISCONNECT, etc.)
+ */
+ ret = CyAsUsbRegisterCallback(h, MyUsbEventCallbackMS) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbRegisterCallbackMS failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+#ifdef DEBUG_ZERO
+ if ( isTurbo )
+#endif
+ {
+ /*
+ * The SD/MMC resource needs to be released before the device
+ * can be successfully initialized by the firmware.
+ */
+ ret = CyAsMiscReleaseResource(h, CyAsBus_1) ;
+ if (ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_RESOURCE_NOT_OWNED)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: CyAsMiscReleaseResource failed with error code %d\n", ret) ;
+ return -ret;
+ }
+
+ ret = CyAsStorageStart(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: CyAsStorageStart failed with error code %d\n", ret) ;
+ return -ret;
+ }
+
+ ret = CyAsStorageQueryMedia(h, CyAsMediaSDFlash, &count, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: Cannot query %s device count - Reason code %d\n", media_name, ret) ;
+ return -ret ;
+ }
+ CyAsHalPrintMessage("CyAsMtpApp: %d %s device(s) found\n", count, media_name) ;
+
+ ret = CyAsStorageClaim(h, CyAsBus_1, 0, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: Cannot claim %s media - Reason code %d\n", media_name, ret) ;
+ return -ret;
+ }
+
+ /* We know that there is only one */
+ g_pAstDevice->dev_data.bus = CyAsBus_1 ;
+ g_pAstDevice->dev_data.device = 0 ;
+ ret = CyAsStorageQueryDevice(h, &(g_pAstDevice->dev_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: Cannot query %s device - Reason code %d\n", media_name, ret) ;
+ return -ret ;
+ }
+ CyAsHalPrintMessage("CyAsMtpApp: blocksize %d, %d units found\n",
+ g_pAstDevice->dev_data.desc_p.block_size, g_pAstDevice->dev_data.desc_p.number_units) ;
+
+ g_pAstDevice->unit_data.bus = CyAsBus_1 ;
+ g_pAstDevice->unit_data.device = 0 ;
+ g_pAstDevice->unit_data.unit = 0 ;
+ /* We know that there is only one */
+ ret = CyAsStorageQueryUnit(h, &(g_pAstDevice->unit_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: Cannot query %s device unit - Reason code %d\n", media_name, ret) ;
+ return -ret ;
+ }
+ CyAsHalPrintMessage("CyAsMtpApp: blocksize %d, %d Block(s) found\n",
+ g_pAstDevice->unit_data.desc_p.block_size, g_pAstDevice->unit_data.desc_p.unit_size) ;
+
+ CyAsHalPrintMessage("CyAsMtpApp: Starting TMTP...\n");
+ ret = CyAsMTPStart(h, MyCyAsMTPEventCallback, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsMTPStart failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+ }
+
+ /*
+ * Step 4: Setup the enumeration mode
+ *
+ * This code tells the West Bridge API how enumeration will be done. Specifically in this
+ * example we are configuring the API for P Port processor based enumeraton. This will cause
+ * all setup packets to be relayed to the P port processor via the USB event callback. See
+ * the function CyAsUsbRegisterEventCallback() for more information about this callback.
+ */
+ config.antioch_enumeration = CyFalse ; /* P port will do enumeration, not West Bridge */
+
+ /* Set the media to enumerate through USB */
+#ifdef DEBUG_ZERO
+ config.devices_to_enumerate[0][0] = CyFalse;
+ config.devices_to_enumerate[1][0] = CyFalse;
+#else
+ config.devices_to_enumerate[0][0] = (bus & CY_TEST_BUS_0) ? CyTrue : CyFalse;
+ config.devices_to_enumerate[1][0] = (bus & CY_TEST_BUS_1) ? CyTrue : CyFalse;
+#endif
+
+ if (isTurbo)
+ {
+ /* Force SD bus */
+ config.devices_to_enumerate[0][0] = CyFalse;
+ config.devices_to_enumerate[1][0] = CyTrue ;
+ /* No MSC in Turbo */
+ config.mass_storage_interface = 0 ;
+ config.mtp_interface = 1 ;
+ }
+ else
+ {
+ /* not Turbo here */
+ config.mtp_interface = 0 ;
+
+#ifndef DEBUG_MSC
+ config.mass_storage_interface = 0 ;
+ config.mass_storage_callbacks = CyFalse ;
+#else
+ /* Force SD bus */
+ config.devices_to_enumerate[1][0] = CyTrue ;
+ config.mass_storage_interface = 1 ;
+ config.mass_storage_callbacks = CyTrue ;
+#endif
+ }
+ ret = CyAsUsbSetEnumConfig(h, &config, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbSetEnumConfigMS failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+#ifndef DEBUG_MSC
+ /*
+ * Step 5: set physical configuration
+ */
+#ifdef DEBUG_ZERO
+ /*nxz-debug-z ret = CyAsUsbSetPhysicalConfiguration(h, 5) ;*/
+ ret = CyAsUsbSetPhysicalConfiguration(h, 1) ;
+#else
+ ret = CyAsUsbSetPhysicalConfiguration(h, 5) ;
+#endif
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbSetPhysicalConfiguration failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ /*
+ * Step 5: Commit the endpoint configuration
+ */
+#ifdef DEBUG_ZERO
+ epconfig.enabled = CyTrue ;
+ epconfig.dir = CyAsUsbOut ;
+ epconfig.type = CyAsUsbBulk ;
+ epconfig.size = 0 ;
+ epconfig.physical = 1 ;
+ ret = CyAsUsbSetEndPointConfig(h, 3, &epconfig) ;
+ if ( ret != CY_AS_ERROR_SUCCESS )
+ {
+ CyAsHalPrintMessage("CyAsUsbSetEndPointConfig failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ epconfig.enabled = CyTrue ;
+ epconfig.dir = CyAsUsbIn ;
+ epconfig.type = CyAsUsbBulk ;
+ epconfig.size = 0 ;
+ epconfig.physical = 3 ;
+ ret = CyAsUsbSetEndPointConfig(h, 5, &epconfig) ;
+ if ( ret != CY_AS_ERROR_SUCCESS )
+ {
+ CyAsHalPrintMessage("CyAsUsbSetEndPointConfig failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ /*nxz-debug-z */
+ epconfig.enabled = CyTrue ;
+ epconfig.dir = CyAsUsbIn ;
+ epconfig.type = CyAsUsbInt ;
+ epconfig.size = 64 ;
+ epconfig.physical = 2 ;
+ ret = CyAsUsbSetEndPointConfig(h, 7, &epconfig) ;
+ if ( ret != CY_AS_ERROR_SUCCESS )
+ {
+ CyAsHalPrintMessage("CyAsUsbSetEndPointConfig failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+#endif
+
+ /*
+ * This code commits the endpoint configuration to the West Bridge hardware.
+ */
+ ret = CyAsUsbCommitConfig(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbCommitConfig failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+#endif
+ /*
+ * Step 6: Connect to the USB host.
+ *
+ * This code actually connects the D+ and D- signals internal to West Bridge to the D+ and D- pins
+ * on the device. If the host is already physically connected, this will begin the enumeration
+ * process. Otherwise, the enumeration process will being when the host is connected.
+ */
+ ret = CyAsUsbConnect(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("CyAsUsbConnect failed with error code %d\n", ret) ;
+ return 0 ;
+ }
+
+ CyAsHalPrintMessage("*** SetupUSBPPort...Done\n") ;
+ return 1 ;
+}
+
+/*
+* Print a block of data, useful for displaying data during debug.
+*/
+static void PrintData(const char *name_p, uint8_t *data, uint16_t size)
+{
+ uint32_t i = 0 ;
+ uint32_t linecnt = 0 ;
+
+ while (i < size)
+ {
+ if (linecnt == 0)
+ CyAsHalPrintMessage("%s @ %02x:", name_p, i) ;
+
+ CyAsHalPrintMessage(" %02x", data[i]) ;
+
+ linecnt++ ;
+ i++ ;
+
+ if (linecnt == 16)
+ {
+ CyAsHalPrintMessage("\n") ;
+ linecnt = 0 ;
+ }
+ }
+
+ if (linecnt != 0)
+ CyAsHalPrintMessage("\n") ;
+}
+
+/*
+* This is the write callback for writes that happen as part of the setup operation.
+*/
+static void SetupWriteCallback(CyAsDeviceHandle h, CyAsEndPointNumber_t ep, uint32_t count, void *buf_p, CyAsReturnStatus_t status)
+{
+ (void)count ;
+ (void)h ;
+ (void)buf_p ;
+
+ /*assert(ep == 0) ;
+ assert(buf_p == replybuf) ;*/
+
+ RestoreReplyArea() ;
+ if (status != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("Error returned in SetupWriteCallback - %d\n", status) ;
+
+ gSetupPending = CyFalse ;
+}
+
+static CyAsReturnStatus_t
+SetupWrite(CyAsDeviceHandle h, uint32_t requested, uint32_t dsize, void *data)
+{
+ CyBool spacket = CyTrue ;
+
+ if (requested == dsize)
+ spacket = CyFalse ;
+
+ return CyAsUsbWriteDataAsync(h, 0, dsize, data, spacket, SetupWriteCallback) ;
+}
+
+int mystrlen(char* str)
+{
+ int len = 0 ;
+
+ while( str && (*str != '\0') )
+ {
+ len++;
+ str++;
+ }
+
+ return len ;
+}
+/*
+* Send the USB host a string descriptor. If the index is zero, send the
+* array of supported languages, otherwise send the string itself per the USB
+* Ch9 specification.
+*/
+static void SendStringDescriptor(CyAsDeviceHandle h, uint8_t *data)
+{
+ CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS;
+ int i = data[2] ;
+ int langid = data[4] | (data[5] << 8) ;
+ uint16_t reqlen = data[6] | (data[7] << 8) ;
+
+ CyAsHalPrintMessage("**** CY_CH9_GD_STRING - %d\n", i) ;
+ if (i == 0)
+ {
+ uint8_t *reply ;
+
+ reply = GetReplyArea() ;
+ reply[0] = 4 ;
+ reply[1] = CY_CH9_GD_STRING ;
+ reply[2] = CY_CH9_LANGID_ENGLISH_UNITED_STATES & 0xff ;
+ reply[3] = (CY_CH9_LANGID_ENGLISH_UNITED_STATES >> 8) & 0xff ;
+ ret = SetupWrite(h, reqlen, 4, reply) ;
+ }
+ else if (i <= sizeof(UsbStrings)/sizeof(UsbStrings[0]) && langid == CY_CH9_LANGID_ENGLISH_UNITED_STATES)
+ {
+ uint8_t *reply ;
+ uint16_t len = (uint16_t)mystrlen(UsbStrings[i - 1]) ;
+
+ CyAsHalPrintMessage("*** Sending string '%s'\n", UsbStrings[i - 1]) ;
+
+ reply = GetReplyArea() ;
+ reply[0] = (uint8_t)(len * 2 + 2) ;
+ reply[1] = CY_CH9_GD_STRING ;
+ /* nxz-linux-port */
+ /*memcpy(reply + 2, UsbStrings[i - 1], len ) ;
+ ret = SetupWrite(h, reqlen, len + 2, reply) ;*/
+ {
+ uint16_t index ;
+ uint16_t *rpy = (uint16_t *)(reply + 2) ;
+ for (index = 0; index < len; index++)
+ {
+ *rpy = (uint16_t)(UsbStrings[i - 1][index]) ;
+ rpy++ ;
+ }
+ }
+ ret = SetupWrite(h, reqlen, len * 2 + 2, reply) ;
+ }
+ else
+ {
+ /*
+ * If the host asks for an invalid string, we must stall EP 0
+ */
+ ret = CyAsUsbSetStall(h, 0, StallCallback, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("**** cannot set stall state on EP 0\n") ;
+
+ CyAsHalPrintMessage("Host asked for invalid string or langid, index = 0x%04x, langid = 0x%04x\n", i, langid) ;
+ }
+
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ else
+ CyAsHalPrintMessage("** Write Sucessful\n") ;
+}
+
+static CyAsReturnStatus_t
+SendSetupData(CyAsDeviceHandle h, uint32_t reqlen, uint32_t size, void *data_p)
+{
+ CyAsReturnStatus_t ret ;
+ uint8_t *reply ;
+
+ /*
+ * Never send more data than was requested
+ */
+ if (size > reqlen)
+ size = reqlen ;
+
+ reply = GetReplyArea() ;
+ /*assert(reply != 0) ;*/
+
+ memcpy(reply, data_p, size) ;
+ ret = SetupWrite(h, reqlen, size, reply) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ RestoreReplyArea() ;
+
+ return ret ;
+}
+
+/*
+* This function processes the GET DESCRIPTOR usb request.
+*/
+static void ProcessGetDescriptorRequest(CyAsDeviceHandle h, uint8_t *data)
+{
+ CyAsReturnStatus_t ret ;
+ uint16_t reqlen = data[6] | (data[7] << 8) ;
+
+ if (data[3] == CY_CH9_GD_DEVICE)
+ {
+ /*
+ * Return the device descriptor
+ */
+ CyAsHalPrintMessage("**** CY_CH9_GD_DEVICE (size = %d)\n", sizeof(pport_device_desc)) ;
+ PrintData("DD", (uint8_t *)&pport_device_desc, sizeof(pport_device_desc)) ;
+
+ ret = SendSetupData(h, reqlen, sizeof(pport_device_desc), &pport_device_desc) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ else
+ CyAsHalPrintMessage("** Write Sucessful\n") ;
+ }
+ else if (data[3] == CY_CH9_GD_DEVICE_QUALIFIER)
+ {
+ /*
+ * Return the device descriptor
+ */
+ CyAsHalPrintMessage("**** CY_CH9_GD_DEVICE (size = %d)\n", sizeof(device_qualifier)) ;
+ PrintData("DD", (uint8_t *)&device_qualifier, sizeof(device_qualifier)) ;
+
+ ret = SendSetupData(h, reqlen, sizeof(device_qualifier), &device_qualifier) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ else
+ CyAsHalPrintMessage("** Write Sucessful\n") ;
+ }
+ else if (data[3] == CY_CH9_GD_CONFIGURATION)
+ {
+ const char *desc_name_p ;
+ uint16_t size ;
+
+ /*
+ * Return the CONFIGURATION descriptor.
+ */
+ if (desc_p == (CyCh9ConfigurationDesc *)&ConfigHSDesc)
+ {
+ desc_name_p = "HighSpeed" ;
+ size = sizeof(ConfigHSDesc) ;
+ }
+ else if (desc_p == (CyCh9ConfigurationDesc *)&ConfigFSDesc)
+ {
+ desc_name_p = "FullSpeed" ;
+ size = sizeof(ConfigFSDesc) ;
+ }
+ else if (desc_p == &ZeroDesc)
+ {
+ desc_name_p = "ZeroDesc" ;
+ size = sizeof(ZeroDesc) ;
+ }
+ else
+ {
+ desc_name_p = "UNKNOWN" ;
+ size = 0 ;
+ }
+ CyAsHalPrintMessage("**** CY_CH9_GD_CONFIGURATION - %s (size = %d)\n", desc_name_p, size) ;
+ if (size > 0)
+ {
+ PrintData("CFG", (uint8_t *)desc_p, size) ;
+ desc_p->bDescriptorType = CY_CH9_GD_CONFIGURATION;
+ ret = SendSetupData(h, reqlen, size, desc_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ else
+ CyAsHalPrintMessage("** Write Sucessful\n") ;
+ }
+ }
+ else if (data[3] == CY_CH9_GD_OTHER_SPEED_CONFIGURATION)
+ {
+ const char *desc_name_p ;
+ uint16_t size ;
+
+ /*
+ * Return the CONFIGURATION descriptor.
+ */
+ if (other_p == (CyCh9ConfigurationDesc *)&ConfigHSDesc)
+ {
+ desc_name_p = "HighSpeed" ;
+ size = sizeof(ConfigHSDesc) ;
+ }
+ else if (other_p == (CyCh9ConfigurationDesc *)&ConfigFSDesc)
+ {
+ desc_name_p = "FullSpeed" ;
+ size = sizeof(ConfigFSDesc) ;
+ }
+ else if (other_p == &ZeroDesc)
+ {
+ desc_name_p = "ZeroDesc" ;
+ size = sizeof(ZeroDesc) ;
+ }
+ else
+ {
+ desc_name_p = "UNKNOWN" ;
+ size = 0 ;
+ }
+ CyAsHalPrintMessage("**** CY_CH9_GD_OTHER_SPEED_CONFIGURATION - %s (size = %d)\n", desc_name_p, size) ;
+ if (size > 0)
+ {
+ PrintData("CFG", (uint8_t *)other_p, size) ;
+ other_p->bDescriptorType = CY_CH9_GD_OTHER_SPEED_CONFIGURATION;
+ ret = SendSetupData(h, reqlen, size, other_p) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ else
+ CyAsHalPrintMessage("** Write Sucessful\n") ;
+ }
+ }
+ else if (data[3] == CY_CH9_GD_STRING)
+ {
+ SendStringDescriptor(h, data) ;
+ }
+ else if (data[3] == CY_CH9_GD_REPORT)
+ {
+ CyAsHalPrintMessage("**** CY_CH9_GD_REPORT\n") ;
+ }
+ else if (data[3] == CY_CH9_GD_HID)
+ {
+ CyAsHalPrintMessage("**** CY_CH9_GD_HID\n") ;
+ }
+ else
+ {
+ CyAsHalPrintMessage("**** Unknown Descriptor request\n") ;
+ }
+}
+
+/*
+static void EP0DataCallback(CyAsDeviceHandle h, CyAsEndPointNumber_t ep, uint32_t count, void *buf_p, CyAsReturnStatus_t status)
+{
+ (void)ep ;
+ (void)h ;
+
+ if (status == CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("Read data phase of setup packet from EP0\n") ;
+ PrintData("SetupData", buf_p, (uint16_t)count) ;
+ }
+ else
+ {
+ CyAsHalPrintMessage("Error reading data from EP0\n") ;
+ }
+}
+*/
+
+static void
+ProcessSetupPacketRequest(CyAsDeviceHandle h, uint8_t *data)
+{
+ CyAsReturnStatus_t ret ;
+ uint16_t reqlen = data[6] | (data[7] << 8) ;
+
+ RestoreReplyArea() ;
+
+ if ((data[0] & CY_CH9_SETUP_TYPE_MASK) == CY_CH9_SETUP_STANDARD_REQUEST)
+ {
+ switch(data[1])
+ {
+ case CY_CH9_SC_GET_DESCRIPTOR:
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_GET_DESCRIPTOR request\n") ;
+ ProcessGetDescriptorRequest(h, data) ;
+ break ;
+
+ case CY_CH9_SC_GET_INTERFACE:
+ {
+ uint8_t *response = GetReplyArea() ;
+
+ *response = 0 ;
+ CyAsHalPrintMessage("************* USB EP0: CY_CH9_SC_GET_INTERFACE request - RETURNING ZERO\n") ;
+ ret = SetupWrite(h, reqlen, 1, response) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ }
+ }
+ break ;
+
+ case CY_CH9_SC_SET_INTERFACE:
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_SET_INTERFACE request\n") ;
+ break ;
+
+ case CY_CH9_SC_SET_CONFIGURATION:
+ {
+ /*CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS ;*/
+
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_SET_CONFIGURATION request (%02x)\n", data[2]) ;
+ {
+ gAsyncStallDone = CyFalse ;
+ gAsyncStallStale = 0;
+ CyAsUsbSetStall(h, 3, StallCallbackEX, 18);
+ }
+ gSetConfig = CyTrue ;
+ g_pAstDevice->configDone = 1 ;
+ MyConfiguration = data[2];
+
+ /* Set configuration is the last step before host send MTP data to EP2 */
+#if 0
+ ret = CyAsUsbReadDataAsync(g_pAstDevice->astDevHandle,
+ CY_AS_MTP_BULK_OUT_EP, CyFalse, 512,
+ g_pAstDevice->astEPBuf, TmtpReadCallback) ;
+ if(ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_ASYNC_PENDING)
+ {
+ /*handle error in reading*/
+ CyAsHalPrintMessage("CyAsMtpApp: CyAsUsbReadDataAsync Failed. Reason code: %d\n",ret) ;
+ return ;
+ }
+#endif
+ }
+ break ;
+
+ case CY_CH9_SC_GET_CONFIGURATION:
+ {
+ uint8_t *response = GetReplyArea() ;
+
+ *response = MyConfiguration ;
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_GET_INTERFACE request\n") ;
+ ret = SetupWrite(h, reqlen, 1, response) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ }
+ }
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_GET_CONFIGURATION request\n") ;
+ break ;
+
+ case CY_CH9_SC_GET_STATUS:
+ {
+ uint16_t *response = (uint16_t *)GetReplyArea() ;
+
+ *response = 0 ;
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_GET_STATUS request\n") ;
+ ret = SetupWrite(h, reqlen, 2, response) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("****** ERROR WRITING USB DATA - %d\n", ret) ;
+ }
+ }
+ break ;
+
+ case CY_CH9_SC_CLEAR_FEATURE:
+ {
+ uint16_t feature = data[2] | (data[3] << 8) ;
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_CLEAR_FEATURE request\n") ;
+
+ if ((data[0] & CY_CH9_SETUP_DEST_MASK) == CY_CH9_SETUP_DEST_ENDPOINT && feature == 0)
+ {
+ CyAsEndPointNumber_t ep = data[4] | (data[5] << 8) ;
+ /* This is a clear feature/endpoint halt on an endpoint */
+ CyAsHalPrintMessage("Calling ClearStall on EP %d\n", ep) ;
+ ret = CyAsUsbClearStall(h, ep, StallCallback, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("******* ERROR SEND CLEAR STALL REQUEST - %d\n", ret) ;
+ }
+ }
+ }
+ break ;
+
+ case CY_CH9_SC_SET_FEATURE:
+ {
+ uint16_t feature = data[2] | (data[3] << 8) ;
+ CyAsHalPrintMessage("USB EP0 : CY_CH9_SC_SET_FEATURE request\n") ;
+
+ if ((data[0] & CY_CH9_SETUP_DEST_MASK) == CY_CH9_SETUP_DEST_ENDPOINT && feature == 0)
+ {
+ CyAsEndPointNumber_t ep = data[4] | (data[5] << 8) ;
+ /* This is a clear feature/endpoint halt on an endpoint */
+ CyAsHalPrintMessage("Calling SetStall on EP %d\n", ep) ;
+ ret = CyAsUsbSetStall(h, ep, StallCallback, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("******* ERROR SEND SET STALL REQUEST - %d\n", ret) ;
+ }
+ }
+ }
+ break;
+ }
+ }
+ else if ((data[0] & CY_CH9_SETUP_TYPE_MASK) == CY_CH9_SETUP_CLASS_REQUEST)
+ {
+ /*
+ * Handle class requests other than Mass Storage
+ */
+ ret = CyAsUsbSetStall(h, 0, StallCallback, 0) ;
+ CyAsHalPrintMessage("Sending stall request\n") ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ CyAsHalPrintMessage("**** cannot set stall state on EP 0\n") ;
+ }
+ else
+ {
+ static char buf[1024] ;
+
+ if ((data[0] & 0x80) == 0)
+ {
+ if (reqlen != 0)
+ {
+ CyAsHalPrintMessage("OUT setup request with additional data\n") ;
+ /* This is an OUT setup request, with additional data to follow */
+ /*ret = CyAsUsbReadDataAsync(h, 0, CyFalse, reqlen, buf, EP0DataCallback) ;
+ if(ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_ASYNC_PENDING)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: CyAsUsbReadDataAsync Failed. Reason code: %d\n",ret) ;
+ }*/
+ }
+ else
+ {
+ CyAsHalPrintMessage("Call setnak\n") ;
+ ret = CyAsUsbSetNak(h, 3, StallCallback, 1) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("Error in CyAsUsbSetNak - %d\n", ret) ;
+ }
+ }
+ }
+ else
+ {
+ if (reqlen != 0)
+ {
+ /*
+ * This is an unknown setup packet, probably some type of generated packet or a class
+ * packet we do not understand. We just send back some data.
+ */
+ CyAsHalMemSet(buf, 0x44, sizeof(buf)) ;
+ ret = SendSetupData(h, reqlen, reqlen, buf) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("Error ending setup data in response to unknown packet\n") ;
+ }
+ else
+ {
+ CyAsHalPrintMessage("Sent setup data associated with the unknown setup packet\n") ;
+ }
+ }
+ else
+ {
+ CyAsHalPrintMessage("Call setnak\n") ;
+ ret = CyAsUsbSetNak(h, 3, StallCallback, 1) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("Error in CyAsUsbSetNak - %d\n", ret) ;
+ }
+ }
+ }
+ }
+}
+
+static void
+MyUsbEventCallbackMS(CyAsDeviceHandle h, CyAsUsbEvent ev, void *evdata)
+{
+ CyAsHalPrintMessage("------------------------------ IN -------------------------------------\n") ;
+ switch(ev)
+ {
+ case CyAsEventUsbSuspend:
+ CyAsHalPrintMessage("CyAsEventUsbSuspend received\n") ;
+ break ;
+ case CyAsEventUsbResume:
+ {
+ /*CyAsReturnStatus_t ret = CY_AS_ERROR_SUCCESS;*/
+ CyAsHalPrintMessage("CyAsEventUsbResume received\n") ;
+ /*ret = CyAsUsbReadDataAsync(g_pAstDevice->astDevHandle, CY_AS_MTP_BULK_OUT_EP,
+ CyFalse, 512, g_pAstDevice->astEPBuf,
+ TmtpReadCallback) ;
+
+ if(ret != CY_AS_ERROR_SUCCESS && ret != CY_AS_ERROR_ASYNC_PENDING)
+ {
+ CyAsHalPrintMessage("CyAsMtpApp: CyAsUsbReadDataAsync Failed. Reason code: %d\n",ret) ;
+ return ;
+ }*/
+ }
+ break ;
+ case CyAsEventUsbReset:
+#ifdef DEBUG_ZERO
+ desc_p = (CyCh9ConfigurationDesc *)&ConfigFSDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ConfigHSDesc ;
+#else
+ desc_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+#endif
+ CyAsHalPrintMessage("CyAsEventUsbReset received\n") ;
+ break ;
+ case CyAsEventUsbSpeedChange:
+
+#ifdef DEBUG_ZERO
+ desc_p = (CyCh9ConfigurationDesc *)&ConfigHSDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ConfigFSDesc ;
+#else
+ desc_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+ other_p = (CyCh9ConfigurationDesc *)&ZeroDesc ;
+#endif
+ CyAsHalPrintMessage("CyAsEventUsbSpeedChange received\n") ;
+ break ;
+ case CyAsEventUsbSetConfig:
+ CyAsHalPrintMessage("CyAsEventUsbSetConfig received\n") ;
+ gSetConfig = CyTrue ;
+ break ;
+ case CyAsEventUsbSetupPacket:
+ PrintData("CyAsEventUsbSetupPacket received: ", (uint8_t*)evdata, 8) ;
+ ProcessSetupPacketRequest(h, (uint8_t *)evdata) ;
+ break ;
+ case CyAsEventUsbStatusPacket:
+ CyAsHalPrintMessage("CyAsEventUsbStatusPacket received\n") ;
+ break ;
+ case CyAsEventUsbInquiryBefore:
+ CyAsHalPrintMessage("CyAsEventUsbInquiryBefore received\n") ;
+ {
+ CyAsUsbInquiryData *data = (CyAsUsbInquiryData *)evdata ;
+ data->updated = CyTrue ;
+ data = data ;
+ }
+ break ;
+ case CyAsEventUsbInquiryAfter:
+ CyAsHalPrintMessage("CyAsEventUsbInquiryAfter received\n") ;
+ break ;
+ case CyAsEventUsbStartStop:
+ CyAsHalPrintMessage("CyAsEventUsbStartStop received\n") ;
+ {
+ CyAsUsbStartStopData *data = (CyAsUsbStartStopData *)evdata ;
+ data = data ;
+ }
+ break ;
+ default:
+ break;
+ }
+ CyAsHalPrintMessage("------------------------------ OUT -------------------------------------\n") ;
+}
+
+
+int CyAsSymbianStorageTest(const char *pgm, CyAsDeviceHandle h, CyAsHalDeviceTag tag)
+{
+ CyAsReturnStatus_t ret ;
+ uint32_t count = 0 ;
+ char *media_name = "SD";
+
+ g_tag = tag ;
+ memset(g_pAstDevice,0, sizeof(g_AstDevice));
+ g_pAstDevice->astHalTag = tag ;
+ g_pAstDevice->astDevHandle = h ;
+
+ /*
+ * Give a delay to allow any equipment to be ready (e.g. CATC)
+ */
+ /*CyAsHalPrintMessage("Press enter to begin USB operation (%s): ", "P Port Enumeration") ;
+ fgets(buffer, sizeof(buffer), stdin) ;*/
+
+ CyAsHalPrintMessage("*** CyAsStorageStart...\n") ;
+ ret = CyAsStorageStart(h, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: CyAsStorageStart returned error code %d\n", pgm, ret) ;
+ return 0 ;
+ }
+
+ CyAsHalPrintMessage("*** CyAsStorageQueryMedia...\n") ;
+ ret = CyAsStorageQueryMedia(h, CyAsMediaSDFlash, &count, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot query %s device count - Reason code %d\n", pgm, media_name, ret) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("%d %s device(s) found\n", count, media_name) ;
+
+ CyAsHalPrintMessage("*** CyAsStorageClaim...\n") ;
+ ret = CyAsStorageClaim(h, CyAsBus_1, 0, 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot claim %s media - Reason code %d\n", pgm, media_name, ret) ;
+ return 0;
+ }
+
+ /* We know that there is only one */
+ g_pAstDevice->dev_data.bus = CyAsBus_1 ;
+ g_pAstDevice->dev_data.device = 0 ;
+ ret = CyAsStorageQueryDevice(h, &(g_pAstDevice->dev_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot query %s device - Reason code %d\n", pgm, media_name, ret) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("blocksize %d, %d units found\n",
+ g_pAstDevice->dev_data.desc_p.block_size, g_pAstDevice->dev_data.desc_p.number_units) ;
+
+ g_pAstDevice->unit_data.bus = CyAsBus_1 ;
+ g_pAstDevice->unit_data.device = 0 ;
+ g_pAstDevice->unit_data.unit = 0 ;
+ /* We know that there is only one */
+ ret = CyAsStorageQueryUnit(h, &(g_pAstDevice->unit_data), 0, 0) ;
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot query %s device unit - Reason code %d\n", pgm, media_name, ret) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("blocksize %d, %d Block(s) found\n",
+ g_pAstDevice->unit_data.desc_p.block_size, g_pAstDevice->unit_data.desc_p.unit_size) ;
+
+
+ {
+ int i = 0 , j;
+ char buf[512] = {0} ;
+ char expBuf[512] = {0} ;
+ memset(buf, 0xa5, 512);
+ memset(expBuf, 0xa5, 512);
+
+ CyAsHalPrintMessage("Read SD card\n");
+ ret = CyAsStorageRead( h, 1, 0, 0, 0, buf, 1);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot read first sector of SD card\n", pgm) ;
+ return 0 ;
+ }
+ CyAsHalPrintMessage("Read Result\n");
+ for ( i = 0 ; i < 512; i++ )
+ {
+ if ( (i != 0 ) && (i % 16 == 0))
+ {
+
+ CyAsHalPrintMessage("\t");
+ for ( j = 0 ; j < 16 ; j++ )
+ {
+ if ( (buf[i+j] > 32) && (buf[i+j] < 127))
+ {
+ CyAsHalPrintMessage("%c",buf[i+j]);
+ }
+ else
+ {
+ CyAsHalPrintMessage(".");
+ }
+ }
+ CyAsHalPrintMessage("\n");
+ }
+ CyAsHalPrintMessage("%02x ",buf[i]);
+ }
+ CyAsHalPrintMessage("\n");
+
+ ret = CyAsStorageWrite(h, 1, 0, 0, 0, expBuf, 1);
+ if ( ret != CY_AS_ERROR_SUCCESS )
+ {
+ CyAsHalPrintMessage("%s: Cannot write to first sector of SD card\n",pgm) ;
+ return 0 ;
+ }
+
+ memset(buf, 0xa5, 512);
+ ret = CyAsStorageRead(h, 1, 0, 0, 0, buf, 1);
+ if (ret != CY_AS_ERROR_SUCCESS)
+ {
+ CyAsHalPrintMessage("%s: Cannot read first sector of SD card\n",pgm) ;
+ return 0 ;
+ }
+
+ for ( i = 0 ; i < 512; i++ )
+ {
+ if ( buf[i] != expBuf[i] )
+ {
+
+ CyAsHalPrintMessage("EXP[%d]: 0x%02x",i,expBuf[i]);
+ CyAsHalPrintMessage("ACT[%d]: 0x%02x",i,buf[i]);
+ }
+ }
+ }
+
+
+ return 1 ;
+}
+
+int CyAsAPIGetHandle( CyAsDeviceHandle h, CyAsHalDeviceTag tag)
+{
+ g_tag = tag ;
+ memset(g_pAstDevice,0, sizeof(g_AstDevice));
+ g_pAstDevice->astHalTag = tag ;
+ g_pAstDevice->astDevHandle = h ;
+
+ return 1 ;
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/drivers/cyasusbinit.h Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,56 @@
+
+#ifndef ASTORIAUSBINIT_H
+#define ASTORIAUSBINIT_H
+
+/* The BUS bits */
+#define CY_TEST_BUS_0 (0x01)
+#define CY_TEST_BUS_1 (0x02)
+
+typedef struct TmtpAstDev
+{
+ CyAsHalDeviceTag astHalTag;
+ CyAsDeviceHandle astDevHandle;
+
+ /* EP related stats */
+ volatile uint8_t astEPDataAvail;
+ uint32_t astEPBuflength;
+ uint8_t astEPBuf[512];
+
+ /* Current Transaction Id */
+ uint32_t tId ;
+
+ /* Data members to be used by user-implemented MTPEventCallback() via the relevant interface methods */
+ volatile CyBool tmtpSendComplete;
+ volatile CyBool tmtpGetComplete;
+ volatile CyBool tmtpNeedNewBlkTbl;
+ CyAsStorageQueryDeviceData dev_data;
+ CyAsStorageQueryUnitData unit_data;
+ /* Data member used to store the SendObjectComplete event data */
+ CyAsMTPSendObjectCompleteData tmtpSendCompleteData;
+
+ /* Data member used to store the GetObjectComplete event data */
+ CyAsMTPGetObjectCompleteData tmtpGetCompleteData;
+
+ uint8_t configDone ;
+} TmtpAstDev;
+
+
+int
+CyAsAPIUsbInit(
+ const char *pgm,
+ CyAsDeviceHandle h,
+ CyAsHalDeviceTag tag);
+
+int
+CyAsSymbianStorageTest(
+ const char *pgm,
+ CyAsDeviceHandle h,
+ CyAsHalDeviceTag tag);
+
+int
+CyAsAPIGetHandle(
+ CyAsDeviceHandle h,
+ CyAsHalDeviceTag tag);
+
+
+#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/wb.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,37 @@
+// Copyright (c) 1994-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:
+// omap3530/beagle_drivers/led/led.cpp
+//
+
+#include <kern_priv.h>
+#include <beagle/beagle_gpio.h>
+#include <beagle/variant.h>
+#include <assp/omap3530_assp/omap3530_assp_priv.h>
+#include <assp/omap3530_assp/omap3530_irqmap.h> // GPIO interrupts
+#include <assp/omap3530_assp/omap3530_gpio.h>
+
+#include <assp.h> // Required for definition of TIsr
+
+#include <cyashalbeagleboard.h>
+
+DECLARE_STANDARD_EXTENSION()
+ {
+
+ CyAsHalAstoriaInit();
+ return KErrNone;
+ }
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omap3530/beagle_drivers/wb/wb.mmp Wed Mar 03 13:10:32 2010 +0000
@@ -0,0 +1,80 @@
+// ===========================
+//
+// Copyright Cypress Semiconductor Corporation, 2006-2009,
+// All Rights Reserved
+// UNPUBLISHED, LICENSED SOFTWARE.
+//
+// CONFIDENTIAL AND PROPRIETARY INFORMATION
+// WHICH IS THE PROPERTY OF CYPRESS.
+//
+// ===========================
+//
+// Description:
+// oamp3530/beagle_drivers/wb/wb.mmp
+// wb.dll Beagle WB driver
+//
+
+
+
+/**
+ @file
+*/
+#define __USING_ASSP_REGISTER_API__
+#define __USING_ASSP_INTERRUPT_API__
+
+#include "beagle/variant.mmh"
+#include "kernel/kern_ext.mmh"
+
+USERINCLUDE ./api/include
+USERINCLUDE ./api/hal
+USERINCLUDE ./api/src
+USERINCLUDE ./drivers
+
+//target VariantTarget(wb,dll)
+target wb.dll
+targettype kext
+romtarget wb.dll
+
+macro CY_DEFINE_BASIC_TYPES
+macro __CY_ASTORIA_BEAGLEBOARD_SPI__HAL__
+macro DEBUG_ZERO
+macro DEBUG_MSC
+//macro FIRMWARE_NOPPORT
+//macro HW_TEST
+macro OVERCLOCK_SD
+
+sourcepath .
+
+source ./api/src/cyasdma.c
+source ./api/src/cyaslep2pep.c
+source ./api/src/cyaslowlevel.c
+source ./api/src/cyasmisc.c
+source ./api/src/cyasmtp.c
+source ./api/src/cyasstorage.c
+source ./api/src/cyasusb.c
+source ./api/src/cyasintr.c
+source ./api/hal/cyashalbeagleboard_spi.cpp
+source ./api/hal/cyashalbeagleboard.cpp
+source ./drivers/CyAsSymbianStorageDriver.cpp
+source ./drivers/cyasusbinit.cpp
+source wb.cpp
+
+library VariantTarget(ecust,lib)
+library AsspTarget(gpio,lib)
+library AsspTarget(prcm,lib)
+
+deffile ./def/~/wb.def
+
+start wins
+win32_headers
+end
+
+epocallowdlldata
+
+UID 0x10004379 0x10005742
+VENDORID 0x70000001
+
+capability all
+
+SMPSAFE
+
--- a/omap3530/beagleboard/rom/kernel.iby Tue Feb 16 21:57:56 2010 +0000
+++ b/omap3530/beagleboard/rom/kernel.iby Wed Mar 03 13:10:32 2010 +0000
@@ -36,6 +36,9 @@
extension[VARID]= \Epoc32\Release\ARMV5\##BUILD##\_omap3530_GPIO.DLL \sys\bin\gpio.dll
//extension[VARID]= \epoc32\release\ARMV5\##BUILD##\_##VARIANT##_LED.DLL \sys\bin\led.dll
+// Uncommnet to include West Bridge Astoria Symbian Storage driver
+//extension[VARID]= \epoc32\release\ARMV5\##BUILD##\_##VARIANT##_WB.DLL \sys\bin\wb.dll
+//extension[VARID]= \epoc32\release\ARMV5\##BUILD##\wb.dll \sys\bin\wb.dll
//extension[VARID]= \Epoc32\Release\ARMV5\##BUILD##\_##VARIANT##_resman.pdd \sys\bin\resman.pdd
//extension[VARID]= \Epoc32\Release\##KMAIN##\##BUILD##\resman.ldd \sys\bin\resman.ldd
@@ -64,6 +67,7 @@
file[VARID]= \epoc32\release\##KMAIN##\##BUILD##\_##VARIANT##_EKDATA.DLL \sys\bin\ekdata.dll
extension[VARID]= \epoc32\release\##KMAIN##\##BUILD##\ELOCD.LDD \sys\bin\elocd.ldd
extension[VARID]= \epoc32\release\ARMV5\##BUILD##\_##VARIANT##_MEDINT.PDD \sys\bin\medint.pdd
+// Uncommnet to include West Bridge Astoria Symbian Storage driver //extension[VARID]= \epoc32\release\ARMV5\##BUILD##\_##VARIANT##_MEDWB.PDD \sys\bin\medwb.pdd
device[VARID]= \epoc32\release\##KMAIN##\##BUILD##\PIPELIB.LDD \sys\bin\pipelib.ldd
extension[VARID]= \epoc32\release\##KMAIN##\##BUILD##\EXSTART.DLL \sys\bin\exstart.dll
--- a/omap3530/bld.inf Tue Feb 16 21:57:56 2010 +0000
+++ b/omap3530/bld.inf Wed Mar 03 13:10:32 2010 +0000
@@ -19,6 +19,10 @@
#include "beagle_drivers/keytran/bld.inf"
#include "beagle_drivers/lcd/bld.inf"
#include "beagle_drivers/led/bld.inf"
+//nxz
+#include "beagle_drivers/wb/bld.inf"
+//skkm
+#include "beagle_drivers/medwb/bld.inf"
// #include "beagle_drivers/prm/bld.inf"
#include "beagle_drivers/serialmouse/bld.inf"
#include "beagle_drivers/usbv/bld.inf"
--- a/omap3530/omap3530_drivers/prcm/prcm.cpp Tue Feb 16 21:57:56 2010 +0000
+++ b/omap3530/omap3530_drivers/prcm/prcm.cpp Wed Mar 03 13:10:32 2010 +0000
@@ -154,7 +154,7 @@
{ KCM_CLKSEL1_PLL_MPU, KBit19 | KBit20 | KBit21, EDivCore_1_2_4, 19 }, // EClkMpuPll_Bypass, ///< DPLL1 bypass frequency
{ KCM_CLKSEL1_PLL_IVA2, KBit19 | KBit20 | KBit21, EDivCore_1_2_4, 19 }, // EClkIva2Pll_Bypass, ///< DPLL2 bypass frequency
- { KCM_CLKSEL_WKUP, KBit1 | KBit2, EDiv_1_2, 1 }, // EClkRM_F, ///< Reset manager functional clock
+ { KCM_CLKSEL_WKUP, KBit1 | KBit2, EDiv_1_2, 1 }, // EClkRM_F, ///< Reset manager functional clock
{ KCM_CLKSEL3_PLL, 0x1F, EDivPll_1_To_16, 0 }, // EClk96M ///< 96MHz clock
{ KCM_CLKSEL5_PLL, 0x1F, EDivPll_1_To_16, 0 }, // EClk120M ///< 120MHz clock
{ KCM_CLKOUT_CTRL, KBit3 | KBit4 | KBit5, EDivClkOut_1_2_4_8_16, 3 }, // EClkSysOut
@@ -362,7 +362,7 @@
{ { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkMpuPll_Bypass, ///< DPLL1 bypass frequency
{ { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkIva2Pll_Bypass, ///< DPLL2 bypass frequency
- { { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkRM_F, ///< Reset manager functional clock
+ { { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkRM_F, ///< Reset manager functional clock
{ { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClk96M, ///< 96MHz clock
{ { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClk120M, ///< 120MHz clock
{ { KDummy, 0, 0, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkSysOut,
@@ -386,8 +386,8 @@
{ { KCM_FCLKEN1_CORE, KBit10, KBit10, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMcBSP5_F,
{ { KCM_FCLKEN1_CORE, KBit18, KBit18, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMcSpi1_F,
{ { KCM_FCLKEN1_CORE, KBit19, KBit19, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMcSpi2_F,
- { { KCM_FCLKEN1_CORE, KBit20, KBit20, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMcSpi3_F,
- { { KCM_FCLKEN1_CORE, KBit21, KBit21, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMcSpi4_F,
+ { { KCM_FCLKEN1_CORE, KBit20, KBit20, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkMcSpi3_F,
+ { { KCM_FCLKEN1_CORE, KBit21, KBit21, 0 }, { KDummy, 0, KDummyReadAsEnabled, 0 } }, // EClkMcSpi4_F,
{ { KCM_FCLKEN1_CORE, KBit15, KBit15, 0}, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkI2c1_F,
{ { KCM_FCLKEN1_CORE, KBit16, KBit16, 0}, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkI2c2_F,
{ { KCM_FCLKEN1_CORE, KBit17, KBit17, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkI2c3_F,
@@ -520,7 +520,7 @@
{ KDummy, 0, KDummyReadAsDisabled, 0 }, // EClkMpuPll_Bypass, ///< DPLL1 bypass frequency
{ KDummy, 0, KDummyReadAsDisabled, 0 }, // EClkIva2Pll_Bypass, ///< DPLL2 bypass frequency
- { KDummy, 0, KDummyReadAsDisabled, 0 }, // EClkRM_F, ///< Reset manager functional clock
+ { KDummy, 0, KDummyReadAsDisabled, 0 }, // EClkRM_F, ///< Reset manager functional clock
{ KDummy, 0, KDummyReadAsDisabled, 0 }, // EClk96M, ///< 96MHz clock
{ KDummy, 0, KDummyReadAsDisabled, 0 }, // EClk120M, ///< 120MHz clock
{ KDummy, 0, KDummyReadAsDisabled, 0 }, // EClkSysOut,
@@ -684,7 +684,7 @@
{ { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkMpuPll_Bypass, ///< DPLL1 bypass frequency
{ { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkIva2Pll_Bypass, ///< DPLL2 bypass frequency
- { { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkRM_F, ///< Reset manager functional clock
+ { { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkRM_F, ///< Reset manager functional clock
{ { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClk96M, ///< 96MHz clock
{ { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClk120M, ///< 120MHz clock
{ { KDummy, 0, KDummyReadAsDisabled, 0 }, { KDummy, 0, KDummyReadAsDisabled, 0 } }, // EClkSysOut,
@@ -860,7 +860,7 @@
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkMpuPll_Bypass, ///< DPLL1 bypass frequency
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkIva2Pll_Bypass, ///< DPLL2 bypass frequency
- { KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkRM_F, ///< Reset manager functional clock
+ { KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkRM_F, ///< Reset manager functional clock
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClk96M, ///< 96MHz clock
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClk120M, ///< 120MHz clock
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkSysOut,
@@ -993,7 +993,7 @@
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClk48M
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClk12M
-
+
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkSysClk
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkAltClk
{ KDummy, {-1, -1, -1, -1, -1, -1 } }, // EClkSysClk32k
@@ -1045,7 +1045,7 @@
{ KCM_CLKSEL_PER, KBit4 }, // EGpt6,
{ KCM_CLKSEL_PER, KBit5 }, // EGpt7,
{ KCM_CLKSEL_PER, KBit6 }, // EGpt8,
- { KCM_CLKSEL_PER, KBit7 }, // EGpt9,
+ { KCM_CLKSEL_PER, KBit7 }, // EGpt9,
{ KCM_CLKSEL_CORE, KBit6 }, // EGpt10,
{ KCM_CLKSEL_CORE, KBit7 }, // EGpt11,
{ KDummy, 0 }, // EGpt12 - clocked from security block
@@ -1152,7 +1152,7 @@
{ EDuplicate, Prcm::EClkSysClk32k }, // EClkGpio5_F,
{ EDuplicate, Prcm::EClkSysClk32k }, // EClkGpio6_F,
{ EDuplicate, Prcm::EClk120M }, // EClkUsb120_F,
- { EDuplicate, Prcm::EClk48M }, // EClkUsb48_F,
+ { EDuplicate, Prcm::EClk48M }, // EClkUsb48_F,
// Interface clocks
{ EDuplicate, Prcm::EClkL4Domain }, // EClkDss_I,
@@ -1692,7 +1692,7 @@
}
TInt irq = __SPIN_LOCK_IRQSAVE(iLock);
-
+
_BitClearSet( KPllMode[ aPll ].iModeRegister,
KPllModeMask << KPllMode[ aPll ].iModeShift,
newMode << KPllMode[ aPll ].iModeShift );
@@ -1700,7 +1700,7 @@
_BitClearSet( KPllMode[ aPll ].iAutoRegister,
KPllAutoMask << KPllMode[ aPll ].iAutoShift,
newAuto << KPllMode[ aPll ].iAutoShift );
-
+
__SPIN_UNLOCK_IRQRESTORE(iLock, irq);
}
@@ -1713,7 +1713,7 @@
TUint32 mode = (AsspRegister::Read32( KPllMode[ aPll ].iModeRegister ) >> KPllMode[ aPll ].iModeShift) bitand KPllModeMask;
TUint32 autoSet = (AsspRegister::Read32( KPllMode[ aPll ].iAutoRegister ) >> KPllMode[ aPll ].iAutoShift) bitand KPllAutoMask;
- static const TPllMode modeTable[8][2] =
+ static const TPllMode modeTable[8][2] =
{ // auto disabled auto enabled
{ EPllStop, EPllStop }, // not possible
{ EPllStop, EPllStop },
@@ -1879,7 +1879,7 @@
{
__KTRACE_OPT( KPRCM, Kern::Printf( "Prcm::PllBypassDivider(%x)", aPll ) );
__ASSERT_DEBUG( (TUint)aPll <= EDpll5, Panic( EPllBypassDividerBadPll ) );
-
+
TUint div = 1;
switch( aPll )
@@ -1917,7 +1917,7 @@
__ASSERT_DEBUG( (TUint)aClock < KSupportedClockCount, Panic( ESetDividerBadClock ) );
const TDividerInfo& inf = KDividerInfo[ aClock ];
-
+
TUint32 div = aDivide; // most common case, special cases handled below
switch( inf.iDivType )
@@ -2026,7 +2026,7 @@
}
// if we get here, we have a valid divider value
-
+
_LockedBitClearSet( inf.iRegister, inf.iMask, div << inf.iShift );
}
@@ -2037,7 +2037,7 @@
__ASSERT_DEBUG( (TUint)aClock < KSupportedClockCount, Panic( EGetDividerBadClock ) );
const TDividerInfo& inf = KDividerInfo[ aClock ];
-
+
TUint32 div = ( AsspRegister::Read32( inf.iRegister ) bitand inf.iMask ) >> inf.iShift;
TUint result = div; // most common case
@@ -2127,7 +2127,7 @@
__ASSERT_DEBUG( (TUint)aMode <= EPowerOn, Panic( ESetDomainModeBadMode ) );
__ASSERT_DEBUG( 0 != (KPowerDomainControl[ aDomain ].iAllowedMask bitand (1 << aMode)), Panic( ESetDomainModeUnsupportedMode ) );
-
+
TUint shift = KPowerDomainControl[ aDomain ].iShift;
_LockedBitClearSet( KPowerDomainControl[ aDomain ].iRegister,
@@ -2316,7 +2316,7 @@
const TWakeupDomainInfo& inf = KClockWakeupDomainTable[ aClock ];
TUint32 mask = 1 << (TUint)inf.iBitNumber[ aDomain ]; // unsupported bit numbers will result in a mask of 0x00000000
-
+
_LockedBitClearSet( inf.iRegister, KClearNone, mask );
}
@@ -2329,7 +2329,7 @@
const TWakeupDomainInfo& inf = KClockWakeupDomainTable[ aClock ];
TUint32 mask = 1 << (TUint)inf.iBitNumber[ aDomain ]; // unsupported bit numbers will result in a mask of 0x00000000
-
+
_LockedBitClearSet( inf.iRegister, mask, KSetNone );
}
@@ -2776,12 +2776,12 @@
div *= 4;
break;
}
-
+
currentClock = prevClock;
} // end do
// When we reach here we have worked back to the origin clock
-
+
TUint64 fSrc;
const Omap3530Assp* variant = (Omap3530Assp*)Arch::TheAsic();
@@ -2828,7 +2828,7 @@
/** Get the currently configured SysClk frequency */
EXPORT_C TSysClkFrequency SysClkFrequency()
{
-
+
switch( AsspRegister::Read32( KPRM_CLKSEL ) bitand (KBit0 | KBit1 | KBit2) )
{
case 0:
@@ -2945,13 +2945,19 @@
r = AsspRegister::Read32(KMCSPI3_SYSCONFIG);
__NK_ASSERT_ALWAYS((r & 1 << 3) == 0);
__NK_ASSERT_ALWAYS((r & 1 << 8) == 0);
+ /* nxz enable SPI 3
SetClockState( EClkMcSpi3_F, EClkOff );
- SetClockState( EClkMcSpi3_I, EClkOff );
+ SetClockState( EClkMcSpi3_I, EClkOff );*/
+ SetClockState( EClkMcSpi3_F, EClkOn );
+ SetClockState( EClkMcSpi3_I, EClkOn );
r = AsspRegister::Read32(KMCSPI4_SYSCONFIG);
__NK_ASSERT_ALWAYS((r & 1 << 3) == 0);
__NK_ASSERT_ALWAYS((r & 1 << 8) == 0);
+ /* nxz enable SPI 4
SetClockState( EClkMcSpi4_F, EClkOff );
- SetClockState( EClkMcSpi4_I, EClkOff );
+ SetClockState( EClkMcSpi4_I, EClkOff );*/
+ SetClockState( EClkMcSpi4_F, EClkOn );
+ SetClockState( EClkMcSpi4_I, EClkOn );
// UART
TInt debugport = Kern::SuperPage().iDebugPort;
@@ -3070,7 +3076,7 @@
__NK_ASSERT_ALWAYS((r & 1 << 8) == 0);
_BitClearSet(KCM_FCLKEN_WKUP, 1 << 3, 0);
_BitClearSet(KCM_ICLKEN_WKUP, 1 << 3, 0);
-
+
//r = AsspRegister::Read32(KGPIO2_SYSCONFIG);
//__NK_ASSERT_ALWAYS((r & 1 << 3) == 0);
//__NK_ASSERT_ALWAYS((r & 1 << 8) == 0);