TITLE "VME decoder for MOP chip";

FUNCTION lpm_ff (data[LPM_WIDTH-1..0], clock, enable, 
		 sclr, sset, sload, aclr, aset, aload)
   WITH (LPM_WIDTH, LPM_AVALUE, LPM_SVALUE, LPM_FFTYPE)
   RETURNS (q[LPM_WIDTH-1..0]);

CONSTANT idpromnum =     0;
CONSTANT idpromstream =  4;
CONSTANT mopnum =        7;
CONSTANT spynum =        8;
CONSTANT dipdevnum =     9;
CONSTANT disablenum =       H"0000";
CONSTANT spycounternum =    H"1100";
CONSTANT endeventresetnum = H"1200";
CONSTANT errorregresetnum = H"1201";
CONSTANT aendeventmasknum = H"1210";
CONSTANT aendeventclrnum =  H"1211";
CONSTANT acdferrormasknum = H"1212";
CONSTANT asvterrormasknum = H"1213";
CONSTANT aerrorregnum     = H"1214";
CONSTANT alocalregnum     = H"1215";
CONSTANT bendeventmasknum = H"1220";
CONSTANT bendeventclrnum =  H"1221";
CONSTANT bcdferrormasknum = H"1222";
CONSTANT bsvterrormasknum = H"1223";
CONSTANT berrorregnum     = H"1224";
CONSTANT blocalregnum     = H"1225";
CONSTANT cendeventmasknum = H"1230";
CONSTANT cendeventclrnum =  H"1231";
CONSTANT ccdferrormasknum = H"1232";
CONSTANT csvterrormasknum = H"1233";
CONSTANT cerrorregnum     = H"1234";
CONSTANT clocalregnum     = H"1235";
CONSTANT lastaddrnum      = H"8000";
CONSTANT dipstream = 9;
CONSTANT dipnum = H"9999";

SUBDESIGN mopvmedecode
( 
  address[24..0]		: INPUT;
  vmewrite			: INPUT;
  vme_as			: INPUT;
  hf_load			: INPUT;
  hf_init			: INPUT;
  hf_freeze			: INPUT;
  hf_test			: INPUT;
  vmespyread			: OUTPUT;
  vmespywrite			: OUTPUT;
  fpspyread			: OUTPUT;
  fpspywrite			: OUTPUT;
  vmespycounterread		: OUTPUT;
  vmespycounterreset		: OUTPUT;
  vmebarrellayerread		: OUTPUT;
  vmebarrellayerwrite		: OUTPUT;
  vmedisableread		: OUTPUT;
  vmedisablewrite		: OUTPUT;
  vmeaendeventmaskread		: OUTPUT;
  vmeaendeventmaskwrite		: OUTPUT;
  vmeaendeventclrread		: OUTPUT;
  vmeaendeventclrwrite		: OUTPUT;
  vmeacdferrormaskread		: OUTPUT;
  vmeacdferrormaskwrite		: OUTPUT;
  vmeasvterrormaskread		: OUTPUT;
  vmeasvterrormaskwrite		: OUTPUT;
  vmeaerrorregread		: OUTPUT;
  vmealocalregread		: OUTPUT;
  vmebendeventmaskread		: OUTPUT;
  vmebendeventmaskwrite		: OUTPUT;
  vmebendeventclrread		: OUTPUT;
  vmebendeventclrwrite		: OUTPUT;
  vmebcdferrormaskread		: OUTPUT;
  vmebcdferrormaskwrite		: OUTPUT;
  vmebsvterrormaskread		: OUTPUT;
  vmebsvterrormaskwrite		: OUTPUT;
  vmeberrorregread		: OUTPUT;
  vmeblocalregread		: OUTPUT;
  vmecendeventmaskread		: OUTPUT;
  vmecendeventmaskwrite		: OUTPUT;
  vmecendeventclrread		: OUTPUT;
  vmecendeventclrwrite		: OUTPUT;
  vmeccdferrormaskread		: OUTPUT;
  vmeccdferrormaskwrite		: OUTPUT;
  vmecsvterrormaskread		: OUTPUT;
  vmecsvterrormaskwrite		: OUTPUT;
  vmecerrorregread		: OUTPUT;
  vmeclocalregread		: OUTPUT;
  vmeerrorregreset		: OUTPUT;
  vmeendeventreset		: OUTPUT;
  vmedipread			: OUTPUT;
  vmeidnumread			: OUTPUT;
  vmelastaddrread       : OUTPUT;
  vmelastaddrwrite      : OUTPUT;
)
VARIABLE
devices[4..0],stream[3..0],subdevices[15..0],vmeread:NODE;

