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_request.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_REQUEST_H_\r
20#define _TLM_REQUEST_H_\r
21\r
22/*------------------------------------------------------------------------------\r
23 * Includes \r
24 *----------------------------------------------------------------------------*/\r
25#include "tlm_bus/tlm_byte_enable.h"\r
26#include "tlm_bus/tlm_custom_base.h"\r
27\r
28\r
29/*------------------------------------------------------------------------------\r
30 * Constants\r
31 *----------------------------------------------------------------------------*/\r
32/** \defgroup request_command Initiator request command\r
33 * Initiator request command type or request opcode \r
34 * @{\r
35 **/\r
36enum tlm_command {\r
37 READ, ///< Command to issue a read operation\r
38 WRITE ///< Command to issue a write operation\r
39};\r
40/* @} */\r
41 \r
42\r
43/** \defgroup request_mode Initiator request command mode\r
44 * Initiator request command mode \r
45 * @{\r
46 **/\r
47enum tlm_mode {\r
48 REGULAR, ///< Regular access\r
49 DEBUG, /*!< Debug access, all wait() statements must be by-passed and side effects \r
50 * in target implementation (clear register on read process activation) should not occur\r
51 **/\r
52 CONTROL ///< Indicates simulation control transaction\r
53\r
54};\r
55\r
56/* @} */\r
57\r
58\r
59/** \defgroup request_block_mode Initiator block request mode\r
60 * Initiator block request mode \r
61 * @{\r
62 **/\r
63enum tlm_block_mode {\r
64 INCREMENT, ///< The address is incremented for each chunk of data. The increment value depend on request parameter "block_address_incr"\r
65 STREAMING, ///< The address is always the same\r
66 WRAP ///< wraps at word boundaries\r
67};\r
68\r
69//\r
70// For example, assuming byte addressing and 32 bit words :\r
71// address = 8, block_size = 4, block_mode = INCREMENT, block_address_incr = 4 would address 0x8, 0xc, 0x10, 0x14\r
72// address = 8, block_size = 4, block_mode = WRAP, block_address_incr = 4 would address 0x8, 0xc, 0x0, 0x4 because\r
73// there is a word boundary at 0x10.\r
74//\r
75/* @} */\r
76\r
77 \r
78\r
79//----------------------------------------------------------------------------\r
80/// Class tlm_request: information sent by the initiator module to the target module\r
81/**\r
82 * It describes the information sent by the initiator module to the target module.\r
83\r
84**/\r
85template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE = TLM_PASS_BY_COPY>\r
86class tlm_request {\r
87 \r
88public:\r
89 \r
90 //----------------\r
91 // Constructors\r
92 //---------------\r
93\r
94 /// Default constructor\r
95 tlm_request();\r
96\r
97 /// Copy constructor\r
98 tlm_request(const tlm_request<ADDRESS,DATA,DATA_MODE>& request);\r
99\r
100 //--------------\r
101 // Destructor\r
102 //--------------\r
103 ~tlm_request(); \r
104\r
105 //----------------------\r
106 // Cross Mode Assignment operator\r
107 //----------------------\r
108 template< tlm_data_mode mode >\r
109 tlm_request& operator=(const tlm_request<ADDRESS,DATA,mode>& request);\r
110\r
111 //----------------------\r
112 // Normal Assignment operator\r
113 //----------------------\r
114 tlm_request& operator=(const tlm_request<ADDRESS,DATA,DATA_MODE>& request );\r
115\r
116 //----------------------\r
117 // Copy from other request object\r
118 //---------------------- \r
119 template< tlm_data_mode from_mode >\r
120 inline void copy( const tlm_request<ADDRESS,DATA,from_mode>& request);\r
121\r
122 //----------------------\r
123 // copy array (data, byte_enable, custom) from other request object\r
124 //---------------------- \r
125 template< tlm_data_mode from_mode >\r
126 inline void copy_arrays( const tlm_request<ADDRESS,DATA,from_mode>& request);\r
127\r
128 //------------------------------------------\r
129 //\r
130 // @name Data members command methods\r
131 /// @{\r
132 inline tlm_command get_command() const;\r
133 inline void set_command(const tlm_command command);\r
134\r
135 inline tlm_mode get_mode() const;\r
136 inline void set_mode(const tlm_mode mode);\r
137\r
138 inline bool is_regular_access() const;\r
139 inline bool is_debug_access() const;\r
140 inline bool is_timed_access() const;\r
141 inline bool is_control_access() const;\r
142\r
143 inline ADDRESS get_address() const;\r
144 inline void set_address(const ADDRESS address);\r
145\r
146 inline const DATA& get_data(const unsigned int index = 0) const;\r
147 inline void set_data(const DATA& data,const unsigned int index = 0);\r
148 \r
149 inline const DATA * get_data_ptr() const;\r
150 inline void set_data_array(const unsigned int size,const DATA * data_ptr = NULL);\r
151\r
152 inline unsigned int get_block_size() const;\r
153 inline void set_block_size(const unsigned int block_size);\r
154\r
155 inline unsigned int get_byte_enable(const unsigned int index = 0) const;\r
156 inline void set_byte_enable(const unsigned int byte_enable,const unsigned int index = 0);\r
157\r
158 inline const unsigned int * get_byte_enable_ptr() const;\r
159 inline void set_byte_enable_array(const unsigned int size,const unsigned int * byte_enable_ptr = NULL);\r
160\r
161 inline unsigned int get_byte_enable_period() const;\r
162 inline void set_byte_enable_period(const unsigned int byte_enable_period);\r
163\r
164 inline tlm_block_mode get_block_mode() const;\r
165 inline void set_block_mode(tlm_block_mode block_mode);\r
166\r
167 inline unsigned int get_block_address_incr() const;\r
168 inline void set_block_address_incr(unsigned int block_address_incr);\r
169\r
170 inline unsigned int get_master_thread_id() const;\r
171 inline void set_master_thread_id(unsigned int master_thread_id);\r
172\r
173 inline unsigned int get_priority() const;\r
174 inline void set_priority(unsigned int priority);\r
175\r
176 inline unsigned int get_transaction_id() const;\r
177 inline void set_transaction_id(unsigned int transaction_id);\r
178\r
179 inline unsigned int get_tlm_export_id() const;\r
180 inline void set_tlm_export_id(unsigned int tlm_export_id);\r
181\r
182 template<typename T >\r
183 inline bool get_custom_ptr( T *& t ) const;\r
184 inline std::vector<tlm_custom_base *> *get_custom_vector_ptr() const;\r
185 inline void set_custom_vector_ptr( std::vector<tlm_custom_base *> *t );\r
186\r
187\r
188 /// @}\r
189\r
190\r
191protected:\r
192 tlm_command m_command; //!< Command type (READ,WRITE)\r
193 tlm_mode m_mode; //!< Request access mode (REGULAR,DEBUG and CONTROL)\r
194 ADDRESS m_address; //!< Request address \r
195 DATA * m_data; //!< Request data pointer\r
196 unsigned int m_block_size; //!< Determines how many chunks of data are transferred (size of block)\r
197 const unsigned int * m_byte_enable; //!< Byte enable array pointer (no byte_enable if NULL)\r
198 unsigned int m_byte_enable_period; /*!< Byte enable period: in case of block transfer (m_block_size != 1) \r
199 * with byte enable, size of byte enable array if not null.\r
200 **/\r
201 tlm_block_mode m_block_mode; //!< Specifies address behavior in case of block tranfer (INCREMENT,STREAMING,WRAPP)\r
202 unsigned int m_block_address_incr; //!< In case of INCREMENT block mode, value of the address increment\r
203 unsigned int m_priority; //!< Priority of the request\r
204 unsigned int m_master_thread_id; //!< Master module thread ID \r
205 unsigned int m_transaction_id; //!< Transaction ID \r
206 unsigned int m_tlm_export_id; //!< export id (used when several exports are used with single interface)\r
207 std::vector<tlm_custom_base *> *m_custom_vector_ptr; //!< Pointer to vector of custom extensions\r
208\r
209private:\r
210 //------------------------------------------\r
211 /// Data copy function. \r
212 static inline void data_copy(DATA * dst,const DATA * src,const unsigned int size); \r
213\r
214};\r
215\r
216\r
217\r
218\r
219//----------------\r
220// Constructors\r
221//---------------\r
222\r
223// Default constructor\r
224template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
225tlm_request<ADDRESS,DATA,DATA_MODE>::tlm_request() : \r
226 m_command(READ),\r
227 m_mode(REGULAR),\r
228 m_address(0),\r
229 m_data(NULL),\r
230 m_block_size(1),\r
231 m_byte_enable(NULL),\r
232 m_byte_enable_period(0),\r
233 m_block_mode(INCREMENT),\r
234 m_block_address_incr(0),\r
235 m_master_thread_id(0),\r
236 m_transaction_id(0) ,\r
237 m_tlm_export_id( 0 ) ,\r
238 m_custom_vector_ptr( 0 )\r
239{}\r
240\r
241\r
242// Copy constructor\r
243template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
244tlm_request<ADDRESS,DATA,DATA_MODE>::tlm_request(const tlm_request<ADDRESS,DATA,DATA_MODE>& request) :\r
245 m_command(request.m_command),\r
246 m_mode(request.m_mode),\r
247 m_address(request.m_address),\r
248 m_data(0),\r
249 m_block_size(request.m_block_size),\r
250 m_byte_enable(0),\r
251 m_byte_enable_period(request.m_byte_enable_period),\r
252 m_block_mode(request.m_block_mode),\r
253 m_block_address_incr(request.m_block_address_incr),\r
254 m_priority(request.m_priority),\r
255 m_master_thread_id(request.m_master_thread_id),\r
256 m_transaction_id(request.m_transaction_id),\r
257 m_tlm_export_id( request.m_tlm_export_id ),\r
258 m_custom_vector_ptr( 0 )\r
259{\r
260 copy_arrays( request );\r
261}\r
262\r
263\r
264//--------------\r
265// Destructor\r
266//--------------\r
267template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
268tlm_request<ADDRESS,DATA,DATA_MODE>::~tlm_request() {\r
269\r
270 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
271\r
272 if (m_data) delete [] m_data;\r
273 if (m_byte_enable) delete [] m_byte_enable;\r
274\r
275 if( m_custom_vector_ptr != 0 ) {\r
276 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
277 delete (*m_custom_vector_ptr)[i];\r
278 }\r
279 delete m_custom_vector_ptr;\r
280 }\r
281\r
282 }\r
283}\r
284 \r
285\r
286\r
287//----------------------\r
288// Cross Mode Assignment operator\r
289//----------------------\r
290template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
291template< tlm_data_mode mode >\r
292tlm_request<ADDRESS,DATA,DATA_MODE>& tlm_request<ADDRESS,DATA,DATA_MODE>::operator=(const tlm_request<ADDRESS,DATA,mode>& request)\r
293{\r
294 copy( request );\r
295 return *this;\r
296}\r
297\r
298//----------------------\r
299// Normal Assignment operator\r
300//----------------------\r
301template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
302tlm_request<ADDRESS,DATA,DATA_MODE>& tlm_request<ADDRESS,DATA,DATA_MODE>::operator=(const tlm_request<ADDRESS,DATA,DATA_MODE>& request )\r
303{\r
304 copy( request );\r
305 return *this;\r
306}\r
307\r
308//----------------------\r
309// Copy from other request object\r
310//---------------------- \r
311template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
312template< tlm_data_mode from_mode >\r
313inline void tlm_request<ADDRESS,DATA,DATA_MODE>::copy( const tlm_request<ADDRESS,DATA,from_mode>& request) {\r
314\r
315 copy_arrays( request );\r
316 \r
317 m_command = request.get_command();\r
318 m_mode = request.get_mode();\r
319 m_address = request.get_address(); \r
320 m_byte_enable_period = request.get_byte_enable_period();\r
321 m_block_size = request.get_block_size();\r
322 m_block_mode = request.get_block_mode();\r
323 m_block_address_incr = request.get_block_address_incr();\r
324 m_priority = request.get_priority();\r
325 m_master_thread_id = request.get_master_thread_id();\r
326 m_transaction_id = request.get_transaction_id(); \r
327}\r
328\r
329//----------------------\r
330// copy array (data, byte_enable, custom) from other request object\r
331//----------------------\r
332template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
333template< tlm_data_mode from_mode >\r
334inline void tlm_request<ADDRESS,DATA,DATA_MODE>::copy_arrays( const tlm_request<ADDRESS,DATA,from_mode>& request) {\r
335 \r
336 if (request.get_data_ptr() ) set_data_array(request.get_block_size(),request.get_data_ptr());\r
337 else m_data = NULL;\r
338 \r
339 if (request.get_byte_enable_ptr()) {\r
340 int byte_enable_period = request.get_byte_enable_period();\r
341 \r
342 if( byte_enable_period == 0 ) byte_enable_period = request.get_block_size();\r
343 \r
344 set_byte_enable_array( byte_enable_period ,\r
345 request.get_byte_enable_ptr());\r
346 } \r
347 else m_byte_enable = NULL;\r
348 \r
349 set_custom_vector_ptr( request.get_custom_vector_ptr() );\r
350}\r
351\r
352 \r
353//------------------------------------------\r
354// Data members command methods\r
355template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
356inline tlm_command tlm_request<ADDRESS,DATA,DATA_MODE>::get_command() const { return(m_command); }\r
357\r
358template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
359inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_command(const tlm_command command) { m_command = command; }\r
360\r
361template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
362inline tlm_mode tlm_request<ADDRESS,DATA,DATA_MODE>::get_mode() const{ return (m_mode); }\r
363\r
364template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
365inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_mode(const tlm_mode mode) { m_mode = mode; }\r
366\r
367template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
368inline bool tlm_request<ADDRESS,DATA,DATA_MODE>::is_regular_access() const { return(m_mode == REGULAR); }\r
369\r
370template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
371inline bool tlm_request<ADDRESS,DATA,DATA_MODE>::is_debug_access() const { return(m_mode == DEBUG); }\r
372\r
373template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
374inline bool tlm_request<ADDRESS,DATA,DATA_MODE>::is_control_access() const { return(m_mode == CONTROL); }\r
375\r
376template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
377inline ADDRESS tlm_request<ADDRESS,DATA,DATA_MODE>::get_address() const { return(m_address); }\r
378\r
379template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
380inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_address(const ADDRESS address) { m_address = address; }\r
381\r
382template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
383inline const DATA& tlm_request<ADDRESS,DATA,DATA_MODE>::get_data(const unsigned int index) const {\r
384 assert(m_data != 0);\r
385 assert(index < m_block_size);\r
386 return(m_data[index]);\r
387}\r
388\r
389template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
390inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_data(const DATA& data,const unsigned int index) { \r
391 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
392 if (!m_data) m_data = new DATA[index+1]; \r
393 else {\r
394 if (m_block_size<(index+1)) {\r
395 DATA * tmp = new DATA[m_block_size];\r
396 data_copy(tmp,m_data,m_block_size);\r
397 delete [] m_data;\r
398 m_data = new DATA[index+1];\r
399 this->data_copy(m_data,tmp,m_block_size);\r
400 delete [] tmp; \r
401 }\r
402 }\r
403 m_block_size = index+1;\r
404 }\r
405 else {\r
406 assert(m_data != 0);\r
407 assert(index < m_block_size);\r
408 }\r
409 m_data[index] = data;\r
410}\r
411\r
412template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
413inline const DATA * tlm_request<ADDRESS,DATA,DATA_MODE>::get_data_ptr() const { return(m_data); }\r
414\r
415template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
416inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_data_array(const unsigned int size,const DATA * data_ptr) { \r
417 if (size) m_block_size = size;\r
418 else m_block_size = 1; //default value\r
419 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
420 if (m_data) delete [] m_data;\r
421 if (size) m_data = new DATA[size];\r
422 else m_data = NULL; // default value\r
423 if (data_ptr) data_copy(m_data,data_ptr,size);\r
424 }\r
425 else m_data = const_cast<DATA * >(data_ptr);\r
426}\r
427\r
428template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
429inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_block_size() const { return(m_block_size); }\r
430\r
431template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
432inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_block_size(const unsigned int block_size) { m_block_size = block_size; }\r
433\r
434template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
435inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_byte_enable(const unsigned int index) const {\r
436 unsigned int be_size;\r
437 if (!m_byte_enable_period) be_size = m_block_size;\r
438 else be_size = m_byte_enable_period;\r
439 assert(index < be_size);\r
440 if (m_byte_enable)\r
441 return(m_byte_enable[index]);\r
442 else \r
443 return(NO_BE);\r
444}\r
445\r
446template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
447inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_byte_enable(const unsigned int byte_enable,const unsigned int index) {\r
448 unsigned int be_size;\r
449 if (!m_byte_enable_period) be_size = m_block_size;\r
450 else be_size = m_byte_enable_period;\r
451 \r
452 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
453 if (!m_byte_enable) m_byte_enable = new unsigned int[index+1]; \r
454 else {\r
455 \r
456 if (be_size<(index+1)) {\r
457 unsigned int * tmp = new unsigned int[be_size];\r
458 memcpy(tmp,m_byte_enable,be_size*get_nb_byte<unsigned int>());\r
459 delete [] m_byte_enable;\r
460 m_byte_enable = new unsigned int[index+1];\r
461 memcpy(const_cast<unsigned int *>(m_byte_enable),tmp,be_size*get_nb_byte<unsigned int>());\r
462 delete [] tmp; \r
463 }\r
464 }\r
465 m_byte_enable_period = index+1;\r
466 }\r
467 else {\r
468 assert(m_byte_enable != 0);\r
469 assert(index < be_size);\r
470 }\r
471 const_cast<unsigned int *>(m_byte_enable)[index] = byte_enable;\r
472}\r
473\r
474template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
475inline const unsigned int * tlm_request<ADDRESS,DATA,DATA_MODE>::get_byte_enable_ptr() const { return(m_byte_enable); }\r
476\r
477template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
478inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_byte_enable_array(const unsigned int size,\r
479 const unsigned int * byte_enable_ptr) { \r
480 m_byte_enable_period = size;\r
481 if (DATA_MODE == TLM_PASS_BY_COPY) {\r
482 if (m_byte_enable) delete [] m_byte_enable;\r
483 if (size) m_byte_enable = new unsigned int[size];\r
484 else m_byte_enable = NULL; // default value\r
485 if (byte_enable_ptr) memcpy(const_cast<unsigned int *>(m_byte_enable),byte_enable_ptr,size*get_nb_byte<unsigned int>());\r
486 }\r
487 else m_byte_enable = const_cast<unsigned int * >(byte_enable_ptr);\r
488}\r
489\r
490template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
491inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_byte_enable_period() const { return(m_byte_enable_period); }\r
492\r
493template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
494inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_byte_enable_period(const unsigned int byte_enable_period) { m_byte_enable_period = byte_enable_period; }\r
495\r
496template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
497inline tlm_block_mode tlm_request<ADDRESS,DATA,DATA_MODE>::get_block_mode() const { return(m_block_mode); } \r
498\r
499template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
500inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_block_mode(tlm_block_mode block_mode) { m_block_mode = block_mode; }\r
501\r
502template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
503inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_block_address_incr() const { return(m_block_address_incr); } \r
504\r
505template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
506inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_block_address_incr(unsigned int block_address_incr) { m_block_address_incr = block_address_incr; }\r
507\r
508template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
509inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_master_thread_id() const { return(m_master_thread_id); } \r
510\r
511template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
512inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_priority() const { return(m_priority); } \r
513\r
514template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
515inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_priority(unsigned int priority) { m_priority = priority; }\r
516\r
517template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
518inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_master_thread_id(unsigned int master_thread_id) { m_master_thread_id = master_thread_id; }\r
519\r
520template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
521inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_transaction_id() const { return(m_transaction_id); } \r
522\r
523template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
524inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_transaction_id(unsigned int transaction_id) { m_transaction_id = transaction_id; }\r
525\r
526template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
527inline unsigned int tlm_request<ADDRESS,DATA,DATA_MODE>::get_tlm_export_id() const { return(m_tlm_export_id); } \r
528\r
529template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
530inline void tlm_request<ADDRESS,DATA,DATA_MODE>::set_tlm_export_id(unsigned int tlm_export_id) { m_tlm_export_id = tlm_export_id; }\r
531\r
532template<typename DATA,typename ADDRESS,tlm_data_mode DATA_MODE>\r
533template<typename T >\r
534inline bool tlm_request<DATA,ADDRESS,DATA_MODE>::get_custom_ptr( T *& t ) const {\r
535 \r
536 if( m_custom_vector_ptr == 0 ) return false;\r
537 \r
538 std::vector<tlm_custom_base *> &v = *m_custom_vector_ptr;\r
539 \r
540 for( unsigned int i = 0; i < v.size(); i++ ) {\r
541 if( (t = dynamic_cast< T *>( v[i] )) ) {\r
542 return true;\r
543 }\r
544 } \r
545 return false; \r
546}\r
547\r
548template<typename DATA,typename ADDRESS,tlm_data_mode DATA_MODE>\r
549inline std::vector<tlm_custom_base *> *\r
550tlm_request<DATA,ADDRESS,DATA_MODE>::get_custom_vector_ptr() const {return m_custom_vector_ptr;}\r
551\r
552template<typename DATA,typename ADDRESS,tlm_data_mode DATA_MODE>\r
553inline void tlm_request<DATA,ADDRESS,DATA_MODE>::set_custom_vector_ptr( std::vector< tlm_custom_base * > *t ) {\r
554 \r
555 if( DATA_MODE == TLM_PASS_BY_POINTER ) {\r
556 m_custom_vector_ptr = t;\r
557 return;\r
558 }\r
559\r
560 if( m_custom_vector_ptr != 0 ) {\r
561 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
562 delete (*m_custom_vector_ptr)[i];\r
563 }\r
564 delete m_custom_vector_ptr;\r
565 }\r
566\r
567 if( t == 0 ) {\r
568 m_custom_vector_ptr = 0;\r
569 return;\r
570 }\r
571\r
572 m_custom_vector_ptr = new std::vector<tlm_custom_base *> ( t->size() );\r
573\r
574 tlm_custom_base *t_custom_ptr;\r
575 for( unsigned int i = 0; i < m_custom_vector_ptr->size(); i++ ) {\r
576 if( (t_custom_ptr = (*t)[i]) ) {\r
577 (*m_custom_vector_ptr)[i] = t_custom_ptr->clone();\r
578 }\r
579 }\r
580}\r
581\r
582\r
583\r
584\r
585//------------------------------------------\r
586/// Data copy function. Generic implementation\r
587template<typename ADDRESS,typename DATA,tlm_data_mode DATA_MODE>\r
588inline void tlm_request<ADDRESS,DATA,DATA_MODE>::data_copy(DATA * dst,const DATA * src,const unsigned int size) {\r
589 for(unsigned int i = 0;i < size;i++)\r
590 dst[i] = src[i];\r
591}\r
592\r
593 \r
594#define TLM_REQUEST_SCALAR_DATA_COPY(ADDRESS,DATA,DATA_MODE)\\r
595 template<>\\r
596 inline void tlm_request<ADDRESS,DATA,DATA_MODE>::data_copy(DATA * dst,const DATA * src,const unsigned int size) { \\r
597 memcpy(dst,src,size*get_nb_byte<DATA>());\\r
598 }\r
599\r
600TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_sint8_t,TLM_PASS_BY_COPY);\r
601TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_uint8_t,TLM_PASS_BY_COPY);\r
602TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_uint16_t,TLM_PASS_BY_COPY);\r
603TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_sint16_t,TLM_PASS_BY_COPY);\r
604TLM_REQUEST_SCALAR_DATA_COPY(int,int,TLM_PASS_BY_COPY);\r
605TLM_REQUEST_SCALAR_DATA_COPY(int,unsigned int,TLM_PASS_BY_COPY);\r
606TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_uint32_t,TLM_PASS_BY_COPY);\r
607TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_sint32_t,TLM_PASS_BY_COPY);\r
608TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_uint64_t,TLM_PASS_BY_COPY);\r
609TLM_REQUEST_SCALAR_DATA_COPY(int,tlm_sint64_t,TLM_PASS_BY_COPY); \r
610\r
611TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_sint8_t,TLM_PASS_BY_COPY);\r
612TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_uint8_t,TLM_PASS_BY_COPY);\r
613TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_uint16_t,TLM_PASS_BY_COPY);\r
614TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_sint16_t,TLM_PASS_BY_COPY);\r
615TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,int,TLM_PASS_BY_COPY);\r
616TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,unsigned int,TLM_PASS_BY_COPY);\r
617TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_uint32_t,TLM_PASS_BY_COPY);\r
618TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_sint32_t,TLM_PASS_BY_COPY);\r
619TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_uint64_t,TLM_PASS_BY_COPY);\r
620TLM_REQUEST_SCALAR_DATA_COPY(unsigned int,tlm_sint64_t,TLM_PASS_BY_COPY); \r
621\r
622TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_sint8_t,TLM_PASS_BY_COPY);\r
623TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_uint8_t,TLM_PASS_BY_COPY);\r
624TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_uint16_t,TLM_PASS_BY_COPY);\r
625TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_sint16_t,TLM_PASS_BY_COPY);\r
626TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,int,TLM_PASS_BY_COPY);\r
627TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,unsigned int,TLM_PASS_BY_COPY);\r
628TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_uint32_t,TLM_PASS_BY_COPY);\r
629TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_sint32_t,TLM_PASS_BY_COPY);\r
630TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_uint64_t,TLM_PASS_BY_COPY);\r
631TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint32_t,tlm_sint64_t,TLM_PASS_BY_COPY); \r
632\r
633TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_sint8_t,TLM_PASS_BY_COPY);\r
634TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_uint8_t,TLM_PASS_BY_COPY);\r
635TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_uint16_t,TLM_PASS_BY_COPY);\r
636TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_sint16_t,TLM_PASS_BY_COPY);\r
637TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,int,TLM_PASS_BY_COPY);\r
638TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,unsigned int,TLM_PASS_BY_COPY);\r
639TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_uint32_t,TLM_PASS_BY_COPY);\r
640TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_sint32_t,TLM_PASS_BY_COPY);\r
641TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_uint64_t,TLM_PASS_BY_COPY);\r
642TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint32_t,tlm_sint64_t,TLM_PASS_BY_COPY); \r
643\r
644TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_sint8_t,TLM_PASS_BY_COPY);\r
645TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_uint8_t,TLM_PASS_BY_COPY);\r
646TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_uint16_t,TLM_PASS_BY_COPY);\r
647TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_sint16_t,TLM_PASS_BY_COPY);\r
648TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,int,TLM_PASS_BY_COPY);\r
649TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,unsigned int,TLM_PASS_BY_COPY);\r
650TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_uint32_t,TLM_PASS_BY_COPY);\r
651TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_sint32_t,TLM_PASS_BY_COPY);\r
652TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_uint64_t,TLM_PASS_BY_COPY);\r
653TLM_REQUEST_SCALAR_DATA_COPY(tlm_uint64_t,tlm_sint64_t,TLM_PASS_BY_COPY); \r
654\r
655TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_sint8_t,TLM_PASS_BY_COPY);\r
656TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_uint8_t,TLM_PASS_BY_COPY);\r
657TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_uint16_t,TLM_PASS_BY_COPY);\r
658TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_sint16_t,TLM_PASS_BY_COPY);\r
659TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,int,TLM_PASS_BY_COPY);\r
660TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,unsigned int,TLM_PASS_BY_COPY);\r
661TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_uint32_t,TLM_PASS_BY_COPY);\r
662TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_sint32_t,TLM_PASS_BY_COPY);\r
663TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_uint64_t,TLM_PASS_BY_COPY);\r
664TLM_REQUEST_SCALAR_DATA_COPY(tlm_sint64_t,tlm_sint64_t,TLM_PASS_BY_COPY); \r
665\r
666#endif /* _TLM_REQUEST_H_ */\r
667\r
668\r
Full OpenSPARC design & verification tarball including full HDL.