00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __TLM_ENDIAN_CONV_H__
00020 #define __TLM_ENDIAN_CONV_H__
00021
00022 #include <systemc>
00023 #include "tlm_gp.h"
00024
00025
00026 namespace tlm {
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142 #ifndef uchar
00143 #define uchar unsigned char
00144 #else
00145 #define TLM_END_CONV_DONT_UNDEF_UCHAR
00146 #endif
00147
00149
00150
00151
00152
00153 class tlm_buffer_pool {
00154 int max_buffer_size;
00155 uchar* pool_head;
00156
00157 public:
00158 tlm_buffer_pool(): max_buffer_size(32), pool_head(0) {};
00159
00160 uchar *get_a_buffer(int size) {
00161 if(size > max_buffer_size) {
00162 max_buffer_size = size;
00163
00164 for(uchar *p = pool_head; p != 0; ) {
00165 uchar *q = p;
00166 p = *((uchar **)(p + sizeof(int)));
00167 delete [] q;
00168 }
00169 pool_head = 0;
00170 }
00171 if(pool_head == 0) {
00172
00173
00174
00175 pool_head = new uchar[max_buffer_size + sizeof(int) + sizeof(uchar *)];
00176 *((int *)pool_head) = max_buffer_size;
00177 *((uchar **)(pool_head + sizeof(int))) = 0;
00178 }
00179
00180 uchar *retval = pool_head + sizeof(int) + sizeof(uchar *);
00181 pool_head = *((uchar **)(pool_head + sizeof(int)));
00182 return retval;
00183 };
00184
00185 void return_buffer(uchar *p) {
00186
00187 uchar *q = p - sizeof(int) - sizeof(uchar *);
00188 if(*((int *)q) != max_buffer_size) {
00189
00190 delete [] q;
00191 } else {
00192
00193 *((uchar **)(q + sizeof(int))) = pool_head;
00194 pool_head = q;
00195 }
00196 }
00197
00198 int get_pool_size() {
00199 int s = 0;
00200 for(uchar *p = pool_head; p != 0; p = *((uchar **)(p + sizeof(int))), s++) {}
00201 return s;
00202 }
00203
00204 int get_buffer_size() {return max_buffer_size;}
00205 };
00206
00207 static tlm_buffer_pool local_buffer_pool;
00208
00209
00210 class tlm_endian_context : public tlm_extension<tlm_endian_context> {
00211 public:
00212 sc_dt::uint64 address;
00213 sc_dt::uint64 new_address;
00214 uchar *data_ptr;
00215 uchar *byte_enable;
00216 int length;
00217 int stream_width;
00218
00219
00220 void (*from_f)(tlm_generic_payload *txn, unsigned int sizeof_databus);
00221 int sizeof_databus;
00222
00223
00224 tlm_extension_base* clone() const {return 0;}
00225 void free() {delete this;}
00226 void copy_from(tlm_extension_base const &) {return;}
00227 };
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243 inline tlm_endian_context *establish_context(tlm_generic_payload *txn) {
00244 tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
00245 if(tc == 0) {
00246 tc = new tlm_endian_context;
00247 txn->set_extension(tc);
00248 }
00249 return tc;
00250 }
00251
00252
00253 template<class D> class tlm_bool {
00254 public:
00255 static D TLM_TRUE;
00256 static D TLM_FALSE;
00257 static D make_uchar_array(uchar c) {
00258 D d;
00259 uchar *tmp = (uchar *)(&d);
00260 for(unsigned int i=0; i<sizeof(D); i++) tmp[i] = c;
00261 return d;
00262 }
00263
00264
00265 tlm_bool(D &d) : b(*((uchar*)&d) != TLM_BYTE_DISABLED) {}
00266 operator bool() const {return b;}
00267 private:
00268 bool b;
00269 };
00270
00271 template<class D> D tlm_bool<D>::TLM_TRUE = tlm_bool<D>::make_uchar_array(TLM_BYTE_ENABLED);
00272 template<class D> D tlm_bool<D>::TLM_FALSE = tlm_bool<D>::make_uchar_array(TLM_BYTE_DISABLED);
00273
00275
00276 inline void copy_db0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00277 *dest1 = *src1;
00278 *dest2 = *src2;
00279 }
00280
00281 inline void copy_dbtrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00282 *dest1 = *src1;
00283 *dest2 = TLM_BYTE_ENABLED;
00284 }
00285
00286 inline void copy_btrue0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00287 *dest2 = TLM_BYTE_ENABLED;
00288 }
00289
00290 inline void copy_b0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00291 *dest2 = *src2;
00292 }
00293
00294 inline void copy_dbyb0(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00295 if(*dest2 == TLM_BYTE_ENABLED) *src1 = *dest1;
00296 }
00297
00298
00299 template<class D,
00300 void COPY(uchar *he_d, uchar *he_b, uchar *ie_d, uchar *ie_b)>
00301 inline void loop_generic0(int new_len, int new_stream_width,
00302 int orig_stream_width, int sizeof_databus,
00303 sc_dt::uint64 orig_start_address, sc_dt::uint64 new_start_address, int be_length,
00304 uchar *ie_data, uchar *ie_be, uchar *he_data, uchar *he_be) {
00305
00306 for(int orig_sword = 0, new_sword = 0; new_sword < new_len;
00307 new_sword += new_stream_width, orig_sword += orig_stream_width) {
00308
00309 sc_dt::uint64 ie_addr = orig_start_address;
00310 for(int orig_dword = orig_sword;
00311 orig_dword < orig_sword + orig_stream_width; orig_dword += sizeof(D)) {
00312
00313 for(int curr_byte = orig_dword + sizeof(D) - 1;
00314 curr_byte >= orig_dword; curr_byte--) {
00315
00316 int he_index = ((ie_addr++) ^ (sizeof_databus - 1))
00317 - new_start_address + new_sword;
00318 COPY(ie_data+curr_byte, ie_be+(curr_byte % be_length),
00319 he_data+he_index, he_be+he_index);
00320 }
00321 }
00322 }
00323 }
00324
00325
00327
00328 template<class DATAWORD> inline void
00329 tlm_from_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00330 if(txn->is_read()) {
00331 tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
00332
00333 loop_generic0<DATAWORD, ©_dbyb0>(txn->get_data_length(),
00334 txn->get_streaming_width(), tc->stream_width, sizeof_databus, tc->address,
00335 tc->new_address, txn->get_data_length(), tc->data_ptr, 0, txn->get_data_ptr(),
00336 txn->get_byte_enable_ptr());
00337 }
00338
00339 local_buffer_pool.return_buffer(txn->get_byte_enable_ptr());
00340 local_buffer_pool.return_buffer(txn->get_data_ptr());
00341 }
00342
00343
00345
00346 template<class DATAWORD> inline void
00347 tlm_to_hostendian_generic(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00348 tlm_endian_context *tc = establish_context(txn);
00349 tc->from_f = &(tlm_from_hostendian_generic<DATAWORD>);
00350 tc->sizeof_databus = sizeof_databus;
00351
00352
00353 int s_width = txn->get_streaming_width();
00354 int length = txn->get_data_length();
00355 if(s_width >= length) s_width = length;
00356 int nr_stream_words = length/s_width;
00357
00358
00359 sc_dt::uint64 new_address = (txn->get_address() & ‾(sizeof_databus - 1));
00360 sc_dt::uint64 end_address = ((txn->get_address() + s_width - 1)
00361 & ‾(sizeof_databus - 1));
00362
00363 int new_stream_width = end_address - new_address + sizeof_databus;
00364 int new_length = new_stream_width * nr_stream_words;
00365
00366
00367 tc->data_ptr = txn->get_data_ptr();
00368 tc->address = txn->get_address();
00369 tc->new_address = new_address;
00370 tc->stream_width = s_width;
00371 uchar *orig_be = txn->get_byte_enable_ptr();
00372 int orig_be_length = txn->get_byte_enable_length();
00373
00374
00375 txn->set_address(new_address);
00376 txn->set_data_ptr(local_buffer_pool.get_a_buffer(new_length));
00377 txn->set_byte_enable_ptr(local_buffer_pool.get_a_buffer(new_length));
00378 memset(txn->get_byte_enable_ptr(), TLM_BYTE_DISABLED, new_length);
00379 txn->set_streaming_width(new_stream_width);
00380 txn->set_data_length(new_length);
00381 txn->set_byte_enable_length(new_length);
00382
00383
00384 if(txn->is_write()) {
00385 if(orig_be == 0) {
00386 loop_generic0<DATAWORD, ©_dbtrue0>(new_length,
00387 new_stream_width, s_width, sizeof_databus, tc->address,
00388 new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
00389 txn->get_byte_enable_ptr());
00390 } else {
00391 loop_generic0<DATAWORD, ©_db0>(new_length,
00392 new_stream_width, s_width, sizeof_databus, tc->address,
00393 new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
00394 txn->get_byte_enable_ptr());
00395 }
00396 } else {
00397 if(orig_be == 0) {
00398 loop_generic0<DATAWORD, ©_btrue0>(new_length,
00399 new_stream_width, s_width, sizeof_databus, tc->address,
00400 new_address, new_length, tc->data_ptr, 0, txn->get_data_ptr(),
00401 txn->get_byte_enable_ptr());
00402 } else {
00403 loop_generic0<DATAWORD, ©_b0>(new_length,
00404 new_stream_width, s_width, sizeof_databus, tc->address,
00405 new_address, orig_be_length, tc->data_ptr, orig_be, txn->get_data_ptr(),
00406 txn->get_byte_enable_ptr());
00407 }
00408 }
00409 }
00410
00411
00412
00414
00415 template<class D>
00416 inline void copy_d1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00417 *((D *)dest1) = *((D *)src1);
00418 *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
00419 }
00420
00421 template<class D>
00422 inline void copy_db1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00423 *((D *)dest1) = *((D *)src1);
00424 *((D *)dest2) = *((D *)src2);
00425 }
00426
00427 template<class D>
00428 inline void true_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00429 *((D *)dest2) = tlm_bool<D>::TLM_TRUE;
00430 }
00431
00432 template<class D>
00433 inline void copy_b1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00434 *((D *)dest2) = *((D *)src2);
00435 }
00436
00437 template<class D>
00438 inline void copy_dbyb1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00439 if(*src2 != TLM_BYTE_DISABLED) *((D *)src1) = *((D *)dest1);
00440 }
00441
00442 template<class D>
00443 inline void copy_dbytrue1(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2) {
00444 *((D *)src1) = *((D *)dest1);
00445 }
00446
00447 template<class D> inline void false_b1(uchar *dest1) {
00448 *((D *)dest1) = tlm_bool<D>::TLM_FALSE;
00449 }
00450
00451 template<class D> inline void no_b1(uchar *dest1) {
00452 }
00453
00454 template<class D,
00455 void COPY(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
00456 void COPYuchar(uchar *src1, uchar *src2, uchar *dest1, uchar *dest2),
00457 void FILLFALSE(uchar *dest1), void FILLFALSEuchar(uchar *dest1)>
00458 inline int loop_word1(
00459 int bytes_left, int len0, int lenN, int sizeof_databus,
00460 uchar *start, uchar *end, uchar *src, uchar *bsrc, uchar *dest, uchar *bdest) {
00461 int d2b_src = bsrc - src;
00462 int d2b_dest = bdest - dest;
00463 uchar *original_dest = dest;
00464
00465 while(true) {
00466
00467 if((src >= start) && (src < end)) {
00468 for(int i=0; i<len0; i++) {
00469 COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
00470 src++;
00471 dest++;
00472 }
00473 bytes_left -= len0;
00474 if(bytes_left <= 0) return int(dest - original_dest);
00475 } else {
00476 for(int i=0; i<len0; i++) {
00477 FILLFALSEuchar(dest+d2b_dest);
00478 src++;
00479 dest++;
00480 }
00481 }
00482 src -= 2 * sizeof(D);
00483
00484
00485 for(unsigned int i=1; i<sizeof_databus/sizeof(D); i++) {
00486 if((src >= start) && (src < end)) {
00487 COPY(src, src+d2b_src, dest, dest+d2b_dest);
00488 bytes_left -= sizeof(D);
00489 } else {
00490 FILLFALSE(dest+d2b_dest);
00491 }
00492 dest += sizeof(D);
00493 if(bytes_left <= 0) return int(dest - original_dest);
00494 src -= sizeof(D);
00495 }
00496
00497
00498 if((src >= start) && (src < end)) {
00499 for(int i=0; i<lenN; i++) {
00500 COPYuchar(src, src+d2b_src, dest, dest+d2b_dest);
00501 src++;
00502 dest++;
00503 }
00504 bytes_left -= lenN;
00505 if(bytes_left <= 0) return int(dest - original_dest);
00506 } else {
00507 for(int i=0; i<lenN; i++) {
00508 FILLFALSEuchar(dest+d2b_dest);
00509 src++;
00510 dest++;
00511 }
00512 }
00513 src += 2 * sizeof_databus;
00514 }
00515 }
00516
00517
00519
00520 template<class DATAWORD> inline void
00521 tlm_from_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00522 if(txn->is_read()) {
00523 tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
00524
00525 sc_dt::uint64 b_mask = sizeof_databus - 1;
00526 int d_mask = sizeof(DATAWORD) - 1;
00527 int a_offset = tc->address & b_mask;
00528 int len0 = (sizeof_databus - a_offset) & d_mask;
00529 int lenN = sizeof(DATAWORD) - len0;
00530 uchar *d_start = tc->data_ptr;
00531 uchar *d_end = tc->length + d_start;
00532 uchar *d = ((sizeof_databus - a_offset) & ‾d_mask) + lenN + d_start;
00533
00534
00535 if(tc->byte_enable == 0) {
00536 loop_word1<DATAWORD, ©_dbytrue1<DATAWORD>,
00537 ©_dbytrue1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
00538 tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
00539 0, txn->get_data_ptr(), 0);
00540 } else {
00541 loop_word1<DATAWORD, ©_dbyb1<DATAWORD>,
00542 ©_dbyb1<uchar>, &no_b1<DATAWORD>, &no_b1<uchar> >(
00543 tc->length, len0, lenN, sizeof_databus, d_start, d_end, d,
00544 tc->byte_enable - d_start + d, txn->get_data_ptr(), 0);
00545 }
00546 }
00547 local_buffer_pool.return_buffer(txn->get_byte_enable_ptr());
00548 local_buffer_pool.return_buffer(txn->get_data_ptr());
00549 }
00550
00551
00553
00554 template<class DATAWORD> inline void
00555 tlm_to_hostendian_word(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00556 tlm_endian_context *tc = establish_context(txn);
00557 tc->from_f = &(tlm_from_hostendian_word<DATAWORD>);
00558 tc->sizeof_databus = sizeof_databus;
00559
00560 sc_dt::uint64 b_mask = sizeof_databus - 1;
00561 int d_mask = sizeof(DATAWORD) - 1;
00562 sc_dt::uint64 a_aligned = txn->get_address() & ‾b_mask;
00563 int a_offset = txn->get_address() & b_mask;
00564 int len0 = (sizeof_databus - a_offset) & d_mask;
00565 int lenN = sizeof(DATAWORD) - len0;
00566 uchar *d_start = txn->get_data_ptr();
00567 uchar *d_end = txn->get_data_length() + d_start;
00568 uchar *d = ((sizeof_databus - a_offset) & ‾d_mask) + lenN + d_start;
00569
00570
00571 int long_enough = txn->get_data_length() + 2 * sizeof_databus;
00572 uchar *new_data = local_buffer_pool.get_a_buffer(long_enough);
00573 uchar *new_be = local_buffer_pool.get_a_buffer(long_enough);
00574
00575 if(txn->is_read()) {
00576 tc->data_ptr = d_start;
00577 tc->address = txn->get_address();
00578 tc->byte_enable = txn->get_byte_enable_ptr();
00579 tc->length = txn->get_data_length();
00580 if(txn->get_byte_enable_ptr() == 0) {
00581
00582 txn->set_data_length(loop_word1<DATAWORD, &true_b1<DATAWORD>,
00583 &true_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
00584 txn->get_data_length(), len0, lenN, sizeof_databus,
00585 d_start, d_end, d, 0, new_data, new_be));
00586 } else {
00587
00588 txn->set_data_length(loop_word1<DATAWORD, ©_b1<DATAWORD>,
00589 ©_b1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
00590 txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
00591 d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
00592 }
00593 } else {
00594
00595 if(txn->get_byte_enable_ptr() == 0) {
00596
00597 txn->set_data_length(loop_word1<DATAWORD, ©_d1<DATAWORD>,
00598 ©_d1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
00599 txn->get_data_length(), len0, lenN, sizeof_databus,
00600 d_start, d_end, d, 0, new_data, new_be));
00601 } else {
00602
00603 txn->set_data_length(loop_word1<DATAWORD, ©_db1<DATAWORD>,
00604 ©_db1<uchar>, &false_b1<DATAWORD>, &false_b1<uchar> >(
00605 txn->get_data_length(), len0, lenN, sizeof_databus, d_start, d_end,
00606 d, txn->get_byte_enable_ptr() - d_start + d, new_data, new_be));
00607 }
00608 }
00609 txn->set_byte_enable_length(txn->get_data_length());
00610 txn->set_streaming_width(txn->get_data_length());
00611 txn->set_data_ptr(new_data);
00612 txn->set_byte_enable_ptr(new_be);
00613 txn->set_address(a_aligned);
00614 }
00615
00616
00617
00619
00620 template<class D> inline void copy_d2(D *src1, D *src2, D *dest1, D *dest2) {
00621 *dest1 = *src1;
00622 }
00623
00624 template<class D> inline void copy_db2(D *src1, D *src2, D *dest1, D *dest2) {
00625 *dest1 = *src1;
00626 *dest2 = *src2;
00627 }
00628
00629 template<class D>
00630 inline void copy_dbyb2(D *src1, D *src2, D *dest1, D *dest2) {
00631 if(tlm_bool<D>(*src2)) *dest1 = *src1;
00632 }
00633
00634 template<class D, void COPY(D *src1, D *src2, D *dest1, D *dest2)>
00635 inline void loop_aligned2(D *src1, D *src2, D *dest1, D *dest2,
00636 int words, int words_per_bus) {
00637 int src1to2 = int(src2) - int(src1);
00638 int dest1to2 = int(dest2) - int(dest1);
00639
00640 D *done = src1 + words;
00641 D *bus_start = src1;
00642 src1 += words_per_bus - 1;
00643
00644 while(true) {
00645 COPY(src1, (D *)(int(src1)+src1to2), dest1, (D *)(int(dest1)+dest1to2));
00646 dest1++;
00647 if((--src1) < bus_start) {
00648 bus_start += words_per_bus;
00649 if(bus_start == done) break;
00650 src1 = bus_start + words_per_bus - 1;
00651 }
00652 }
00653 }
00654
00655
00657
00658 template<class DATAWORD> inline void
00659 tlm_from_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00660 int words_per_bus = sizeof_databus/sizeof(DATAWORD);
00661 if(words_per_bus == 1) return;
00662 int words = (txn->get_data_length())/sizeof(DATAWORD);
00663
00664 if(txn->get_byte_enable_ptr() == 0) {
00665
00666 if(txn->is_read()) {
00667
00668 tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
00669 loop_aligned2<DATAWORD, ©_d2<DATAWORD> >(
00670 (DATAWORD *)(txn->get_data_ptr()),
00671 0, (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
00672 }
00673 } else {
00674
00675 if(txn->is_read()) {
00676
00677 tlm_endian_context *tc = txn->template get_extension<tlm_endian_context>();
00678 loop_aligned2<DATAWORD, ©_dbyb2<DATAWORD> >(
00679 (DATAWORD *)(txn->get_data_ptr()),
00680 (DATAWORD *)(txn->get_byte_enable_ptr()),
00681 (DATAWORD *)(tc->data_ptr), 0, words, words_per_bus);
00682 }
00683 local_buffer_pool.return_buffer(txn->get_byte_enable_ptr());
00684 }
00685
00686 local_buffer_pool.return_buffer(txn->get_data_ptr());
00687 }
00688
00689
00691
00692 template<class DATAWORD> inline void
00693 tlm_to_hostendian_aligned(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00694 tlm_endian_context *tc = establish_context(txn);
00695 tc->from_f = &(tlm_from_hostendian_aligned<DATAWORD>);
00696 tc->sizeof_databus = sizeof_databus;
00697
00698 int words_per_bus = sizeof_databus/sizeof(DATAWORD);
00699 if(words_per_bus == 1) return;
00700 int words = (txn->get_data_length())/sizeof(DATAWORD);
00701
00702 DATAWORD *original_be = (DATAWORD *)(txn->get_byte_enable_ptr());
00703 DATAWORD *original_data = (DATAWORD *)(txn->get_data_ptr());
00704
00705
00706 txn->set_data_ptr(local_buffer_pool.get_a_buffer(txn->get_data_length()));
00707
00708 if(original_be == 0) {
00709
00710 if(txn->is_write()) {
00711
00712 loop_aligned2<DATAWORD, ©_d2<DATAWORD> >(original_data, 0,
00713 (DATAWORD *)(txn->get_data_ptr()), 0,
00714 words, words_per_bus);
00715 } else {
00716
00717 tc->data_ptr = (uchar *)original_data;
00718 }
00719 } else {
00720
00721
00722 txn->set_byte_enable_ptr(
00723 local_buffer_pool.get_a_buffer(txn->get_data_length()));
00724 txn->set_byte_enable_length(txn->get_data_length());
00725
00726 if(txn->is_write()) {
00727
00728 loop_aligned2<DATAWORD, ©_db2<DATAWORD> >(original_data, original_be,
00729 (DATAWORD *)(txn->get_data_ptr()),
00730 (DATAWORD *)(txn->get_byte_enable_ptr()), words, words_per_bus);
00731 } else {
00732
00733 tc->data_ptr = (uchar *)original_data;
00734
00735 loop_aligned2<DATAWORD, ©_d2<DATAWORD> >(original_be, 0,
00736 (DATAWORD *)(txn->get_byte_enable_ptr()), 0,
00737 words, words_per_bus);
00738 }
00739 }
00740 }
00741
00742
00743
00745
00746 template<class DATAWORD> inline void
00747 tlm_from_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00748
00749 }
00750
00751
00753
00754 template<class DATAWORD> inline void
00755 tlm_to_hostendian_single(tlm_generic_payload *txn, unsigned int sizeof_databus) {
00756 tlm_endian_context *tc = establish_context(txn);
00757 tc->from_f = &(tlm_from_hostendian_single<DATAWORD>);
00758 tc->sizeof_databus = sizeof_databus;
00759
00760
00761 sc_dt::uint64 mask = sizeof_databus-1;
00762 sc_dt::uint64 a = txn->get_address();
00763 txn->set_address((a & ‾mask) |
00764 (sizeof_databus - (a & mask) - sizeof(DATAWORD)));
00765 }
00766
00767
00768
00770
00771 inline void tlm_from_hostendian(tlm_generic_payload *txn) {
00772 tlm_endian_context *tc = txn->get_extension<tlm_endian_context>();
00773 (*(tc->from_f))(txn, tc->sizeof_databus);
00774 }
00775
00776
00777 #ifndef TLM_END_CONV_DONT_UNDEF_UCHAR
00778 #undef uchar
00779 #endif
00780
00781 }
00782
00783
00784 #endif // multiple-inclusion protection
00785