@@ -568,6 +568,8 @@ template device {
568
568
// this carried semantics in DML 1.2; deprecated in 1.4
569
569
param _confidentiality = undefined;
570
570
571
+ session conf_object_t *_current_initiator;
572
+
571
573
method _init() { _rec_init(); }
572
574
method _post_init() { _rec_post_init(); }
573
575
method init() default {}
@@ -2007,52 +2009,78 @@ template bank is (object, shown_desc) {
2007
2009
return 0;
2008
2010
}
2009
2011
2010
- local register hits[8];
2011
- local int num_hits;
2012
- local uint64 unmapped_bytes;
2012
+ local uint64 readval = 0;
2013
+ local bool ok = true;
2013
2014
2014
2015
local uint64 size = _enabled_bytes_to_size(enabled_bytes);
2015
- (num_hits, unmapped_bytes) = this._dispatch(offset, size, hits, false);
2016
+ local bool inquiry_override = false;
2017
+ _callback_before_read(this._bank_obj(), dev._current_initiator,
2018
+ &inquiry_override, &offset,
2019
+ size, &_connections, &_before_read_callbacks);
2020
+ if (inquiry_override) {
2021
+ try {
2022
+ readval = this.get(offset, size);
2023
+ } catch {
2024
+ ok = false;
2025
+ }
2026
+ } else {
2027
+ try {
2028
+ local register hits[8];
2029
+ local int num_hits;
2030
+ local uint64 unmapped_bytes;
2016
2031
2017
- local uint64 readval = 0;
2018
- if ((unmapped_bytes & enabled_bytes) != 0) {
2019
- readval[size * 8 - 1 : 0] = this.unmapped_read(
2020
- offset, unmapped_bytes & enabled_bytes, aux);
2021
- }
2032
+ (num_hits, unmapped_bytes) = this._dispatch(
2033
+ offset, size, hits, false);
2022
2034
2023
- for (local int r = 0; r < num_hits; ++r) {
2024
- local int r_start;
2025
- local int r_end;
2026
- (r_start, r_end) = this._intersect(
2027
- hits[r].offset, hits[r]._size(), offset, size, true);
2035
+ if ((unmapped_bytes & enabled_bytes) != 0) {
2036
+ readval[size * 8 - 1 : 0] = this.unmapped_read(
2037
+ offset, unmapped_bytes & enabled_bytes, aux);
2038
+ }
2028
2039
2029
- local int start;
2030
- local int end;
2031
- (start, end) = this._intersect(
2032
- offset, size, hits[r].offset, hits[r]._size(), true);
2040
+ for (local int r = 0; r < num_hits; ++r) {
2041
+ local int r_start;
2042
+ local int r_end;
2043
+ (r_start, r_end) = this._intersect(
2044
+ hits[r].offset, hits[r]._size(), offset, size, true);
2045
+
2046
+ local int start;
2047
+ local int end;
2048
+ (start, end) = this._intersect(
2049
+ offset, size, hits[r].offset, hits[r]._size(), true);
2050
+
2051
+ local uint64 r_enabled_bytes = 0;
2052
+ r_enabled_bytes[r_end * 8 - 1 : r_start * 8] =
2053
+ enabled_bytes[end * 8 - 1 : start * 8];
2054
+ if (r_enabled_bytes == 0) {
2055
+ continue;
2056
+ }
2033
2057
2034
- local uint64 r_enabled_bytes = 0;
2035
- r_enabled_bytes[r_end * 8 - 1 : r_start * 8] =
2036
- enabled_bytes[end * 8 - 1 : start * 8];
2037
- if (r_enabled_bytes == 0) {
2038
- continue;
2039
- }
2058
+ local uint64 r_val = hits[r].read_register(r_enabled_bytes, aux);
2059
+ if (r_end - r_start == hits[r]._size()) {
2060
+ log info, 4, Register_Read:
2061
+ "Read from register %s -> 0x%0*x",
2062
+ hits[r]._qname(), cast(size*2, int), r_val;
2063
+ } else {
2064
+ log info, 4, Register_Read:
2065
+ "Partial read from register %s: bytes %d-%d -> 0x%0*x",
2066
+ hits[r]._qname(), r_start, r_end-1,
2067
+ cast(r_end - r_start, int),
2068
+ r_val[r_end * 8 - 1 : r_start * 8];
2069
+ }
2040
2070
2041
- local uint64 r_val = hits[r].read_register(r_enabled_bytes, aux);
2042
- if (r_end - r_start == hits[r]._size()) {
2043
- log info, 4, Register_Read:
2044
- "Read from register %s -> 0x%0*x",
2045
- hits[r]._qname(), cast(size*2, int), r_val;
2046
- } else {
2047
- log info, 4, Register_Read:
2048
- "Partial read from register %s: bytes %d-%d -> 0x%0*x",
2049
- hits[r]._qname(), r_start, r_end-1,
2050
- cast(r_end - r_start, int),
2051
- r_val[r_end * 8 - 1 : r_start * 8];
2071
+ readval[end * 8 - 1 : start * 8] =
2072
+ (r_val & r_enabled_bytes)[r_end * 8 - 1 : r_start * 8];
2073
+ }
2074
+ } catch {
2075
+ ok = false;
2052
2076
}
2053
-
2054
- readval[end * 8 - 1 : start * 8] =
2055
- (r_val & r_enabled_bytes)[r_end * 8 - 1 : r_start * 8];
2077
+ }
2078
+ _callback_after_read(this._bank_obj(), dev._current_initiator,
2079
+ &offset, size,
2080
+ &readval, &ok, &_connections,
2081
+ &_after_read_callbacks);
2082
+ if (!ok) {
2083
+ throw;
2056
2084
}
2057
2085
2058
2086
return readval;
@@ -2100,52 +2128,72 @@ template bank is (object, shown_desc) {
2100
2128
return;
2101
2129
}
2102
2130
2103
- local register hits[8];
2104
- local int num_hits;
2105
- local uint64 unmapped_bytes;
2106
-
2131
+ local bool suppress = false;
2107
2132
local uint64 size = _enabled_bytes_to_size(enabled_bytes);
2108
- (num_hits, unmapped_bytes) = this._dispatch(offset, size, hits, false);
2109
- if ((unmapped_bytes & enabled_bytes) != 0) {
2110
- this.unmapped_write(
2111
- offset, value, unmapped_bytes & enabled_bytes, aux);
2112
- }
2113
-
2114
- for (local int r = 0; r < num_hits; ++r) {
2115
- local int r_start;
2116
- local int r_end;
2117
- (r_start, r_end) = this._intersect(
2118
- hits[r].offset, hits[r]._size(), offset, size, true);
2133
+ _callback_before_write(
2134
+ this._bank_obj(), dev._current_initiator, &offset, size,
2135
+ &value,
2136
+ &suppress, &_connections, &_before_write_callbacks);
2137
+ local bool ok = true;
2138
+ if (!suppress) {
2139
+ try {
2140
+ local register hits[8];
2141
+ local int num_hits;
2142
+ local uint64 unmapped_bytes;
2143
+
2144
+ (num_hits, unmapped_bytes) = this._dispatch(
2145
+ offset, size, hits, false);
2146
+ if ((unmapped_bytes & enabled_bytes) != 0) {
2147
+ this.unmapped_write(
2148
+ offset, value, unmapped_bytes & enabled_bytes, aux);
2149
+ }
2119
2150
2120
- local int start;
2121
- local int end;
2122
- (start, end) = this._intersect(
2123
- offset, size, hits[r].offset, hits[r]._size(), true);
2151
+ for (local int r = 0; r < num_hits; ++r) {
2152
+ local int r_start;
2153
+ local int r_end;
2154
+ (r_start, r_end) = this._intersect(
2155
+ hits[r].offset, hits[r]._size(), offset, size, true);
2156
+
2157
+ local int start;
2158
+ local int end;
2159
+ (start, end) = this._intersect(
2160
+ offset, size, hits[r].offset, hits[r]._size(), true);
2161
+
2162
+ local uint64 r_enabled_bytes = 0;
2163
+ r_enabled_bytes[r_end * 8 - 1 : r_start * 8] =
2164
+ enabled_bytes[end * 8 - 1 : start * 8];
2165
+ if (r_enabled_bytes == 0) {
2166
+ continue;
2167
+ }
2124
2168
2125
- local uint64 r_enabled_bytes = 0;
2126
- r_enabled_bytes[r_end * 8 - 1 : r_start * 8] =
2127
- enabled_bytes[end * 8 - 1 : start * 8];
2128
- if (r_enabled_bytes == 0) {
2129
- continue;
2130
- }
2169
+ local uint64 r_value = 0;
2170
+ r_value[r_end * 8 - 1 : r_start * 8]
2171
+ = value[end * 8 - 1 : start * 8];
2172
+ if (r_end - r_start == hits[r]._size()) {
2173
+ log info, 4, Register_Write:
2174
+ "Write to register %s <- 0x%0*x",
2175
+ hits[r]._qname(), cast(size*2, int), r_value;
2176
+ } else {
2177
+ log info, 4, Register_Write:
2178
+ "Partial write to register %s: bytes %d-%d <- 0x%0*x",
2179
+ hits[r]._qname(), r_start, r_end-1,
2180
+ cast(r_end - r_start, int),
2181
+ r_value[r_end * 8 - 1 : r_start * 8];
2182
+ }
2131
2183
2132
- local uint64 r_value = 0;
2133
- r_value[r_end * 8 - 1 : r_start * 8]
2134
- = value[end * 8 - 1 : start * 8];
2135
- if (r_end - r_start == hits[r]._size()) {
2136
- log info, 4, Register_Write:
2137
- "Write to register %s <- 0x%0*x",
2138
- hits[r]._qname(), cast(size*2, int), r_value;
2139
- } else {
2140
- log info, 4, Register_Write:
2141
- "Partial write to register %s: bytes %d-%d <- 0x%0*x",
2142
- hits[r]._qname(), r_start, r_end-1,
2143
- cast(r_end - r_start, int),
2144
- r_value[r_end * 8 - 1 : r_start * 8];
2184
+ hits[r].write_register(
2185
+ r_value & r_enabled_bytes, r_enabled_bytes, aux);
2186
+ }
2187
+ } catch {
2188
+ ok = false;
2145
2189
}
2190
+ }
2191
+ _callback_after_write(
2192
+ this._bank_obj(), dev._current_initiator, &offset, size,
2193
+ &ok, &_connections, &_after_write_callbacks);
2146
2194
2147
- hits[r].write_register(r_value & r_enabled_bytes, r_enabled_bytes,
2148
- aux) ;
2195
+ if (!ok) {
2196
+ throw ;
2149
2197
}
2150
2198
}
2151
2199
@@ -2240,7 +2288,8 @@ template bank is (object, shown_desc) {
2240
2288
default {
2241
2289
local uint64 size = SIM_get_mem_op_size(memop);
2242
2290
local bool inquiry = SIM_get_mem_op_inquiry(memop);
2243
- local conf_object_t *ini = SIM_get_mem_op_initiator(memop);
2291
+ local conf_object_t *prev_initiator = dev._current_initiator;
2292
+ dev._current_initiator = SIM_get_mem_op_initiator(memop);
2244
2293
2245
2294
local bool success = true;
2246
2295
if (inquiry) {
@@ -2262,53 +2311,33 @@ template bank is (object, shown_desc) {
2262
2311
} else {
2263
2312
if (SIM_mem_op_is_read(memop)) {
2264
2313
local uint64 value = 0;
2265
- local bool inquiry_override = false;
2266
- _callback_before_read(
2267
- this._bank_obj(), ini, &inquiry_override,
2268
- &offset, size, &_connections, &_before_read_callbacks);
2269
2314
try {
2270
- if (inquiry_override) {
2271
- value = this.get(offset, size);
2272
- } else {
2273
- value = this.read(offset, _mask(size), aux);
2274
- }
2315
+ value = this.read(offset, _mask(size), aux);
2275
2316
} catch {
2276
2317
success = false;
2277
2318
}
2278
- _callback_after_read(this._bank_obj(), ini, &offset, size,
2279
- &value, &success, &_connections,
2280
- &_after_read_callbacks);
2281
2319
2282
2320
if (success) {
2283
2321
this._memop_set_read_value(memop, value);
2284
2322
}
2285
2323
} else {
2286
2324
local uint64 writevalue = this._memop_write_value(memop);
2287
-
2288
- local bool suppress = false;
2289
- _callback_before_write(
2290
- this._bank_obj(), ini, &offset, size, &writevalue,
2291
- &suppress, &_connections, &_before_write_callbacks);
2292
- if (!suppress) {
2293
- try {
2294
- this.write(offset, writevalue, _mask(size), aux);
2295
- } catch {
2296
- success = false;
2297
- }
2325
+ try {
2326
+ this.write(offset, writevalue, _mask(size), aux);
2327
+ } catch {
2328
+ success = false;
2298
2329
}
2299
- _callback_after_write(this._bank_obj(), ini, &offset, size,
2300
- &success, &_connections,
2301
- &_after_write_callbacks);
2302
2330
}
2303
2331
}
2304
2332
2333
+ dev._current_initiator = prev_initiator;
2305
2334
return success;
2306
2335
}
2307
2336
2308
2337
shared method transaction_access(transaction_t *t, uint64 offset,
2309
2338
void *aux) -> (exception_type_t) default {
2310
2339
local uint64 size = SIM_transaction_size(t);
2311
- local conf_object_t *ini = SIM_transaction_initiator(t) ;
2340
+ local conf_object_t *ini = dev._current_initiator ;
2312
2341
local uint8 buf[size];
2313
2342
if (SIM_transaction_is_write(t)) {
2314
2343
local buffer_t bytes;
@@ -2346,7 +2375,8 @@ template bank is (object, shown_desc) {
2346
2375
shared method _transaction_access(
2347
2376
conf_object_t *ini, bool is_read, bool inquiry,
2348
2377
uint64 offset, uint64 size, uint8 *buf, void *aux) -> (bool) {
2349
-
2378
+ local conf_object_t *prev_ini = dev._current_initiator;
2379
+ dev._current_initiator = ini;
2350
2380
local bool success = true;
2351
2381
if (inquiry) {
2352
2382
if (is_read) {
@@ -2366,47 +2396,23 @@ template bank is (object, shown_desc) {
2366
2396
}
2367
2397
} else {
2368
2398
if (is_read) {
2369
- local bool inquiry_override = false;
2370
- _callback_before_read(this._bank_obj(), ini,
2371
- &inquiry_override, &offset,
2372
- size, &_connections, &_before_read_callbacks);
2373
- local uint64 value = 0;
2374
2399
try {
2375
- if (inquiry_override) {
2376
- value = this.get(offset, size);
2377
- } else {
2378
- value = this.read(offset, _mask(size), aux);
2379
- }
2380
- } catch {
2381
- success = false;
2382
- }
2383
-
2384
- _callback_after_read(this._bank_obj(), ini, &offset, size,
2385
- &value, &success, &_connections,
2386
- &_after_read_callbacks);
2387
-
2388
- if (success) {
2400
+ local uint64 value = this.read(offset, _mask(size), aux);
2389
2401
this._set_read_value(size, buf, value);
2402
+ return true;
2403
+ } catch {
2404
+ return false;
2390
2405
}
2391
2406
} else {
2392
2407
local uint64 writevalue = this._write_value(size, buf);
2393
-
2394
- local bool suppress = false;
2395
- _callback_before_write(
2396
- this._bank_obj(), ini, &offset, size, &writevalue,
2397
- &suppress, &_connections, &_before_write_callbacks);
2398
- if (!suppress) {
2399
- try {
2400
- this.write(offset, writevalue, _mask(size), aux);
2401
- } catch {
2402
- success = false;
2403
- }
2408
+ try {
2409
+ this.write(offset, writevalue, _mask(size), aux);
2410
+ } catch {
2411
+ success = false;
2404
2412
}
2405
- _callback_after_write(this._bank_obj(), ini, &offset, size,
2406
- &success, &_connections,
2407
- &_after_write_callbacks);
2408
2413
}
2409
2414
}
2415
+ dev._current_initiator = prev_ini;
2410
2416
2411
2417
return success;
2412
2418
}
0 commit comments