]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/opencsd/decoder/include/common/trc_pkt_decode_base.h
Re-add opencsd as a vendor import from the dist directory
[FreeBSD/FreeBSD.git] / contrib / opencsd / decoder / include / common / trc_pkt_decode_base.h
1 /*!
2  * \file       trc_pkt_decode_base.h
3  * \brief      OpenCSD : Trace Packet decoder base class.
4  * 
5  * \copyright  Copyright (c) 2015, ARM Limited. All Rights Reserved.
6  */
7
8 /* 
9  * Redistribution and use in source and binary forms, with or without modification, 
10  * are permitted provided that the following conditions are met:
11  * 
12  * 1. Redistributions of source code must retain the above copyright notice, 
13  * this list of conditions and the following disclaimer.
14  * 
15  * 2. Redistributions in binary form must reproduce the above copyright notice, 
16  * this list of conditions and the following disclaimer in the documentation 
17  * and/or other materials provided with the distribution. 
18  * 
19  * 3. Neither the name of the copyright holder nor the names of its contributors 
20  * may be used to endorse or promote products derived from this software without 
21  * specific prior written permission. 
22  * 
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND 
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
26  * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
27  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
28  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
30  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
33  */ 
34
35 #ifndef ARM_TRC_PKT_DECODE_BASE_H_INCLUDED
36 #define ARM_TRC_PKT_DECODE_BASE_H_INCLUDED
37
38 #include "trc_component.h"
39 #include "comp_attach_pt_t.h"
40
41 #include "interfaces/trc_pkt_in_i.h"
42 #include "interfaces/trc_gen_elem_in_i.h"
43 #include "interfaces/trc_tgt_mem_access_i.h"
44 #include "interfaces/trc_instr_decode_i.h"
45
46 /** @defgroup ocsd_pkt_decode OpenCSD Library : Packet Decoders.
47
48     @brief Classes providing Protocol Packet Decoding capability.
49
50     Packet decoders convert incoming protocol packets from a packet processor,
51     into generic trace elements to be output to an analysis program.
52
53     Packet decoders can be:-
54     - PE decoders - converting ETM or PTM packets into instruction and data trace elements
55     - SW stimulus decoder - converting STM or ITM packets into software generated trace elements.
56     - Bus decoders - converting HTM packets into bus transaction elements.
57
58 @{*/
59
60
61 class TrcPktDecodeI : public TraceComponent
62 {
63 public:
64     TrcPktDecodeI(const char *component_name);
65     TrcPktDecodeI(const char *component_name, int instIDNum);
66     virtual ~TrcPktDecodeI() {};
67
68     componentAttachPt<ITrcGenElemIn> *getTraceElemOutAttachPt() { return &m_trace_elem_out; };
69     componentAttachPt<ITargetMemAccess> *getMemoryAccessAttachPt() { return &m_mem_access; };
70     componentAttachPt<IInstrDecode> *getInstrDecodeAttachPt() { return &m_instr_decode; };
71
72     void setUsesMemAccess(bool bUsesMemaccess) { m_uses_memaccess = bUsesMemaccess; };
73     const bool getUsesMemAccess() const { return m_uses_memaccess; };
74
75     void setUsesIDecode(bool bUsesIDecode) { m_uses_idecode = bUsesIDecode; };
76     const bool getUsesIDecode() const { return m_uses_idecode; };
77
78 protected:
79
80     /* implementation packet decoding interface */
81     virtual ocsd_datapath_resp_t processPacket() = 0;
82     virtual ocsd_datapath_resp_t onEOT() = 0;
83     virtual ocsd_datapath_resp_t onReset() = 0;
84     virtual ocsd_datapath_resp_t onFlush() = 0;
85     virtual ocsd_err_t onProtocolConfig() = 0;
86     virtual const uint8_t getCoreSightTraceID() = 0;
87
88     const bool checkInit();
89
90     /* data output */
91     ocsd_datapath_resp_t outputTraceElement(const OcsdTraceElement &elem);    // use current index
92     ocsd_datapath_resp_t outputTraceElementIdx(ocsd_trc_index_t idx, const OcsdTraceElement &elem); // use supplied index (where decoder caches elements) 
93
94     /* target access */
95     ocsd_err_t accessMemory(const ocsd_vaddr_t address, const ocsd_mem_space_acc_t mem_space, uint32_t *num_bytes, uint8_t *p_buffer);
96
97     /* instruction decode */
98     ocsd_err_t instrDecode(ocsd_instr_info *instr_info);
99
100     componentAttachPt<ITrcGenElemIn> m_trace_elem_out;
101     componentAttachPt<ITargetMemAccess> m_mem_access;
102     componentAttachPt<IInstrDecode> m_instr_decode;
103
104     ocsd_trc_index_t   m_index_curr_pkt;
105
106     bool m_decode_init_ok;  //!< set true if all attachments in place for decode. (remove checks in main throughput paths)
107     bool m_config_init_ok;  //!< set true if config set.
108
109     std::string init_err_msg;    //!< error message for init error
110
111     bool m_uses_memaccess;
112     bool m_uses_idecode;
113
114 };
115
116 inline TrcPktDecodeI::TrcPktDecodeI(const char *component_name) : 
117     TraceComponent(component_name),
118     m_index_curr_pkt(0),
119     m_decode_init_ok(false),
120     m_config_init_ok(false),
121     m_uses_memaccess(true),
122     m_uses_idecode(true)
123 {
124 }
125
126 inline TrcPktDecodeI::TrcPktDecodeI(const char *component_name, int instIDNum) :
127     TraceComponent(component_name, instIDNum),
128     m_index_curr_pkt(0),
129     m_decode_init_ok(false),
130     m_config_init_ok(false),
131     m_uses_memaccess(true),
132     m_uses_idecode(true)
133 {
134 }
135
136 inline const bool TrcPktDecodeI::checkInit()
137 {
138     if(!m_decode_init_ok)
139     {
140         if(!m_config_init_ok)
141             init_err_msg = "No decoder configuration information";
142         else if(!m_trace_elem_out.hasAttachedAndEnabled())
143             init_err_msg = "No element output interface attached and enabled";
144         else if(m_uses_memaccess && !m_mem_access.hasAttachedAndEnabled())
145             init_err_msg = "No memory access interface attached and enabled";
146         else if(m_uses_idecode && !m_instr_decode.hasAttachedAndEnabled())
147             init_err_msg = "No instruction decoder interface attached and enabled";
148         else
149             m_decode_init_ok = true;
150     }
151     return m_decode_init_ok;
152 }
153
154 inline ocsd_datapath_resp_t TrcPktDecodeI::outputTraceElement(const OcsdTraceElement &elem)
155 {
156     return m_trace_elem_out.first()->TraceElemIn(m_index_curr_pkt,getCoreSightTraceID(), elem);
157 }
158
159 inline ocsd_datapath_resp_t TrcPktDecodeI::outputTraceElementIdx(ocsd_trc_index_t idx, const OcsdTraceElement &elem)
160 {
161     return m_trace_elem_out.first()->TraceElemIn(idx, getCoreSightTraceID(), elem);
162 }
163
164 inline ocsd_err_t TrcPktDecodeI::instrDecode(ocsd_instr_info *instr_info)
165 {
166     if(m_uses_idecode)
167         return m_instr_decode.first()->DecodeInstruction(instr_info);
168     return OCSD_ERR_DCD_INTERFACE_UNUSED;
169 }
170
171 inline ocsd_err_t TrcPktDecodeI::accessMemory(const ocsd_vaddr_t address, const ocsd_mem_space_acc_t mem_space, uint32_t *num_bytes, uint8_t *p_buffer)
172 {
173     if(m_uses_memaccess)
174         return m_mem_access.first()->ReadTargetMemory(address,getCoreSightTraceID(),mem_space, num_bytes,p_buffer);
175     return OCSD_ERR_DCD_INTERFACE_UNUSED;
176 }
177
178 /**********************************************************************/
179 template <class P, class Pc>
180 class TrcPktDecodeBase : public TrcPktDecodeI, public IPktDataIn<P>
181 {
182 public:
183     TrcPktDecodeBase(const char *component_name);
184     TrcPktDecodeBase(const char *component_name, int instIDNum);
185     virtual ~TrcPktDecodeBase();
186
187     virtual ocsd_datapath_resp_t PacketDataIn( const ocsd_datapath_op_t op,
188                                                 const ocsd_trc_index_t index_sop,
189                                                 const P *p_packet_in);
190     
191
192     /* protocol configuration */
193     ocsd_err_t setProtocolConfig(const Pc *config); 
194     const Pc *  getProtocolConfig() const { return  m_config; };
195     
196 protected:
197     void ClearConfigObj();
198
199     /* the protocol configuration */
200     Pc *          m_config;
201     /* the current input packet */
202     const P *     m_curr_packet_in;
203     
204 };
205
206
207 template <class P, class Pc> TrcPktDecodeBase<P, Pc>::TrcPktDecodeBase(const char *component_name) : 
208     TrcPktDecodeI(component_name),
209     m_config(0)
210 {
211 }
212
213 template <class P, class Pc> TrcPktDecodeBase<P, Pc>::TrcPktDecodeBase(const char *component_name, int instIDNum) : 
214     TrcPktDecodeI(component_name,instIDNum),
215     m_config(0)
216 {
217 }
218
219 template <class P, class Pc> TrcPktDecodeBase<P, Pc>::~TrcPktDecodeBase() 
220 {
221     ClearConfigObj();
222 }
223
224 template <class P, class Pc> ocsd_datapath_resp_t TrcPktDecodeBase<P, Pc>::PacketDataIn( const ocsd_datapath_op_t op,
225                                                 const ocsd_trc_index_t index_sop,
226                                                 const P *p_packet_in)
227 {
228     ocsd_datapath_resp_t resp = OCSD_RESP_CONT;
229     if(!checkInit())
230     {
231         LogError(ocsdError(OCSD_ERR_SEV_ERROR,OCSD_ERR_NOT_INIT,init_err_msg));
232         return OCSD_RESP_FATAL_NOT_INIT;
233     }
234
235     switch(op)
236     {
237     case OCSD_OP_DATA:
238         if(p_packet_in == 0)
239         {
240             LogError(ocsdError(OCSD_ERR_SEV_ERROR,OCSD_ERR_INVALID_PARAM_VAL));
241             resp = OCSD_RESP_FATAL_INVALID_PARAM;
242         }
243         else
244         {
245             m_curr_packet_in = p_packet_in;
246             m_index_curr_pkt = index_sop;
247             resp = processPacket();
248         }
249         break;
250
251     case OCSD_OP_EOT:
252         resp = onEOT();
253         break;
254
255     case OCSD_OP_FLUSH:
256         resp = onFlush();
257         break;
258
259     case OCSD_OP_RESET:
260         resp = onReset();
261         break;
262
263     default:
264         LogError(ocsdError(OCSD_ERR_SEV_ERROR,OCSD_ERR_INVALID_PARAM_VAL));
265         resp = OCSD_RESP_FATAL_INVALID_OP;
266         break;
267     }
268     return resp;
269 }
270
271     /* protocol configuration */
272 template <class P, class Pc>  ocsd_err_t TrcPktDecodeBase<P, Pc>::setProtocolConfig(const Pc *config)
273 {
274     ocsd_err_t err = OCSD_ERR_INVALID_PARAM_VAL;
275     if(config != 0)
276     {
277         ClearConfigObj(); // remove any current config
278         m_config = new (std::nothrow) Pc(*config); // make a copy of the config - don't rely on the object passed in being valid outside the context of the call.
279         if(m_config != 0)
280         {
281             err = onProtocolConfig();
282             if(err == OCSD_OK)
283                 m_config_init_ok = true;
284         }
285         else
286             err = OCSD_ERR_MEM;
287     }
288     return err;
289 }
290
291 template <class P, class Pc> void TrcPktDecodeBase<P, Pc>::ClearConfigObj()
292 {
293     if(m_config)
294     {
295         delete m_config;
296         m_config = 0;
297     }
298 }
299
300 /** @}*/
301 #endif // ARM_TRC_PKT_DECODE_BASE_H_INCLUDED
302
303 /* End of File trc_pkt_decode_base.h */