#ifndef __fei82559_h__
#define __fei82559_h__

#include "type.h"
#include "ethernetCapable.h"

struct Fei82559 : public EthernetCapable
{
	//~Fei82559();
	struct Hw
	{
		struct ScbControlStatus
		{
			Field<U32, 2, 4> rus;
			Field<U32, 6, 2> cus;
			struct Flags
			{
				Field<U32,15, 1> cx;
				Field<U32,14, 1> fr;
				Field<U32,13, 1> cna;
				Field<U32,12, 1> rnr;
				Field<U32,11, 1> mdi;
				Field<U32,10, 1> swi;
				Field<U32, 9, 1> rsvd;
				Field<U32, 8, 1> fcp;
				Field<U32, 8, 8> all;
			};
			struct Interrupt
			{
				Field<U32,25, 1> si;
				Field<U32,26, 1> fcp;
				Field<U32,27, 1> er;
				Field<U32,28, 1> rnr;
				Field<U32,29, 1> cna;
				Field<U32,30, 1> fr;
				Field<U32,31, 1> cx;
				Field<U32,25, 7> all;
			};
			RelativeRef<Flags, 0> stat;
			RelativeRef<Flags, 0> ack;
			Field<U32,16, 3> ruc;
			Field<U32,20, 4> cuc;
			Field<U32,24, 1> interruptGlobalMask;
			RelativeRef<Interrupt, 0> interrupt;
			volatile U32 all;
		};
		RelativeRef<ScbControlStatus,0x00> scbControlStatus;
		Relative<U32,0x04,volatile U32> scbGeneralPointer;
		Relative<U32,0x08,U32> port;
		struct Eeprom
		{
			static const U32 cmdLen=3;
			static const U32 adrLen=8;
			static const U32 dataLen=16;
			struct OpCode
			{
				static const U32 erase=0x7000000;
				static const U32 read =0x6000000;
				static const U32 write=0x5000000;
				static const U32 ewen =0x4c00000;
				static const U32 eral =0x4800000;
				static const U32 wral =0x4400000;
				static const U32 ewds =0x4000000;
			};
			struct Control
			{
				Field<U32,16, 1> ck;
				Field<U32,17, 1> cs;
				Field<U32,18, 1> din;
				Field<U32,19, 1> dout;
				volatile U32 all;
			};
			RelativeRef<Control,0> control;
			
			void bitDelay();
			bool cmd(U32 cmd,U32 address=0,U32 *data=0);
			inline bool eraseAll()
			{
				return cmd(OpCode::eral);
			}
			inline bool ewen()
			{
				return cmd(OpCode::ewen);
			}
			inline bool ewds()
			{
				return cmd(OpCode::ewds);
			}
			inline bool read(U32 address,U32 *data)
			{
				return cmd(OpCode::read,address,data);
			}
			inline bool write(U32 address,U32 data)
			{
				return cmd(OpCode::write,address,&data);
			}
			U32 all;
		};
		RelativeRef<Eeprom,0x0c> eeprom;
		struct Mdi
		{
			struct OpCode
			{
				static const U32 write=1;
				static const U32 read=2;
			};
			struct Control
			{
				Field<U32,29, 1> interruptEnable;
				Field<U32,28, 1> ready;
				Field<U32,26, 2> opCode;
				Field<U32,21, 5> phyAdd;
				Field<U32,16, 5> regAdd;
				Field<U32, 0,16> data;
				U32 all;
			};
			RelativeRef<Control,0> control;
			bool access(U32 phyAdd,U32 regAdd,U32 *data,U32 opCode);
			inline bool read (U32 phyAdd,U32 regAdd,U32 *data)
			{
				return access(phyAdd,regAdd,data,OpCode::read);
			}
			bool write(U32 phyAdd,U32 regAdd,U32  data)
			{
				return access(phyAdd,regAdd,&data,OpCode::write);
			}
			U32 all;
		};
		RelativeRef<Mdi,0x10> mdi;
		
