1 /*
2  * \file       trc_pkt_elem_etmv4i.h
3  * \brief      OpenCSD :
4  *
5  * \copyright  Copyright (c) 2015, ARM Limited. All Rights Reserved.
6  */
7 
8 
9 /*
10  * Redistribution and use in source and binary forms, with or without modification,
11  * are permitted provided that the following conditions are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright notice,
14  * this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright notice,
17  * this list of conditions and the following disclaimer in the documentation
18  * and/or other materials provided with the distribution.
19  *
20  * 3. Neither the name of the copyright holder nor the names of its contributors
21  * may be used to endorse or promote products derived from this software without
22  * specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
26  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27  * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
28  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
31  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 #ifndef ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
37 #define ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
38 
39 #include "trc_pkt_types_etmv4.h"
40 #include "common/trc_printable_elem.h"
41 #include "common/trc_pkt_elem_base.h"
42 
43 /** @addtogroup trc_pkts
44 @{*/
45 
46 /*!
47 * @class Etmv4PktAddrStack
48 * @brief ETMv4 Address packet values stack
49 * @ingroup trc_pkts
50 *
51 *  This class represents a stack of recent broadcast address values -
52 *  used to fulfil the ExactMatch address type where no address is output.
53 *
54 */
55 class Etmv4PktAddrStack
56 {
57 public:
58     Etmv4PktAddrStack()
59     {
60         for (int i = 0; i < 3; i++)
61         {
62             m_v_addr[i].pkt_bits = 0;
63             m_v_addr[i].size = VA_64BIT;
64             m_v_addr[i].val = 0;
65             m_v_addr[i].valid_bits = 0;
66             m_v_addr_ISA[i] = 0;
67         }
68     }
69     ~Etmv4PktAddrStack() {};
70 
71     void push(const ocsd_pkt_vaddr vaddr, const uint8_t isa)
72     {
73         m_v_addr[2] = m_v_addr[1];
74         m_v_addr[1] = m_v_addr[0];
75         m_v_addr[0] = vaddr;
76         m_v_addr_ISA[2] = m_v_addr_ISA[1];
77         m_v_addr_ISA[1] = m_v_addr_ISA[0];
78         m_v_addr_ISA[0] = isa;
79     }
80 
81     void get_idx(const uint8_t idx, ocsd_pkt_vaddr &vaddr, uint8_t &isa)
82     {
83         if (idx < 3)
84         {
85             vaddr = m_v_addr[idx];
86             isa = m_v_addr_ISA[idx];
87         }
88     }
89 
90 private:
91     ocsd_pkt_vaddr m_v_addr[3];         //!< most recently broadcast address packet
92     uint8_t        m_v_addr_ISA[3];
93 };
94 
95 /*!
96  * @class EtmV4ITrcPacket
97  * @brief ETMv4 Instuction Trace Protocol Packet.
98  * @ingroup trc_pkts
99  *
100  *  This class represents a single ETMv4 data trace packet, along with intra packet state.
101  *
102  */
103 class EtmV4ITrcPacket :  public TrcPacketBase, public ocsd_etmv4_i_pkt, public trcPrintableElem
104 {
105 public:
106     EtmV4ITrcPacket();
107     ~EtmV4ITrcPacket();
108 
109     EtmV4ITrcPacket &operator =(const ocsd_etmv4_i_pkt* p_pkt);
110 
111     virtual const void *c_pkt() const { return (const ocsd_etmv4_i_pkt *)this; };
112 
113     // update interface - set packet values
114     void initStartState();   //!< Set to initial state - no intra packet state valid. Use on start of trace / discontinuities.
115     void initNextPacket();  //!< clear any single packet only flags / state.
116 
117     void setType(const ocsd_etmv4_i_pkt_type pkt_type) { type = pkt_type; };
118     void updateErrType(const ocsd_etmv4_i_pkt_type err_pkt_type, const uint8_t val = 0);
119 
120     void clearTraceInfo();  //!< clear all the trace info data prior to setting for new trace info packet.
121     void setTraceInfo(const uint32_t infoVal);
122     void setTraceInfoKey(const uint32_t keyVal);
123     void setTraceInfoSpec(const uint32_t specVal);
124     void setTraceInfoCyct(const uint32_t cyctVal);
125 
126     void setTS(const uint64_t value, const uint8_t bits);
127     void setCycleCount(const uint32_t value);
128     void setCommitElements(const uint32_t commit_elem);
129     void setCancelElements(const uint32_t cancel_elem);
130     void setAtomPacket(const ocsd_pkt_atm_type type, const uint32_t En_bits, const uint8_t num);
131 
132     void setCondIF1(uint32_t const cond_key);
133     void setCondIF2(uint8_t const c_elem_idx);
134     void setCondIF3(uint8_t const num_c_elem, const bool finalElem);
135 
136     void setCondRF1(const uint32_t key[2], const uint8_t res[2], const uint8_t CI[2], const bool set2Keys);
137     void setCondRF2(const uint8_t key_incr, const uint8_t token);
138     void setCondRF3(const uint16_t tokens);
139     void setCondRF4(const uint8_t token);
140 
141     void setContextInfo(const bool update, const uint8_t EL = 0, const uint8_t NS = 0, const uint8_t SF = 0);
142     void setContextVMID(const uint32_t VMID);
143     void setContextCID(const uint32_t CID);
144 
145     void setExceptionInfo(const uint16_t excep_type, const uint8_t addr_interp, const uint8_t m_fault_pending, const uint8_t m_type);
146 
147     void set64BitAddress(const uint64_t addr, const uint8_t IS);
148     void set32BitAddress(const uint32_t addr, const uint8_t IS);
149     void updateShortAddress(const uint32_t addr, const uint8_t IS, const uint8_t update_bits);
150     void setAddressExactMatch(const uint8_t idx);
151 
152     void setDataSyncMarker(const uint8_t dsm_val);
153     void setEvent(const uint8_t event_val);
154 
155     void setQType(const bool has_count, const uint32_t count, const bool has_addr, const bool addr_match, const uint8_t type);
156 
157     // packet status interface - get packet info.
158     const ocsd_etmv4_i_pkt_type getType() const { return type; };
159     const ocsd_etmv4_i_pkt_type getErrType() const { return err_type; };
160 
161     //! return true if this packet has set the commit packet count.
162     const bool hasCommitElementsCount() const
163     {
164         return pkt_valid.bits.commit_elem_valid ? true : false;
165     };
166 
167     // trace info
168     const etmv4_trace_info_t &getTraceInfo() const { return trace_info; };
169     const uint32_t getCCThreshold() const;
170     const uint32_t getP0Key() const;
171     const uint32_t getCurrSpecDepth() const;
172 
173     // atom
174     const ocsd_pkt_atom &getAtom() const { return atom; };
175 
176     // context
177     const etmv4_context_t &getContext() const { return context; };
178 
179     // address
180     const uint8_t &getAddrMatch() const  { return addr_exact_match_idx; };
181     const ocsd_vaddr_t &getAddrVal() const { return v_addr.val; };
182     const uint8_t &getAddrIS() const { return v_addr_ISA; };
183     const bool getAddr64Bit() const { return v_addr.size == VA_64BIT; };
184 
185     // ts
186     const uint64_t getTS() const { return pkt_valid.bits.ts_valid ? ts.timestamp : 0; };
187 
188     // cc
189     const uint32_t getCC() const { return pkt_valid.bits.cc_valid ? cycle_count : 0; };
190 
191     // packet type
192     const bool isBadPacket() const;
193 
194     // printing
195     virtual void toString(std::string &str) const;
196     virtual void toStringFmt(const uint32_t fmtFlags, std::string &str) const;
197 
198 private:
199     const char *packetTypeName(const ocsd_etmv4_i_pkt_type type, const char **pDesc) const;
200     void contextStr(std::string &ctxtStr) const;
201     void atomSeq(std::string &valStr) const;
202     void addrMatchIdx(std::string &valStr) const;
203     void exceptionInfo(std::string &valStr) const;
204 
205     void push_vaddr();
206     void pop_vaddr_idx(const uint8_t idx);
207 
208     Etmv4PktAddrStack m_addr_stack;
209 };
210 
211 inline void  EtmV4ITrcPacket::updateErrType(const ocsd_etmv4_i_pkt_type err_pkt_type, const uint8_t err_val /* = 0 */)
212 {
213     // set primary type to incoming error type, set packet err type to previous primary type.
214     err_type = type;
215     type = err_pkt_type;
216     err_hdr_val = err_val;
217 }
218 
219 inline void EtmV4ITrcPacket::clearTraceInfo()
220 {
221     pkt_valid.bits.ts_valid = 0;
222     pkt_valid.bits.trace_info_valid = 0;
223     pkt_valid.bits.p0_key_valid = 0;
224     pkt_valid.bits.spec_depth_valid = 0;
225     pkt_valid.bits.cc_thresh_valid  = 0;
226 
227     // set these as defaults - if they don't appear in TINFO this is the state.
228     setTraceInfo(0);
229     setTraceInfoSpec(0);
230 }
231 
232 inline void EtmV4ITrcPacket::setTraceInfo(const uint32_t infoVal)
233 {
234     trace_info.val = infoVal;
235     pkt_valid.bits.trace_info_valid = 1;
236 }
237 
238 inline void EtmV4ITrcPacket::setTraceInfoKey(const uint32_t keyVal)
239 {
240     p0_key = keyVal;
241     pkt_valid.bits.p0_key_valid = 1;
242 }
243 
244 inline void EtmV4ITrcPacket::setTraceInfoSpec(const uint32_t specVal)
245 {
246     curr_spec_depth = specVal;
247     pkt_valid.bits.spec_depth_valid = 1;
248 }
249 
250 inline void EtmV4ITrcPacket::setTraceInfoCyct(const uint32_t cyctVal)
251 {
252     cc_threshold = cyctVal;
253     pkt_valid.bits.cc_thresh_valid  = 1;
254 }
255 
256 inline void EtmV4ITrcPacket::setTS(const uint64_t value, const uint8_t bits)
257 {
258     uint64_t mask = (uint64_t)-1LL;
259     if(bits < 64) mask = (1ULL << bits) - 1;
260     ts.timestamp = (ts.timestamp & ~mask) | (value & mask);
261     ts.bits_changed = bits;
262     pkt_valid.bits.ts_valid = 1;
263 }
264 
265 inline void EtmV4ITrcPacket::setCycleCount(const uint32_t value)
266 {
267     pkt_valid.bits.cc_valid = 1;
268     cycle_count = value;
269 }
270 
271 inline void EtmV4ITrcPacket::setCommitElements(const uint32_t commit_elem)
272 {
273     pkt_valid.bits.commit_elem_valid = 1;
274     commit_elements = commit_elem;
275 }
276 
277 inline const uint32_t EtmV4ITrcPacket::getCCThreshold() const
278 {
279     if(pkt_valid.bits.cc_thresh_valid)
280         return cc_threshold;
281     return 0;
282 }
283 
284 inline const uint32_t EtmV4ITrcPacket::getP0Key() const
285 {
286     if(pkt_valid.bits.p0_key_valid)
287         return p0_key;
288     return 0;
289 }
290 
291 inline const uint32_t EtmV4ITrcPacket::getCurrSpecDepth() const
292 {
293     if(pkt_valid.bits.spec_depth_valid)
294         return curr_spec_depth;
295     return 0;
296 }
297 
298 inline void EtmV4ITrcPacket::setCancelElements(const uint32_t cancel_elem)
299 {
300     cancel_elements = cancel_elem;
301 }
302 
303 inline void EtmV4ITrcPacket::setAtomPacket(const ocsd_pkt_atm_type type, const uint32_t En_bits, const uint8_t num)
304 {
305     if(type == ATOM_REPEAT)
306     {
307         uint32_t bit_patt = En_bits & 0x1;
308         if(bit_patt)
309         {
310             // none zero - all 1s
311             bit_patt = (bit_patt << num) - 1;
312         }
313         atom.En_bits = bit_patt;
314     }
315     else
316         atom.En_bits = En_bits;
317     atom.num = num;
318 }
319 
320 inline void EtmV4ITrcPacket::setCondIF1(const uint32_t cond_key)
321 {
322     cond_instr.cond_key_set = 1;
323     cond_instr.f3_final_elem = 0;
324     cond_instr.f2_cond_incr = 0;
325     cond_instr.num_c_elem = 1;
326     cond_instr.cond_c_key = cond_key;
327 }
328 
329 inline void EtmV4ITrcPacket::setCondIF2(const uint8_t c_elem_idx)
330 {
331     cond_instr.cond_key_set = 0;
332     cond_instr.f3_final_elem = 0;
333     switch(c_elem_idx & 0x3)
334     {
335     case 0:
336         cond_instr.f2_cond_incr = 1;
337         cond_instr.num_c_elem = 1;
338         break;
339 
340     case 1:
341         cond_instr.f2_cond_incr = 0;
342         cond_instr.num_c_elem = 1;
343         break;
344 
345     case 2:
346         cond_instr.f2_cond_incr = 1;
347         cond_instr.num_c_elem = 2;
348         break;
349     }
350 }
351 
352 inline void EtmV4ITrcPacket::setCondIF3(const uint8_t num_c_elem, const bool finalElem)
353 {
354     cond_instr.cond_key_set = 0;
355     cond_instr.f3_final_elem = finalElem ? 1: 0;
356     cond_instr.f2_cond_incr = 0;
357     cond_instr.num_c_elem = num_c_elem;
358 }
359 
360 inline void EtmV4ITrcPacket::setCondRF1(const uint32_t key[2], const uint8_t res[2], const uint8_t CI[2],const bool set2Keys)
361 {
362     cond_result.key_res_0_set = 1;
363     cond_result.cond_r_key_0 = key[0];
364     cond_result.res_0 = res[0];
365     cond_result.ci_0 = CI[0];
366 
367     if(set2Keys)
368     {
369         cond_result.key_res_1_set = 1;
370         cond_result.cond_r_key_1 = key[1];
371         cond_result.res_1 = res[1];
372         cond_result.ci_1 = CI[1];
373     }
374 }
375 
376 
377 inline void EtmV4ITrcPacket::setCondRF2(const uint8_t key_incr, const uint8_t token)
378 {
379     cond_result.key_res_0_set = 0;
380     cond_result.key_res_1_set = 0;
381     cond_result.f2_key_incr = key_incr;
382     cond_result.f2f4_token = token;
383 }
384 
385 inline void EtmV4ITrcPacket::setCondRF3(const uint16_t tokens)
386 {
387     cond_result.key_res_0_set = 0;
388     cond_result.key_res_1_set = 0;
389     cond_result.f3_tokens = tokens;
390 }
391 
392 inline void EtmV4ITrcPacket::setCondRF4(const uint8_t token)
393 {
394     cond_result.key_res_0_set = 0;
395     cond_result.key_res_1_set = 0;
396     cond_result.f2f4_token = token;
397 }
398 
399 inline void EtmV4ITrcPacket::setContextInfo(const bool update, const uint8_t EL, const uint8_t NS, const uint8_t SF)
400 {
401     pkt_valid.bits.context_valid = 1;
402     if(update)
403     {
404         context.updated = 1;
405         context.EL = EL;
406         context.NS = NS;
407         context.SF = SF;
408     }
409 }
410 
411 inline void EtmV4ITrcPacket::setContextVMID(const uint32_t VMID)
412 {
413     pkt_valid.bits.context_valid = 1;
414     context.updated = 1;
415     context.VMID = VMID;
416     context.updated_v = 1;
417 }
418 
419 inline void EtmV4ITrcPacket::setContextCID(const uint32_t CID)
420 {
421     pkt_valid.bits.context_valid = 1;
422     context.updated = 1;
423     context.ctxtID = CID;
424     context.updated_c = 1;
425 }
426 
427 inline void EtmV4ITrcPacket::setExceptionInfo(const uint16_t excep_type, const uint8_t addr_interp, const uint8_t m_fault_pending, const uint8_t m_type)
428 {
429     exception_info.exceptionType = excep_type;
430     exception_info.addr_interp = addr_interp;
431     exception_info.m_fault_pending = m_fault_pending;
432     exception_info.m_type = m_type;
433 }
434 
435 inline void EtmV4ITrcPacket::set64BitAddress(const uint64_t addr, const uint8_t IS)
436 {
437     v_addr.pkt_bits = 64;
438     v_addr.valid_bits = 64;
439     v_addr.size = VA_64BIT;
440     v_addr.val = addr;
441     v_addr_ISA = IS;
442     push_vaddr();
443 }
444 
445 inline void EtmV4ITrcPacket::set32BitAddress(const uint32_t addr, const uint8_t IS)
446 {
447     uint64_t mask = OCSD_BIT_MASK(32);
448     v_addr.pkt_bits = 32;
449 
450 	if (pkt_valid.bits.context_valid && context.SF)
451 	{
452 		v_addr.size = VA_64BIT;
453 		if (v_addr.valid_bits < 32) // may be updating a 64 bit address so only set 32 if currently less.
454 			v_addr.valid_bits = 32;
455 		v_addr.val = (v_addr.val & ~mask) | (addr & mask);
456 	}
457     else
458     {
459 		v_addr.val = addr;
460         v_addr.size = VA_32BIT;
461 		v_addr.valid_bits = 32;
462 	}
463 
464     v_addr_ISA = IS;
465     push_vaddr();
466 }
467 
468 inline void EtmV4ITrcPacket::updateShortAddress(const uint32_t addr, const uint8_t IS, const uint8_t update_bits)
469 {
470     ocsd_vaddr_t update_mask = OCSD_BIT_MASK(update_bits);
471     v_addr.pkt_bits = update_bits;
472     if(v_addr.valid_bits < update_bits)
473         v_addr.valid_bits = update_bits;
474 
475     v_addr.val = (v_addr.val & ~update_mask) | (addr & update_mask);
476     v_addr_ISA = IS;
477     push_vaddr();
478 }
479 
480 inline void EtmV4ITrcPacket::setAddressExactMatch(const uint8_t idx)
481 {
482     addr_exact_match_idx = idx;
483     pop_vaddr_idx(idx);
484     push_vaddr();
485 }
486 
487 inline void EtmV4ITrcPacket::setDataSyncMarker(const uint8_t dsm_value)
488 {
489     dsm_val = dsm_value;
490 }
491 
492 inline void EtmV4ITrcPacket::setEvent(const uint8_t event_value)
493 {
494     event_val = event_value;
495 }
496 
497 inline void EtmV4ITrcPacket::setQType(const bool has_count, const uint32_t count, const bool has_addr, const bool addr_match, const uint8_t type)
498 {
499     Q_pkt.q_count = count;
500     Q_pkt.q_type = type;
501     Q_pkt.count_present = has_count ? 1 : 0;
502     Q_pkt.addr_present = has_addr ? 1: 0;
503     Q_pkt.addr_match = addr_match ? 1 :0;
504 }
505 
506 inline const bool EtmV4ITrcPacket::isBadPacket() const
507 {
508     return (type >= ETM4_PKT_I_BAD_SEQUENCE);
509 }
510 
511 inline void  EtmV4ITrcPacket::push_vaddr()
512 {
513     m_addr_stack.push(v_addr, v_addr_ISA);
514 }
515 
516 inline void EtmV4ITrcPacket::pop_vaddr_idx(const uint8_t idx)
517 {
518     m_addr_stack.get_idx(idx, v_addr, v_addr_ISA);
519 }
520 
521 /** @}*/
522 
523 #endif // ARM_TRC_PKT_ELEM_ETMV4I_H_INCLUDED
524 
525 /* End of File trc_pkt_elem_etmv4i.h */
526