src/mem/protocol/MESI_CMP_directory-dma.sm

   1
   2 machine(DMA, "DMA Controller")
   3 : DMASequencer * dma_sequencer,
   4   int request_latency = 6
   5 {
   6
   7   MessageBuffer responseFromDir, network="From", virtual_network="1", ordered="true", vnet_type="response", no_vector="true";
   8   MessageBuffer reqToDirectory, network="To", virtual_network="0", ordered="false", vnet_type="request", no_vector="true";
   9
  10   state_declaration(State, desc="DMA states", default="DMA_State_READY") {
  11     READY, AccessPermission:Invalid, desc="Ready to accept a new request";
  12     BUSY_RD, AccessPermission:Busy, desc="Busy: currently processing a request";
  13     BUSY_WR, AccessPermission:Busy, desc="Busy: currently processing a request";
  14   }
  15
  16   enumeration(Event, desc="DMA events") {
  17     ReadRequest,  desc="A new read request";
  18     WriteRequest, desc="A new write request";
  19     Data,         desc="Data from a DMA memory read";
  20     Ack,          desc="DMA write to memory completed";
  21   }
  22
  23   structure(DMASequencer, external="yes") {
  24     void ackCallback();
  25     void dataCallback(DataBlock);
  26   }
  27
  28   MessageBuffer mandatoryQueue, ordered="false", no_vector="true";
  29   State cur_state, no_vector="true";
  30
  31   State getState(Address addr) {
  32     return cur_state;
  33   }
  34   void setState(Address addr, State state) {
  35   cur_state := state;
  36   }
  37
  38   AccessPermission getAccessPermission(Address addr) {
  39     return AccessPermission:NotPresent;
  40   }
  41
  42   void setAccessPermission(Address addr, State state) {
  43   }
  44
  45   DataBlock getDataBlock(Address addr), return_by_ref="yes" {
  46     error("DMA does not support get data block.");
  47   }
  48
  49   out_port(reqToDirectory_out, RequestMsg, reqToDirectory, desc="...");
  50
  51   in_port(dmaRequestQueue_in, SequencerMsg, mandatoryQueue, desc="...") {
  52     if (dmaRequestQueue_in.isReady()) {
  53       peek(dmaRequestQueue_in, SequencerMsg) {
  54         if (in_msg.Type == SequencerRequestType:LD ) {
  55           trigger(Event:ReadRequest, in_msg.LineAddress);
  56         } else if (in_msg.Type == SequencerRequestType:ST) {
  57           trigger(Event:WriteRequest, in_msg.LineAddress);
  58         } else {
  59           error("Invalid request type");
  60         }
  61       }
  62     }
  63   }
  64
  65   in_port(dmaResponseQueue_in, ResponseMsg, responseFromDir, desc="...") {
  66     if (dmaResponseQueue_in.isReady()) {
  67       peek( dmaResponseQueue_in, ResponseMsg) {
  68         if (in_msg.Type == CoherenceResponseType:ACK) {
  69           trigger(Event:Ack, makeLineAddress(in_msg.Address));
  70         } else if (in_msg.Type == CoherenceResponseType:DATA) {
  71           trigger(Event:Data, makeLineAddress(in_msg.Address));
  72         } else {
  73           error("Invalid response type");
  74         }
  75       }
  76     }
  77   }
  78
  79   action(s_sendReadRequest, "s", desc="Send a DMA read request to memory") {
  80     peek(dmaRequestQueue_in, SequencerMsg) {
  81       enqueue(reqToDirectory_out, RequestMsg, latency=request_latency) {
  82         out_msg.Address := in_msg.PhysicalAddress;
  83         out_msg.Type := CoherenceRequestType:DMA_READ;
  84         out_msg.DataBlk := in_msg.DataBlk;
  85         out_msg.Len := in_msg.Len;
  86         out_msg.Destination.add(map_Address_to_Directory(address));
  87         out_msg.MessageSize := MessageSizeType:Writeback_Control;
  88       }
  89     }
  90   }
  91
  92   action(s_sendWriteRequest, "\s", desc="Send a DMA write request to memory") {
  93     peek(dmaRequestQueue_in, SequencerMsg) {
  94       enqueue(reqToDirectory_out, RequestMsg, latency=request_latency) {
  95           out_msg.Address := in_msg.PhysicalAddress;
  96           out_msg.Type := CoherenceRequestType:DMA_WRITE;
  97           out_msg.DataBlk := in_msg.DataBlk;
  98           out_msg.Len := in_msg.Len;
  99           out_msg.Destination.add(map_Address_to_Directory(address));
 100           out_msg.MessageSize := MessageSizeType:Writeback_Control;
 101         }
 102       }
 103   }
 104
 105   action(a_ackCallback, "a", desc="Notify dma controller that write request completed") {
 106     dma_sequencer.ackCallback();
 107   }
 108
 109   action(d_dataCallback, "d", desc="Write data to dma sequencer") {
 110     peek (dmaResponseQueue_in, ResponseMsg) {
 111       dma_sequencer.dataCallback(in_msg.DataBlk);
 112     }
 113   }
 114
 115   action(p_popRequestQueue, "p", desc="Pop request queue") {
 116     dmaRequestQueue_in.dequeue();
 117   }
 118
 119   action(p_popResponseQueue, "\p", desc="Pop request queue") {
 120     dmaResponseQueue_in.dequeue();
 121   }
 122
 123   action(z_stall, "z", desc="dma is busy..stall") {
 124     // do nothing
 125   }
 126
 127   transition(READY, ReadRequest, BUSY_RD) {
 128     s_sendReadRequest;
 129     p_popRequestQueue;
 130   }
 131
 132   transition(READY, WriteRequest, BUSY_WR) {
 133     s_sendWriteRequest;
 134     p_popRequestQueue;
 135   }
 136
 137   transition(BUSY_RD, Data, READY) {
 138     d_dataCallback;
 139     p_popResponseQueue;
 140   }
 141
 142   transition(BUSY_WR, Ack, READY) {
 143     a_ackCallback;
 144     p_popResponseQueue;
 145   }
 146 }