#ifndef __ohci_h__
#define __ohci_h__

#include "type.h"
#include "ieee1394.h"
#include "b.h"

template <class type>
struct SetClear
{
	RelativeRef<type,0x0> set;
	RelativeRef<type,0x4> clear;
};

struct Ohci
{
	struct Version
	{
		Field<U32, 0, 8> revision;
		Field<U32,16, 8> version;
		Field<U32,24, 1> guidRom;
		U32 all;
	};
	RelativeRef<Version,0x000> version;
	struct GuidRom
	{
		Field<U32, 0, 8> miniRom;
		Field<U32,16, 8> rdData;
		Field<U32,25, 1> rdStart;
		Field<U32,31, 1> addrReset;
		U32 all;
	};
	RelativeRef<Version,0x004> guidRom;
	struct AtRetries
	{
		Field<U32, 0, 4> maxAtReqRetries;
		Field<U32, 4, 4> maxAtRespRetries;
		Field<U32, 8, 1> maxPhysRespRetries;
		Field<U32,16,13> cycleLimit;
		Field<U32,29, 3> secondLimit;
		U32 all;
	};
	RelativeRef<Version,0x008> atRetries;
	RelativeRef<U32,0x00c> csrData;
	RelativeRef<U32,0x010> csrCompare;
	struct CsrControl
	{
		static const U32 selBusManagerId=0;
		static const U32 selBandwidthAvailable=1;
		static const U32 selChannelAvailableHi=2;
		static const U32 selChannelAvailableLo=3;
		Field<U32, 0, 2> sel;
		Field<U32,31, 1> done;
		U32 all;
	};
	RelativeRef<CsrControl,0x014> csrControl;
	struct ConfigRomHeader
	{
		Field<U32, 0,16> romCrcValue;
		Field<U32,16, 8> crcLength;
		Field<U32,24, 8> infoLength;
		U32 all;
	};
	RelativeRef<CsrControl,0x018> configRomHeader;
	RelativeRef<U32,0x01c> busId;
	struct BusOptions
	{
		Field<U32, 0, 3> linkSpd;
		Field<U32,12, 4> maxRec;
		U32 all;
	};
	RelativeRef<BusOptions,0x020> busOptions;
	struct GlobalUniqueIdHi
	{
		Field<U32, 0, 8> chipIdHi;
		Field<U32, 8,24> nodeVendorId;
		U32 all;
	};
	RelativeRef<GlobalUniqueIdHi,0x024> globalUniqueIdHi;
	struct GlobalUniqueIdLo
	{
		Field<U32, 0,32> chipIdLo;
		U32 all;
	};
	RelativeRef<U32,0x028> globalUniqueIdLo;
	struct ConfigRomAddr
	{
		Field<U32, 0,10> aligned;
		Field<U32,10,22> configRomAddrHi;
		U32 all;
	};
	RelativeRef<ConfigRomAddr,0x034> configRomAddr;
	struct VendorId
	{
		Field<U32, 0,24> vendorCompanyId;
		Field<U32,24, 8> vendorUnique;
		U32 all;
	};
	RelativeRef<VendorId,0x040> vendorId;

	struct HcControl
	{
		Field<U32,16, 1> softReset;
		Field<U32,17, 1> linkEnable;
		Field<U32,18, 1> postedWriteEnable;
		Field<U32,19, 1> lps;
		Field<U32,22, 1> aPhyEnhanceEnable;
		Field<U32,23, 1> programPhyEnable;
		Field<U32,29, 1> ackTardyEnable;
		Field<U32,30, 1> noByteSwapData;
		Field<U32,31, 1> BibImageValid;
		U32 all;
	};
	RelativeRef<SetClear<HcControl>,0x050> hcControl;

