projects / OpenSPARC-T2-DV / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 design and verification files.
[OpenSPARC-T2-DV] / verif / model / vendor / TLM-2006-11-29 / tlm / tlm_bus / tlm_response.h
CommitLineData
86530b38
AT		 1/*****************************************************************************\r
2\r
3 The following code is derived, directly or indirectly, from the SystemC\r
4 source code Copyright (c) 1996-2004 by all Contributors.\r
5 All Rights reserved.\r
6\r
7 The contents of this file are subject to the restrictions and limitations\r
8 set forth in the SystemC Open Source License Version 2.4 (the "License");\r
9 You may not use this file except in compliance with such restrictions and\r
10 limitations. You may obtain instructions on how to receive a copy of the\r
11 License at http://www.systemc.org/. Software distributed by Contributors\r
12 under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF\r
13 ANY KIND, either express or implied. See the License for the specific\r
14 language governing rights and limitations under the License.\r
15\r
16*****************************************************************************/\r
17\r
18\r
19#ifndef _TLM_RESPONSE_H_\r
20#define _TLM_RESPONSE_H_\r
21\r
22/*------------------------------------------------------------------------------\r
23 * Includes \r
24 *----------------------------------------------------------------------------*/\r
25#include "tlm_bus/tlm_custom_base.h"\r
26#include "tlm_bus/tlm_status.h"\r
27\r
28//----------------------------------------------------------------------------\r
29/// Class tlm_response: information returned by the target module\r
30/**\r
31 * It describes the information returned by the target module,including the tlm_status, tlm_metadata and \r
32 * tlm_error_reason to the initiator module.\r
33 **/\r
34 \r
35template<typename DATA,tlm_data_mode DATA_MODE = TLM_PASS_BY_COPY>\r
36class tlm_response {\r
37 \r
38 public:\r
39 \r
40 //---------------\r
41 // Constructors\r
42 //---------------\r
43 \r
44 /// Default constructor\r
45 tlm_response();\r
46 \r
47 /// Copy constructor\r
48 tlm_response(const tlm_response<DATA,DATA_MODE>& response);\r
49 \r
50 //--------------\r
51 // Destructor\r
52 //--------------\r
53 ~tlm_response();\r
54 \r
55 \r
56 //----------------------\r
57 // Cross Mode Assignment operator\r
58 //---------------------- \r
59 template<tlm_data_mode mode>\r
60 tlm_response &operator=( const tlm_response<DATA,mode>& response);\r
61 \r
62 //----------------------\r
63 // Normal Assignment operator\r
64 //---------------------- \r
65 tlm_response &operator=( const tlm_response<DATA,DATA_MODE>& response);\r
66 \r
67 //----------------------\r
68 // Copy from other response object\r
69 //---------------------- \r
70 template<tlm_data_mode mode>\r
71 void copy(const tlm_response<DATA,mode>& response);\r
72\r
73\r
74 //----------------------\r
75 // copy array (data, custom) from other response object\r
76 //------------------------------------------\r
77 template<tlm_data_mode mode>\r
78 inline void copy_arrays(const tlm_response<DATA,mode>& response);\r
79\r
80 //------------------------------------------\r
81 /// @name Data members access methods\r
82 /// @{\r
83 inline const DATA& get_data(const unsigned int index = 0) const;\r
84 inline DATA& get_data(const unsigned int index = 0);\r
85 inline void set_data(const DATA& data,const unsigned int index = 0);\r
86 \r
87 inline const DATA * get_data_ptr() const;\r
88 inline DATA * get_data_ptr();\r
89 inline void set_data_array(const unsigned int size,const DATA * data_ptr = NULL);\r
90 \r
91 inline unsigned int get_block_size() const;\r
92 inline void set_block_size(const unsigned int block_size);\r
93 \r
94 inline const tlm_status& get_status() const;\r
95 inline tlm_status& get_status();\r
96 inline void set_status(const tlm_status& status);\r
97 \r
98 inline unsigned int get_priority() const;\r
99 inline void set_priority(unsigned int priority);\r
100 \r
101 inline unsigned int get_master_thread_id() const;\r
102 inline void set_master_thread_id(unsigned int master_thread_id);\r
103 \r
104 inline unsigned int get_transaction_id() const;\r
105 inline void set_transaction_id(unsigned int transaction_id);\r
106 \r
107 inline unsigned int get_tlm_export_id() const;\r
108 inline void set_tlm_export_id(unsigned int tlm_export_id);\r
109 \r
110 template<typename T >\r
111 inline bool get_custom_ptr( T *& t ) const;\r
112 inline std::vector<tlm_custom_base *> *get_custom_vector_ptr() const;\r
113 inline void set_custom_vector_ptr( std::vector<tlm_custom_base *> *t );\r
114 \r
115 /// @}\r
116 \r
117 protected:\r
118 DATA * m_data; //!< Response data pointer\r
119 unsigned int m_block_size; //!< Determines how many chunks of data are transfered (size of block)\r
120 tlm_status m_status; //!< Response status \r
121 unsigned int m_priority; //!< Priority of the response\r
122 unsigned int m_master_thread_id; //!< Master module thread ID \r
123 unsigned int m_transaction_id; //!< Transaction ID \r
124 unsigned int m_tlm_export_id; //!< export id (used when several exports are used with single interface)\r
125 std::vector<tlm_custom_base *> *m_custom_vector_ptr; //!< Pointer to vector of custom extensions\r
126\r
127private: \r
128 //------------------------------------------\r
129 /// Data copy function. \r
130 static inline void data_copy(DATA * dst,const DATA * src,const unsigned int size);\r
131\r
132\r
133};\r
134\r
135\r
136\r
137//---------------\r
138// Constructors\r
139//---------------\r
140\r
141// Default constructor\r
142template<typename DATA,tlm_data_mode DATA_MODE>\r
143tlm_response<DATA,DATA_MODE>::tlm_response() :\r
144 m_data(0),\r
145 m_block_size(0),\r
146 m_status(),\r
147 m_priority(0),\r
148 m_master_thread_id( 0 ),\r
149 m_transaction_id(0),\r
150 m_tlm_export_id(0),\r
151 m_custom_vector_ptr( 0 )\r
152{}\r
153\r
154\r
155// Copy constructor\r
156template<typename DATA,tlm_data_mode DATA_MODE>\r
157tlm_response<DATA,DATA_MODE>::tlm_response(const tlm_response<DATA,DATA_MODE>& response) :\r
158 m_data(0),\r
159 m_block_size(response.m_block_size),\r
160 m_status(response.m_status),\r
161 m_priority(response.m_priority),\r
162 m_master_thread_id( response.m_master_thread_id ),\r
163 m_transaction_id(response.m_transaction_id),\r
164 m_tlm_export_id( response.m_tlm_export_id ),\r
165 m_custom_vector_ptr(0)\r
166{\r
167 copy_arrays( response );\r
168}\r
169 \r
170\r
171//--------------\r
172// Destructor\r
173//--------------\r
174template<typename DATA,tlm_data_mode DATA_MODE>\r
175tlm_response<DATA,DATA_MODE>::~tlm_response() {\r
176\r
177 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
178\r
179 if (m_data) delete [] m_data;\r
180\r
181 if( m_custom_vector_ptr != 0 ) {\r
182 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
183 delete (*m_custom_vector_ptr)[i];\r
184 }\r
185 delete m_custom_vector_ptr;\r
186 }\r
187 }\r
188}\r
189\r
190\r
191//----------------------\r
192// Cross Mode Assignment operator\r
193//----------------------\r
194template<typename DATA,tlm_data_mode DATA_MODE>\r
195template<tlm_data_mode mode>\r
196tlm_response<DATA,DATA_MODE>& tlm_response<DATA,DATA_MODE>::operator=( const tlm_response<DATA,mode>& response) {\r
197 copy( response );\r
198 return *this;\r
199}\r
200\r
201//----------------------\r
202// Normal Assignment operator\r
203//----------------------\r
204template<typename DATA,tlm_data_mode DATA_MODE> \r
205tlm_response<DATA,DATA_MODE>& tlm_response<DATA,DATA_MODE>::operator=( const tlm_response<DATA,DATA_MODE>& response) {\r
206 copy( response );\r
207 return *this;\r
208}\r
209\r
210\r
211\r
212//----------------------\r
213// Copy from other response object\r
214//---------------------- \r
215template<typename DATA,tlm_data_mode DATA_MODE> \r
216template<tlm_data_mode mode>\r
217inline void tlm_response<DATA,DATA_MODE>::copy(const tlm_response<DATA,mode>& response) {\r
218\r
219 copy_arrays( response );\r
220\r
221 m_block_size = response.get_block_size();\r
222 m_status = response.get_status();\r
223 m_priority = response.get_priority();\r
224 m_master_thread_id = response.get_master_thread_id();\r
225 m_transaction_id = response.get_transaction_id();\r
226 m_tlm_export_id = response.get_tlm_export_id();\r
227\r
228} \r
229\r
230//----------------------\r
231// copy array (data, custom) from other response object\r
232//----------------------\r
233template<typename DATA,tlm_data_mode DATA_MODE>\r
234template<tlm_data_mode mode>\r
235inline void tlm_response<DATA,DATA_MODE>::copy_arrays(const tlm_response<DATA,mode>& response) {\r
236 \r
237 if ( response.get_data_ptr() ) set_data_array( response.get_block_size(), response.get_data_ptr() );\r
238 else m_data = NULL;\r
239\r
240 set_custom_vector_ptr( response.get_custom_vector_ptr() );\r
241}\r
242\r
243\r
244//------------------------------------------\r
245// Data members access methods\r
246\r
247template<typename DATA,tlm_data_mode DATA_MODE>\r
248inline const DATA& tlm_response<DATA,DATA_MODE>::get_data(const unsigned int index) const {\r
249 assert(m_data != 0);\r
250 assert(index < m_block_size);\r
251 return(m_data[index]);\r
252}\r
253\r
254template<typename DATA,tlm_data_mode DATA_MODE>\r
255inline DATA& tlm_response<DATA,DATA_MODE>::get_data(const unsigned int index) {\r
256 assert(m_data != 0);\r
257 assert(index < m_block_size);\r
258 return(m_data[index]);\r
259}\r
260 \r
261template<typename DATA,tlm_data_mode DATA_MODE>\r
262inline void tlm_response<DATA,DATA_MODE>::set_data(const DATA& data,const unsigned int index) { \r
263 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
264 if (!m_data) m_data = new DATA[index+1];\r
265 else {\r
266 if (m_block_size<(index+1)) {\r
267 DATA * tmp = new DATA[m_block_size];\r
268 data_copy(tmp,m_data,m_block_size);\r
269 delete [] m_data;\r
270 m_data = new DATA[index+1];\r
271 this->data_copy(m_data,tmp,m_block_size);\r
272 delete [] tmp; \r
273 }\r
274 }\r
275 m_block_size = index+1;\r
276 }\r
277 else {\r
278 assert(m_data != 0);\r
279 assert(index < m_block_size);\r
280 }\r
281 m_data[index] = data;\r
282}\r
283\r
284template<typename DATA,tlm_data_mode DATA_MODE>\r
285inline const DATA * tlm_response<DATA,DATA_MODE>::get_data_ptr() const { return(m_data); }\r
286\r
287template<typename DATA,tlm_data_mode DATA_MODE>\r
288inline DATA * tlm_response<DATA,DATA_MODE>::get_data_ptr() { return(m_data); }\r
289\r
290template<typename DATA,tlm_data_mode DATA_MODE>\r
291inline void tlm_response<DATA,DATA_MODE>::set_data_array(const unsigned int size,const DATA * data_ptr) { \r
292 if (size) m_block_size = size;\r
293 else m_block_size = 1; //default value\r
294 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
295 if (m_data) delete [] m_data;\r
296 if (size) m_data = new DATA[size];\r
297 else m_data = NULL; // default value\r
298 if (data_ptr) data_copy(m_data,data_ptr,size);\r
299 }\r
300 else m_data = const_cast<DATA *>(data_ptr);\r
301}\r
302\r
303\r
304template<typename DATA,tlm_data_mode DATA_MODE>\r
305inline unsigned int tlm_response<DATA,DATA_MODE>::get_block_size() const { return(m_block_size); }\r
306\r
307template<typename DATA,tlm_data_mode DATA_MODE>\r
308inline void tlm_response<DATA,DATA_MODE>::set_block_size(const unsigned int block_size) { m_block_size = block_size; }\r
309\r
310template<typename DATA,tlm_data_mode DATA_MODE>\r
311inline const tlm_status& tlm_response<DATA,DATA_MODE>::get_status() const { return(m_status); }\r
312\r
313template<typename DATA,tlm_data_mode DATA_MODE>\r
314inline tlm_status& tlm_response<DATA,DATA_MODE>::get_status() { return(m_status); }\r
315\r
316template<typename DATA,tlm_data_mode DATA_MODE>\r
317inline void tlm_response<DATA,DATA_MODE>::set_status(const tlm_status& status) { m_status = status; }\r
318\r
319\r
320template<typename DATA,tlm_data_mode DATA_MODE>\r
321inline unsigned int tlm_response<DATA,DATA_MODE>::get_priority() const { return(m_priority); } \r
322\r
323template<typename DATA,tlm_data_mode DATA_MODE>\r
324inline void tlm_response<DATA,DATA_MODE>::set_priority(unsigned int priority) { m_priority = priority; }\r
325\r
326template<typename DATA,tlm_data_mode DATA_MODE>\r
327inline unsigned int tlm_response<DATA,DATA_MODE>::get_transaction_id() const { return(m_transaction_id); } \r
328\r
329template<typename DATA,tlm_data_mode DATA_MODE>\r
330inline void tlm_response<DATA,DATA_MODE>::set_transaction_id(unsigned int transaction_id) { m_transaction_id = transaction_id; }\r
331\r
332template<typename DATA,tlm_data_mode DATA_MODE>\r
333inline unsigned int tlm_response<DATA,DATA_MODE>::get_master_thread_id() const { return(m_master_thread_id); } \r
334\r
335template<typename DATA,tlm_data_mode DATA_MODE>\r
336inline void tlm_response<DATA,DATA_MODE>::set_master_thread_id(unsigned int master_thread_id ) { m_master_thread_id = master_thread_id; }\r
337\r
338template<typename DATA,tlm_data_mode DATA_MODE>\r
339inline unsigned int tlm_response<DATA,DATA_MODE>::get_tlm_export_id() const { return(m_tlm_export_id); } \r
340\r
341template<typename DATA,tlm_data_mode DATA_MODE>\r
342inline void tlm_response<DATA,DATA_MODE>::set_tlm_export_id(unsigned int tlm_export_id) { m_tlm_export_id = tlm_export_id; }\r
343\r
344\r
345template<typename DATA,tlm_data_mode DATA_MODE> \r
346template<typename T >\r
347inline bool tlm_response<DATA,DATA_MODE>::get_custom_ptr( T *& t ) const {\r
348 \r
349 if( m_custom_vector_ptr == 0 ) return false;\r
350 \r
351 std::vector<tlm_custom_base *> &v = *m_custom_vector_ptr;\r
352 \r
353 for( unsigned int i = 0; i < v.size(); i++ ) {\r
354 if( (t = dynamic_cast< T *>( v[i] )) ) {\r
355 return true;\r
356 }\r
357 } \r
358 return false; \r
359}\r
360\r
361\r
362template<typename DATA,tlm_data_mode DATA_MODE>\r
363inline std::vector<tlm_custom_base *> *\r
364tlm_response<DATA,DATA_MODE>::get_custom_vector_ptr() const { return m_custom_vector_ptr;}\r
365\r
366\r
367template<typename DATA,tlm_data_mode DATA_MODE>\r
368inline void tlm_response<DATA,DATA_MODE>::set_custom_vector_ptr( std::vector<tlm_custom_base *> *t ) {\r
369\r
370 if( DATA_MODE == TLM_PASS_BY_POINTER ) {\r
371 m_custom_vector_ptr = t;\r
372 return;\r
373 }\r
374\r
375 if( m_custom_vector_ptr != 0 ) {\r
376\r
377 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
378 delete (*m_custom_vector_ptr)[i];\r
379 }\r
380 delete m_custom_vector_ptr;\r
381 }\r
382\r
383 if( t == 0 ) {\r
384 m_custom_vector_ptr = 0;\r
385 return;\r
386 }\r
387\r
388 m_custom_vector_ptr = new std::vector<tlm_custom_base *>( t->size() );\r
389\r
390 tlm_custom_base *t_custom_ptr;\r
391 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
392 if( (t_custom_ptr = (*t)[i]) ) {\r
393 (*m_custom_vector_ptr)[i] = t_custom_ptr->clone();\r
394 }\r
395 }\r
396\r
397}\r
398\r
399\r
400\r
401\r
402//------------------------------------------\r
403/// Data copy function. Generic implementation\r
404template<typename DATA,tlm_data_mode DATA_MODE>\r
405inline void tlm_response<DATA,DATA_MODE>::data_copy(DATA * dst,const DATA * src,const unsigned int size) {\r
406 for(unsigned int i = 0;i < size;i++)\r
407 dst[i] = src[i];\r
408}\r
409 \r
410\r
411\r
412 \r
413#define TLM_RESPONSE_SCALAR_DATA_COPY(DATA,DATA_MODE)\\r
414 template<>\\r
415 inline void tlm_response<DATA,DATA_MODE>::data_copy(DATA * dst,const DATA * src,const unsigned int size) { \\r
416 memcpy(dst,src,size*get_nb_byte<DATA>());\\r
417 }\r
418 \r
419TLM_RESPONSE_SCALAR_DATA_COPY(tlm_sint8_t,TLM_PASS_BY_COPY);\r
420TLM_RESPONSE_SCALAR_DATA_COPY(tlm_uint8_t,TLM_PASS_BY_COPY);\r
421TLM_RESPONSE_SCALAR_DATA_COPY(tlm_uint16_t,TLM_PASS_BY_COPY);\r
422TLM_RESPONSE_SCALAR_DATA_COPY(tlm_sint16_t,TLM_PASS_BY_COPY);\r
423TLM_RESPONSE_SCALAR_DATA_COPY(int,TLM_PASS_BY_COPY);\r
424TLM_RESPONSE_SCALAR_DATA_COPY(unsigned int,TLM_PASS_BY_COPY);\r
425TLM_RESPONSE_SCALAR_DATA_COPY(tlm_uint32_t,TLM_PASS_BY_COPY);\r
426TLM_RESPONSE_SCALAR_DATA_COPY(tlm_sint32_t,TLM_PASS_BY_COPY);\r
427TLM_RESPONSE_SCALAR_DATA_COPY(tlm_uint64_t,TLM_PASS_BY_COPY);\r
428TLM_RESPONSE_SCALAR_DATA_COPY(tlm_sint64_t,TLM_PASS_BY_COPY);\r
429\r
430\r
431#endif /* _TLM_RESPONSE_H_ */\r
432\r
433\r
Full OpenSPARC design & verification tarball including full HDL.