BEGIN

devices[4..0] = address[24..20];
stream[3..0] = address[19..16];
subdevices[15..0] = address[15..0];
vmeread = !vmewrite;
    
vmelastaddrread = vme_as & 
  (devices[] == mopnum) &
  (subdevices[] == lastaddrnum) &
  vmeread;

vmelastaddrwrite = vme_as & vmewrite;

vmedipread = vme_as & 
	(stream[] == dipstream) & 
	(devices[] == dipdevnum) &
	(subdevices[] == dipnum) &
	vmeread;

vmeidnumread = vme_as &
	(stream[] == idpromstream) &
	(devices[] == idpromnum) &
	(subdevices[15..2] == 0) &
	vmeread;

vmespyread = vme_as & 
        (hf_freeze # hf_load) &
        (devices[] == spynum) & vmeread;

vmeaerrorregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == aerrorregnum) & vmeread;

vmeberrorregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == berrorregnum) & vmeread;

vmecerrorregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == cerrorregnum) & vmeread;

vmealocalregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == alocalregnum) & vmeread;

vmeblocalregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == blocalregnum) & vmeread;

vmeclocalregread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == clocalregnum) & vmeread;

vmespywrite = vme_as & 
        hf_load &
        (devices[] == spynum) & vmewrite;

vmespycounterread = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == spycounternum) & vmeread;

vmespycounterreset = vme_as & 
        (devices[] == mopnum) & 
        (subdevices[] == spycounternum) & vmewrite & !fpspyread;

fpspyread = hf_test & !hf_load & !hf_freeze;

fpspywrite = !hf_test & !hf_freeze & !hf_load;

vmebarrellayerread = vme_as & 
        hf_load &
           (devices[] == mopnum) & 
           (subdevices[15..4] == H"100") & vmeread;

vmebarrellayerwrite = vme_as & 
        hf_load &
           (devices[] == mopnum) & 
           (subdevices[15..4] == H"100") &  vmewrite;

vmedisablewrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == disablenum);  
  
vmedisableread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == disablenum);

vmeaendeventmaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == aendeventmasknum);  
  
vmeaendeventmaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == aendeventmasknum);

vmeaendeventclrwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == aendeventclrnum);  
  
vmeaendeventclrread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == aendeventclrnum);

vmeacdferrormaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == acdferrormasknum);  
  
vmeacdferrormaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == acdferrormasknum);

vmeasvterrormaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == asvterrormasknum);  
  
vmeasvterrormaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == asvterrormasknum);

vmebendeventmaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == bendeventmasknum);  
  
vmebendeventmaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == bendeventmasknum);

vmebendeventclrwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == bendeventclrnum);  
  
vmebendeventclrread = vme_as & vmeread &
            (devices[] == mopnum) & (subdevices[] == bendeventclrnum);

vmebcdferrormaskwrite = vme_as & 
                hf_load & vmewrite &
                   (devices[] == mopnum) & (subdevices[] == bcdferrormasknum);
  
vmebcdferrormaskread = vme_as & vmeread &
            (devices[] == mopnum) & (subdevices[] == bcdferrormasknum);

vmebsvterrormaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == bsvterrormasknum);  
  
vmebsvterrormaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == bsvterrormasknum);

vmecendeventmaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == cendeventmasknum);  
  
vmecendeventmaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == cendeventmasknum);

vmecendeventclrwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == cendeventclrnum);  
  
vmecendeventclrread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == cendeventclrnum);

vmeccdferrormaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == ccdferrormasknum);  
  
vmeccdferrormaskread = vme_as & vmeread &
           (devices[] == mopnum) & (subdevices[] == ccdferrormasknum);

vmecsvterrormaskwrite = vme_as & 
        hf_load & vmewrite &
           (devices[] == mopnum) & (subdevices[] == csvterrormasknum);
  
vmecsvterrormaskread = vme_as & vmeread &
             (devices[] == mopnum) & (subdevices[] == csvterrormasknum);

vmeerrorregreset = vme_as & vmewrite &
        (devices[] == mopnum) & (subdevices[] == errorregresetnum);

vmeendeventreset = vme_as & vmewrite &
        (devices[] == mopnum) & (subdevices[] == endeventresetnum);

END;