	struct InitialBandwidthAvailable
	{
		Field<U32, 0,12> initialBandwidthAvailable;
		U32 all;
	};
	RelativeRef<InitialBandwidthAvailable,0x0b0> initialBandwidthAvailable;
	RelativeRef<U32,0x0b4> initialChannelAvailableHi;
	RelativeRef<U32,0x0b8> initialChannelAvailableLo;
	struct FairnessControl
	{
		Field<U32, 0, 8> priReq;
		U32 all;
	};
	RelativeRef<FairnessControl,0x0dc> fairnessControl;
	struct LinkControl
	{
		Field<U32, 6, 1> tag1SyncFilterLock;
		Field<U32, 9, 1> rcvSelfId;
		Field<U32,10, 1> rcvPhyPkt;
		Field<U32,20, 1> cycleTimerEnable;
		Field<U32,21, 1> cycleMaster;
		Field<U32,22, 1> cycleSource;
		U32 all;
	};
	RelativeRef<SetClear<LinkControl>,0x0e0> linkControl;
	struct NodeIdentificationAndStatus
	{
		Field<U32, 0, 6> nodeNumber;
		Field<U32, 6,10> busNumber;
		Field<U32,37, 1> cps;
		Field<U32,30, 1> root;
		Field<U32,31, 1> idValid;
		U32 all;
	};
	RelativeRef<NodeIdentificationAndStatus,0x0e8> nodeIdentificationAndStatus;
	struct PhyControl
	{
		Field<U32, 0, 8> wrData;
		Field<U32, 8, 4> regAddr;
		Field<U32,14, 1> wrReg;
		Field<U32,15, 1> rdReg;
		Field<U32,16, 8> rdData;
		Field<U32,24, 4> rdAddr;
		Field<U32,31, 1> rdDone;
		U32 all;
	};
	RelativeRef<PhyControl,0x0ec> phyControl;
	struct IsochronousCycleTimer
	{
		Field<U32, 0,12> cycleOffset;
		Field<U32,12,13> cycleCount;
		Field<U32,25, 7> cycleSeconds;
		Field<U32,12,16> timeStamp;
		U32 all;
	};
	RelativeRef<IsochronousCycleTimer,0x0f0> isochronousCycleTimer;

	struct AsynchronousRequestFilterHi
	{
		Field<U32, 0,31> asynReqResourceHi;
		Field<U32,31, 1> asynReqResourceAll;
		U32 all;
	};
	RelativeRef<SetClear<AsynchronousRequestFilterHi>,0x100> asynchronousRequestFilterHi;
	struct AsynchronousRequestFilterLo
	{
		Field<U32, 0,32> asynReqResourceLo;
		U32 all;
	};
	RelativeRef<SetClear<AsynchronousRequestFilterLo>,0x108> asynchronousRequestFilterLo;

	struct PhysicalRequestFilterHi
	{
		Field<U32, 0,31> physReqResourceHi;
		Field<U32,31, 1> physReqResourceAllBuses;
		U32 all;
	};
	RelativeRef<SetClear<PhysicalRequestFilterHi>,0x110> physicalRequestFilterHi;
	struct PhysicalRequestFilterLo
	{
		Field<U32, 0,32> physReqResourceLo;
		U32 all;
	};
	RelativeRef<SetClear<PhysicalRequestFilterLo>,0x118> physicalRequestFilterLo;

	RelativeRef<U32,0x120> physicalUpperBoundOffset;

	struct IntEvent
	{
		Field<U32, 0, 1> reqTxComplete;
		Field<U32, 1, 1> respTxComplete;
		Field<U32, 2, 1> arrq;
		Field<U32, 3, 1> arrs;
		Field<U32, 4, 1> rqPkt;
		Field<U32, 5, 1> rspPkt;
		Field<U32, 6, 1> isoTx;
		Field<U32, 7, 1> isoRx;
		Field<U32, 8, 1> postedWriteErr;
		Field<U32, 9, 1> lockRespErr;
		Field<U32,15, 1> selfIdComplete2;
		Field<U32,16, 1> selfIdComplete;
		Field<U32,17, 1> busReset;
		Field<U32,18, 1> regAccessFail;
		Field<U32,19, 1> phy;
		Field<U32,20, 1> cycleSync;
		Field<U32,21, 1> cycle64Seconds;
		Field<U32,22, 1> cycleLost;
		Field<U32,23, 1> cycleIconsistent;
		Field<U32,24, 1> unrecoverableError;
		Field<U32,25, 1> cycleTooLong;
		Field<U32,26, 1> phyRegRcvd;
		Field<U32,27, 1> ackTardy;
		Field<U32,29, 1> softInterrupt;
		Field<U32,30, 1> vendorSpecific;
		Field<U32,31, 1> masterIntEnable;
		U32 all;
	};
	RelativeRef<SetClear<IntEvent>,0x080> intEvent;
	RelativeRef<SetClear<IntEvent>,0x088> intMask;

	RelativeRef<SetClear<U32>,0x090> isoXmitIntEvent;
	RelativeRef<SetClear<U32>,0x098> isoXmitIntMask;

	RelativeRef<SetClear<U32>,0x0a0> isoRecvIntEvent;
	RelativeRef<SetClear<U32>,0x0a8> isoRecvIntMask;

