ipblock my_arm {
  iptype "armsystem";
  ipparm "exec=gcddrive";
}

ipblock m_req(out data : ns(32)) {
  iptype "armsystemsource";
  ipparm "core=my_arm";
  ipparm "address=0x80000000";
}

ipblock m_ack(in data : ns(32)) {
  iptype "armsystemsink";
  ipparm "core=my_arm";
  ipparm "address=0x80000004";
}

ipblock m_data_out(out data : ns(32)) {
  iptype "armsystemsource";
  ipparm "core=my_arm";
  ipparm "address=0x80000008";
}

ipblock m_data_in(in data : ns(32)) {
  iptype "armsystemsink";
  ipparm "core=my_arm";
  ipparm "address=0x8000000C";
}

dp euclid(in  m_in, n_in : ns(32);
          in  go         : ns( 1);
          out ready      : ns( 1);
          out gcd        : ns(32)) {
  reg m, n : ns(32);
  sig done : ns(1);

  always { done  = ((m==0) | (n==0));
           ready = done;
           gcd   = (m > n) ? m : n;
           m     = go ? m_in : ((m >  n) ? m - n : m);
           n     = go ? n_in : ((n >= m) ? n - m : n);
         }
}

dp tb_euclid {
  sig m, n  : ns(32);
  sig ready : ns(1);
  sig go    : ns(1);
  sig gcd   : ns(32);
  use euclid(m, n, go, ready, gcd);

  use my_arm;

  sig req, ack, data_out, data_in : ns(32);
  use m_req(req);
  use m_ack(ack);
  use m_data_out(data_out);
  use m_data_in(data_in);

  reg r_req    : ns(1);
  reg r_done   : ns(1);
  reg r_m, r_n : ns(32);

  always   { r_req   = req;
             r_done  = ready;
             data_in = gcd;
             m       = r_m;
             n       = r_n;
           }
  sfg ack1 { ack = 1;        }
  sfg ack0 { ack = 0;        }
  sfg getm { r_m = data_out; }
  sfg getn { r_n = data_out; }
  sfg start{ go  = 1;        }
  sfg wait { go  = 0;        }
}

fsm ctl_tb_euclid(tb_euclid) {
  initial s0;
  state s1, s2, s3, s4, s5, s6;

  @s0 (ack0, wait) -> s1;

  // read m
  @s1 if (r_req)  then (getm, ack1, wait) -> s2;
                  else (ack0, wait)       -> s1;
  // read n
  @s2 if (~r_req) then (getn, ack0, wait) -> s3;
                  else (ack1, wait)       -> s2;

  // compute
  @s3 (start, ack0) -> s4;
  @s4 if (r_done) then (ack0, wait)       -> s5;
                  else (ack0, wait)       -> s4;

  // output result
  @s5 if (r_req)  then (ack1, wait)       -> s6;
                  else (ack0, wait)       -> s5;
  @s6 if (~r_req) then (ack0, wait)       -> s1;
                  else (ack1, wait)       -> s6;
}

system S {
  tb_euclid;
}