		struct Cb
		{
			struct CommandStatus
			{
				Field<U32,31, 1> el;
				Field<U32,30, 1> s;
				Field<U32,29, 1> i;
				Field<U32,24, 5> cid;
				Field<U32,20, 1> h;
				Field<U32,20, 1> nc;
				Field<U32,19, 1> sf;
				Field<U32,16, 3> cmd;
				Field<U32,15, 1> c;
				Field<U32,13, 1> ok;
				Field<U32,12, 1> u;
				Field<U32, 0,13> status;
				U32 all;
			};
			
			RelativeRef<CommandStatus,0x0> commandStatus;
			Relative<U32,0x4,U32> link;
		};
		
		struct Nop : public Cb
		{
			RelativeRef<U8,0x8> bytes;
			RelativeRef<U16,0x8> words;
			U32 head[2];
			U32 data[2]; // not used
		} __attribute__((packed));
		
		struct Ias : public Cb
		{
			RelativeRef<U8,0x8> bytes;
			RelativeRef<U16,0x8> words;
			U32 head[2];
			U32 data[2];
		} __attribute__((packed));
		
		struct Config : public Cb
		{
			RelativeRef<U8,0x8> bytes;
			U32 head[2];
			U32 data[0];
		} __attribute__((packed));
		
		struct Dump : public Cb
		{
			Relative<U32,0x8,U32> buf;
			U32 head[4];
			U32 data[596/sizeof(U32)];
		} __attribute__((packed));
		
		struct Other
		{
			U8 dgsh[0];
		} __attribute__((packed));
		
		struct Rd : public Cb
		{
			//RelativeRef<Cb,0x0> cb;
			
			Relative<U32,0x8,U32> reserved;
			struct Sizes
			{
				Field<U32,16,14> size;
				Field<U32, 0,14> actual;
				Field<U32,14, 1> f;
				Field<U32,15, 1> eof;
				U32 all;
			};
			RelativeRef<Sizes,0xc> sizes;
			
			U32 head[4];
			U32 data[0];
		};
		
		struct Tbd
		{
			Relative<U32,0x0,U32> address;
			struct Sizes
			{
				Field<U32, 0,14> length;
				Field<U32,16, 1> el;
				U32 all;
			};
			RelativeRef<Sizes,0x4> sizes;
			U32 buf[2];
		};
		struct Td : public Cb
		{
			//RelativeRef<Cb,0x0> cb;
			Relative<Tbd*,0x8,Tbd*> tbds;
			struct Sizes
			{
				Field<U32, 0,14> tcbCount;
				Field<U32,14, 1> f;
				Field<U32,15, 1> eof;
				Field<U32,16, 8> threshold;
				Field<U32,24, 8> tbdNumber;
				U32 all;
			};
			RelativeRef<Sizes,0xc> sizes;
			RelativeRef<Tbd,0x10> extTbds;
			U32 head[4];
			U32 data[0];
		};
		
		bool doCu(Cb *cb);
		bool doCuResume();
		bool doRu(Cb *cb);
		bool receiveTodo(Rd *rd,U32 len);
		bool receiveDone(Rd *rd,U32 *len);
		
		bool init();
		bool dump();
	};
	
	struct Td : public Hw::Td
	{
		Ethernet ethernet[0];
		U8 buf[ALIGN(Ethernet::MTU,32)];
	};
	
	struct Rd : public Hw::Rd
	{
		Ethernet ethernet[0];
		U8 buf[ALIGN(Ethernet::MTU,32)];
	};
	
	static const U32 rdsCount=4;
	static const U32 tdsCount=4;
	Aligned<U8,sizeof(Rd)*rdsCount+sizeof(Td)*tdsCount,32> buf;
	
	Hw *hw;
	Rd *currentRd;
	Td *currentTd;
	int debugLevel;
	
	Fei82559();
	virtual bool init();
	virtual void reset();
	virtual Ethernet *receive(U32 *size);
	virtual void receive(Ethernet *e);
	virtual Ethernet *send();
	virtual bool send(Ethernet *,U32 size);
};


#endif /* __fei82559_h__ */