	struct Program
	{
		struct ContextControl
		{
			Field<U32, 0, 5> eventCode;
			Field<U32, 5, 3> spd;
			Field<U32,10, 1> active;
			Field<U32,11, 1> dead;
			Field<U32,12, 1> wake;
			Field<U32,15, 1> run;
			Field<U32,16,15> cycleMatch;
			Field<U32,31, 1> cycleMatchEnable;
			U32 all;
		};
		RelativeRef<SetClear<ContextControl>,0x00> contextControl;
		struct DmaContext
		{
			Field<U32, 0, 4> z;
			Field<U32, 4,28> descriptorAddressMsb;
			U32 all;
		};
		RelativeRef<DmaContext,0x0c> dmaContext;
	};
	RelativeRef<Program,0x180> atRequestProgram;
	RelativeRef<Program,0x1a0> atResponseProgram;

	RelativeRef<Program,0x1c0> arRequestProgram;
	RelativeRef<Program,0x1e0> arResponseProgram;

	struct ItPrograms : public Program
	{
		U32 buf[4];
	};
	struct IrPrograms : public Program
	{
		struct ContextMatch
		{
			Field<U32, 0, 6> channelNumber;
			Field<U32, 6, 1> tag1SyncFilter;
			Field<U32, 8, 4> sync;
			Field<U32,12,15> cycleMatch;
			Field<U32,28, 1> tag0;
			Field<U32,29, 1> tag1;
			Field<U32,30, 1> tag2;
			Field<U32,31, 1> tag3;
			U32 all;
		};
		RelativeRef<ContextMatch,0x10> contextMatch;
		U32 buf[8];
	};
	RelativeRef<ItPrograms,0x200> itPrograms;
	RelativeRef<IrPrograms,0x400> irPrograms;

	RelativeRef<SetClear<U32>,0x070> irMultiChannelMaskHi;
	RelativeRef<SetClear<U32>,0x078> irMultiChannelMaskLo;

	struct SelfIdPointer
	{
		Field<U32, 0,11> aligned;
		Field<U32,11,21> selfIdPointer;
		U32 all;
	};
	RelativeRef<SelfIdPointer,0x064> selfIdPointer;

	struct SelfIdCount
	{
		Field<U32, 2, 9> selfIdSize;
		Field<U32,16, 8> selfIdGeneration;
		Field<U32,31, 1> selfIdError;
		U32 all;
	};
	RelativeRef<SelfIdCount,0x068> selfIdCount;

	RelativeRef<U32,0x038> postedWriteAddressLo;
	RelativeRef<U32,0x03c> postedWriteAddressHi;

};

struct OhciDescriptor
{
	struct Descriptor
	{
		RelativeField<U32,0x0, 0,32> id;
		RelativeField<U32,0x0, 0,16> reqCount;
		RelativeField<U32,0x0,18, 2> b;
		RelativeField<U32,0x0,20, 2> i;
		RelativeField<U32,0x0,23, 1> p;
		RelativeField<U32,0x0,24, 3> key;
		RelativeField<U32,0x0,27, 1> s;
		RelativeField<U32,0x0,28, 4> cmd;

		RelativeField<U32,0x4, 0,32> dataAddress;

		RelativeField<U32,0x8, 0,32> branchAddress;
		RelativeField<U32,0x8, 0, 4> z;
		RelativeField<U32,0x8, 4,28> branchAddressMsb;

		RelativeField<U32,0xc, 0,16> timeStamp;
		RelativeField<U32,0xc,16,16> xfer;
	};

	struct OutputMore : public Descriptor
	{
		inline void init()
		{
			cmd=0;
			key=0;
			b=0;
		}
		U32 buf[4];
	};
	struct OutputMoreImmediate : public Descriptor
	{
		inline void init()
		{
			cmd=0;
			key=2;
			b=0;
		}
		RelativeRef<U32,0x10> quadlets;
		U32 buf[8];
	};
	struct OutputLast : public Descriptor
	{
		inline void init()
		{
			cmd=1;
			key=0;
			b=3;
		}
		U32 buf[4];
	};
	struct OutputLastImmediate : public Descriptor
	{
		inline void init()
		{
			bClear((U8*)this,sizeof(*this));
			cmd=1;
			key=2;
			b=3;
		}
		RelativeRef<U32,0x10> quadlets;
		U32 buf[8];
	};
	struct InputMore : public Descriptor
	{
		RelativeField<U32,0xc, 0,16> resCount;
		inline void init()
		{
			bClear((U8*)this,sizeof(*this));
			cmd=2;
			key=0;
			b=3;
			s=1;
		}
		U32 buf[4];
	};
};

int waitQuadletInit(Ohci *ohci);
int waitQuadletPoll(Ohci *ohci);

#endif /* __ohci_h__ */