[258] | 1 | /////////////////////////////////////////////////////////////////////////////////// |
---|
| 2 | // File : sys_handler.c |
---|
| 3 | // Date : 01/04/2012 |
---|
| 4 | // Author : alain greiner and joel porquet |
---|
| 5 | // Copyright (c) UPMC-LIP6 |
---|
| 6 | /////////////////////////////////////////////////////////////////////////////////// |
---|
| 7 | |
---|
| 8 | #include <sys_handler.h> |
---|
| 9 | #include <tty_driver.h> |
---|
| 10 | #include <tim_driver.h> |
---|
| 11 | #include <ioc_driver.h> |
---|
| 12 | #include <nic_driver.h> |
---|
[440] | 13 | #include <mmc_driver.h> |
---|
| 14 | #include <cma_driver.h> |
---|
[258] | 15 | #include <ctx_handler.h> |
---|
| 16 | #include <fat32.h> |
---|
| 17 | #include <utils.h> |
---|
[478] | 18 | #include <kernel_malloc.h> |
---|
[459] | 19 | #include <tty0.h> |
---|
[396] | 20 | #include <vmem.h> |
---|
[322] | 21 | #include <hard_config.h> |
---|
[258] | 22 | #include <giet_config.h> |
---|
| 23 | #include <mapping_info.h> |
---|
| 24 | |
---|
[322] | 25 | #if !defined(SEG_BOOT_MAPPING_BASE) |
---|
| 26 | # error: You must define SEG_BOOT_MAPPING_BASE in the hard_config.h file |
---|
| 27 | #endif |
---|
| 28 | |
---|
[449] | 29 | #if !defined(NB_TTY_CHANNELS) |
---|
| 30 | # error: You must define NB_TTY_CHANNELS in the hard_config.h file |
---|
| 31 | #endif |
---|
| 32 | |
---|
[459] | 33 | #if (NB_TTY_CHANNELS < 1) |
---|
| 34 | # error: NB_TTY_CHANNELS cannot be smaller than 1! |
---|
| 35 | #endif |
---|
| 36 | |
---|
[449] | 37 | #if !defined(NB_TIM_CHANNELS) |
---|
| 38 | # error: You must define NB_TIM_CHANNELS in the hard_config.h file |
---|
| 39 | #endif |
---|
| 40 | |
---|
| 41 | #if !defined(NB_NIC_CHANNELS) |
---|
| 42 | # error: You must define NB_NIC_CHANNELS in the hard_config.h file |
---|
| 43 | #endif |
---|
| 44 | |
---|
| 45 | #if !defined(NB_CMA_CHANNELS) |
---|
| 46 | # error: You must define NB_CMA_CHANNELS in the hard_config.h file |
---|
| 47 | #endif |
---|
| 48 | |
---|
[478] | 49 | #if !defined(GIET_NO_HARD_CC) |
---|
| 50 | # error: You must define GIET_NO_HARD_CC in the giet_config.h file |
---|
[449] | 51 | #endif |
---|
| 52 | |
---|
[478] | 53 | #if !defined ( GIET_NIC_MAC4 ) |
---|
| 54 | # error: You must define GIET_NIC_MAC4 in the giet_config.h file |
---|
[449] | 55 | #endif |
---|
| 56 | |
---|
[478] | 57 | #if !defined ( GIET_NIC_MAC2 ) |
---|
| 58 | # error: You must define GIET_NIC_MAC2 in the giet_config.h file |
---|
[449] | 59 | #endif |
---|
| 60 | |
---|
| 61 | |
---|
[258] | 62 | //////////////////////////////////////////////////////////////////////////// |
---|
[440] | 63 | // Channel allocators for peripherals |
---|
| 64 | // (TTY[0] is reserved for kernel) |
---|
| 65 | //////////////////////////////////////////////////////////////////////////// |
---|
| 66 | |
---|
[478] | 67 | unsigned int _tty_channel_allocator = 1; |
---|
| 68 | unsigned int _tim_channel_allocator = 0; |
---|
| 69 | unsigned int _cma_channel_allocator = 0; |
---|
[449] | 70 | unsigned int _nic_rx_channel_allocator = 0; |
---|
| 71 | unsigned int _nic_tx_channel_allocator = 0; |
---|
[440] | 72 | |
---|
| 73 | //////////////////////////////////////////////////////////////////////////// |
---|
[478] | 74 | // NIC_RX and NIC_TX chbuf arrays |
---|
[449] | 75 | //////////////////////////////////////////////////////////////////////////// |
---|
| 76 | |
---|
[459] | 77 | nic_chbuf_t _nic_rx_chbuf[NB_NIC_CHANNELS] __attribute__((aligned(64))); |
---|
| 78 | |
---|
| 79 | nic_chbuf_t _nic_tx_chbuf[NB_NIC_CHANNELS] __attribute__((aligned(64))); |
---|
| 80 | |
---|
[478] | 81 | //////////////////////////////////////////////////////////////////////////// |
---|
| 82 | // FBF related chbuf descriptors array, indexed by the CMA channel index. |
---|
| 83 | // Physical addresses of these chbuf descriptors required for L2 cache sync. |
---|
| 84 | //////////////////////////////////////////////////////////////////////////// |
---|
[459] | 85 | |
---|
[478] | 86 | fbf_chbuf_t _fbf_chbuf[NB_CMA_CHANNELS] __attribute__((aligned(64))); |
---|
[459] | 87 | |
---|
[478] | 88 | unsigned long long _fbf_chbuf_paddr[NB_CMA_CHANNELS]; |
---|
| 89 | |
---|
[449] | 90 | //////////////////////////////////////////////////////////////////////////// |
---|
[258] | 91 | // Initialize the syscall vector with syscall handlers |
---|
| 92 | // Note: This array must be synchronised with the define in file stdio.h |
---|
| 93 | //////////////////////////////////////////////////////////////////////////// |
---|
| 94 | const void * _syscall_vector[64] = |
---|
| 95 | { |
---|
[440] | 96 | &_sys_proc_xyp, /* 0x00 */ |
---|
| 97 | &_get_proctime, /* 0x01 */ |
---|
| 98 | &_sys_tty_write, /* 0x02 */ |
---|
| 99 | &_sys_tty_read, /* 0x03 */ |
---|
| 100 | &_sys_tty_alloc, /* 0x04 */ |
---|
| 101 | &_sys_tty_get_lock, /* 0x05 */ |
---|
| 102 | &_sys_tty_release_lock, /* 0x06 */ |
---|
| 103 | &_sys_heap_info, /* 0x07 */ |
---|
| 104 | &_sys_local_task_id, /* 0x08 */ |
---|
| 105 | &_sys_global_task_id, /* 0x09 */ |
---|
| 106 | &_sys_fbf_cma_alloc, /* 0x0A */ |
---|
| 107 | &_sys_fbf_cma_start, /* 0x0B */ |
---|
| 108 | &_sys_fbf_cma_display, /* 0x0C */ |
---|
| 109 | &_sys_fbf_cma_stop, /* 0x0D */ |
---|
| 110 | &_sys_task_exit, /* 0x0E */ |
---|
| 111 | &_sys_procs_number, /* 0x0F */ |
---|
[258] | 112 | |
---|
[440] | 113 | &_sys_fbf_sync_write, /* 0x10 */ |
---|
| 114 | &_sys_fbf_sync_read, /* 0x11 */ |
---|
| 115 | &_sys_thread_id, /* 0x12 */ |
---|
| 116 | &_sys_ukn, /* 0x13 */ |
---|
| 117 | &_sys_tim_alloc, /* 0x14 */ |
---|
| 118 | &_sys_tim_start, /* 0x15 */ |
---|
| 119 | &_sys_tim_stop, /* 0x16 */ |
---|
| 120 | &_sys_ukn, /* 0x17 */ |
---|
| 121 | &_sys_ukn, /* 0x18 */ |
---|
| 122 | &_context_switch, /* 0x19 */ |
---|
| 123 | &_sys_vobj_get_vbase, /* 0x1A */ |
---|
| 124 | &_sys_vobj_get_length, /* 0x1B */ |
---|
| 125 | &_sys_xy_from_ptr, /* 0x1C */ |
---|
[449] | 126 | &_sys_ukn, /* 0x1D */ |
---|
| 127 | &_sys_ukn, /* 0x1E */ |
---|
| 128 | &_sys_ukn, /* 0x1F */ |
---|
[258] | 129 | |
---|
[440] | 130 | &_fat_user_open, /* 0x20 */ |
---|
| 131 | &_fat_user_read, /* 0x21 */ |
---|
| 132 | &_fat_user_write, /* 0x22 */ |
---|
| 133 | &_fat_user_lseek, /* 0x23 */ |
---|
| 134 | &_fat_fstat, /* 0x24 */ |
---|
| 135 | &_fat_close, /* 0x25 */ |
---|
| 136 | &_sys_ukn, /* 0x26 */ |
---|
| 137 | &_sys_ukn, /* 0x27 */ |
---|
| 138 | &_sys_ukn, /* 0x28 */ |
---|
| 139 | &_sys_ukn, /* 0x29 */ |
---|
| 140 | &_sys_ukn, /* 0x2A */ |
---|
| 141 | &_sys_ukn, /* 0x2B */ |
---|
| 142 | &_sys_ukn, /* 0x2C */ |
---|
| 143 | &_sys_ukn, /* 0x2D */ |
---|
| 144 | &_sys_ukn, /* 0x2E */ |
---|
| 145 | &_sys_ukn, /* 0x2F */ |
---|
[258] | 146 | |
---|
[449] | 147 | &_sys_nic_alloc, /* 0x30 */ |
---|
[459] | 148 | &_sys_nic_start, /* 0x31 */ |
---|
| 149 | &_sys_nic_move, /* 0x32 */ |
---|
| 150 | &_sys_nic_stop, /* 0x33 */ |
---|
| 151 | &_sys_nic_stats, /* 0x34 */ |
---|
| 152 | &_sys_nic_clear, /* 0x35 */ |
---|
| 153 | &_sys_ukn, /* 0x36 */ |
---|
| 154 | &_sys_ukn, /* 0x37 */ |
---|
[440] | 155 | &_sys_ukn, /* 0x38 */ |
---|
| 156 | &_sys_ukn, /* 0x39 */ |
---|
| 157 | &_sys_ukn, /* 0x3A */ |
---|
| 158 | &_sys_ukn, /* 0x3B */ |
---|
| 159 | &_sys_ukn, /* 0x3C */ |
---|
| 160 | &_sys_ukn, /* 0x3D */ |
---|
| 161 | &_sys_ukn, /* 0x3E */ |
---|
| 162 | &_sys_ukn, /* 0x3F */ |
---|
[258] | 163 | }; |
---|
| 164 | |
---|
[459] | 165 | |
---|
[258] | 166 | ////////////////////////////////////////////////////////////////////////////// |
---|
[440] | 167 | // TTY related syscall handlers |
---|
[258] | 168 | ////////////////////////////////////////////////////////////////////////////// |
---|
[440] | 169 | |
---|
| 170 | //////////////////// |
---|
| 171 | int _sys_tty_alloc() |
---|
[258] | 172 | { |
---|
[440] | 173 | // get a new TTY terminal index |
---|
[459] | 174 | unsigned int channel = _atomic_increment( &_tty_channel_allocator, 1 ); |
---|
[440] | 175 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
| 176 | unsigned int vspace = _get_context_slot( CTX_VSID_ID ); |
---|
| 177 | |
---|
| 178 | if ( channel >= NB_TTY_CHANNELS ) |
---|
| 179 | { |
---|
| 180 | _printf("\n[GIET_ERROR] in _sys_tty_alloc() : not enough TTY channels\n"); |
---|
| 181 | return -1; |
---|
| 182 | } |
---|
| 183 | else |
---|
| 184 | { |
---|
| 185 | _printf("\n[GIET WARNING] TTY channel %d allocated " |
---|
| 186 | " to thread %d in vspace %d\n", channel, thread, vspace ); |
---|
[449] | 187 | _set_context_slot( CTX_TTY_ID, channel ); |
---|
| 188 | return 0; |
---|
[440] | 189 | } |
---|
[258] | 190 | } |
---|
| 191 | |
---|
[440] | 192 | ///////////////////////////////////////////////// |
---|
| 193 | int _sys_tty_write( const char* buffer, |
---|
| 194 | unsigned int length, // number of characters |
---|
| 195 | unsigned int channel) // channel index |
---|
| 196 | { |
---|
| 197 | unsigned int nwritten; |
---|
| 198 | |
---|
| 199 | // compute and check tty channel |
---|
| 200 | if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); |
---|
| 201 | if( channel >= NB_TTY_CHANNELS ) return -1; |
---|
| 202 | |
---|
| 203 | // write string to TTY channel |
---|
| 204 | for (nwritten = 0; nwritten < length; nwritten++) |
---|
| 205 | { |
---|
| 206 | // check tty's status |
---|
| 207 | if ( _tty_get_register( channel, TTY_STATUS ) & 0x2 ) break; |
---|
| 208 | |
---|
| 209 | // write one byte |
---|
| 210 | if (buffer[nwritten] == '\n') |
---|
| 211 | { |
---|
| 212 | _tty_set_register( channel, TTY_WRITE, (unsigned int)'\r' ); |
---|
| 213 | } |
---|
| 214 | _tty_set_register( channel, TTY_WRITE, (unsigned int)buffer[nwritten] ); |
---|
| 215 | } |
---|
| 216 | |
---|
| 217 | return nwritten; |
---|
| 218 | } |
---|
| 219 | |
---|
| 220 | //////////////////////////////////////////////// |
---|
| 221 | int _sys_tty_read( char* buffer, |
---|
| 222 | unsigned int length, // unused |
---|
| 223 | unsigned int channel) // channel index |
---|
| 224 | { |
---|
| 225 | // compute and check tty channel |
---|
| 226 | if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); |
---|
| 227 | if( channel >= NB_TTY_CHANNELS ) return -1; |
---|
| 228 | |
---|
| 229 | // read one character from TTY channel |
---|
| 230 | if (_tty_rx_full[channel] == 0) |
---|
| 231 | { |
---|
| 232 | return 0; |
---|
| 233 | } |
---|
| 234 | else |
---|
| 235 | { |
---|
| 236 | *buffer = _tty_rx_buf[channel]; |
---|
| 237 | _tty_rx_full[channel] = 0; |
---|
| 238 | return 1; |
---|
| 239 | } |
---|
| 240 | } |
---|
| 241 | |
---|
| 242 | /////////////////////////////////////////// |
---|
| 243 | int _sys_tty_get_lock( unsigned int channel, |
---|
| 244 | unsigned int * save_sr_ptr ) |
---|
| 245 | { |
---|
| 246 | // compute and check tty channel |
---|
| 247 | if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); |
---|
| 248 | if( channel >= NB_TTY_CHANNELS ) return -1; |
---|
| 249 | |
---|
| 250 | _it_disable( save_sr_ptr ); |
---|
[467] | 251 | _sbt_lock_acquire( &_tty_tx_lock[channel] ); |
---|
[440] | 252 | return 0; |
---|
| 253 | } |
---|
| 254 | |
---|
| 255 | /////////////////////////////////////////////// |
---|
| 256 | int _sys_tty_release_lock( unsigned int channel, |
---|
| 257 | unsigned int * save_sr_ptr ) |
---|
| 258 | { |
---|
| 259 | // compute and check tty channel |
---|
| 260 | if( channel == 0xFFFFFFFF ) channel = _get_context_slot(CTX_TTY_ID); |
---|
| 261 | if( channel >= NB_TTY_CHANNELS ) return -1; |
---|
| 262 | |
---|
[467] | 263 | _sbt_lock_release( &_tty_tx_lock[channel] ); |
---|
[440] | 264 | _it_restore( save_sr_ptr ); |
---|
| 265 | return 0; |
---|
| 266 | } |
---|
| 267 | |
---|
[428] | 268 | ////////////////////////////////////////////////////////////////////////////// |
---|
[440] | 269 | // TIM related syscall handlers |
---|
[428] | 270 | ////////////////////////////////////////////////////////////////////////////// |
---|
[440] | 271 | |
---|
| 272 | //////////////////// |
---|
| 273 | int _sys_tim_alloc() |
---|
[428] | 274 | { |
---|
[440] | 275 | // get a new timer index |
---|
[459] | 276 | unsigned int channel = _atomic_increment( &_tim_channel_allocator, 1 ); |
---|
[440] | 277 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
| 278 | unsigned int vspace = _get_context_slot( CTX_VSID_ID ); |
---|
| 279 | |
---|
| 280 | if ( channel >= NB_TIM_CHANNELS ) |
---|
| 281 | { |
---|
| 282 | _printf("\n[GIET_ERROR] in _sys_tim_alloc() : not enough TIM channels\n"); |
---|
| 283 | return -1; |
---|
| 284 | } |
---|
| 285 | else |
---|
| 286 | { |
---|
| 287 | _printf("\n[GIET WARNING] TIM channel %d allocated " |
---|
| 288 | " to thread %d in vspace %d\n", channel, thread, vspace ); |
---|
[449] | 289 | _set_context_slot( CTX_TIM_ID, channel ); |
---|
| 290 | return 0; |
---|
[440] | 291 | } |
---|
| 292 | } |
---|
| 293 | |
---|
| 294 | ///////////////////////////////////////// |
---|
| 295 | int _sys_tim_start( unsigned int period ) |
---|
| 296 | { |
---|
| 297 | // get timer index |
---|
| 298 | unsigned int channel = _get_context_slot( CTX_TIM_ID ); |
---|
| 299 | if ( channel >= NB_TIM_CHANNELS ) |
---|
| 300 | { |
---|
| 301 | _printf("\n[GIET_ERROR] in _sys_tim_start() : not enough TIM channels\n"); |
---|
| 302 | return -1; |
---|
| 303 | } |
---|
| 304 | |
---|
| 305 | // start timer |
---|
| 306 | _timer_start( channel, period ); |
---|
| 307 | |
---|
| 308 | return 0; |
---|
| 309 | } |
---|
| 310 | |
---|
| 311 | /////////////////// |
---|
| 312 | int _sys_tim_stop() |
---|
| 313 | { |
---|
| 314 | // get timer index |
---|
| 315 | unsigned int channel = _get_context_slot( CTX_TIM_ID ); |
---|
| 316 | if ( channel >= NB_TIM_CHANNELS ) |
---|
| 317 | { |
---|
| 318 | _printf("\n[GIET_ERROR] in _sys_tim_stop() : illegal timer index\n"); |
---|
| 319 | return -1; |
---|
| 320 | } |
---|
| 321 | |
---|
| 322 | // stop timer |
---|
| 323 | _timer_stop( channel ); |
---|
| 324 | |
---|
| 325 | return 0; |
---|
| 326 | } |
---|
| 327 | |
---|
| 328 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 329 | // NIC related syscall handlers |
---|
| 330 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 331 | |
---|
[478] | 332 | #define NIC_CONTAINER_SIZE 4096 |
---|
| 333 | |
---|
[449] | 334 | /////////////////////////////////////////// |
---|
| 335 | int _sys_nic_alloc( unsigned int is_rx ) |
---|
[440] | 336 | { |
---|
[459] | 337 | |
---|
| 338 | #if GIET_DEBUG_NIC |
---|
| 339 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
[478] | 340 | _printf("\n[GIET DEBUG NIC] Task %d enters sys_nic_alloc() at cycle %d\n", |
---|
| 341 | thread, _get_proctime() ); |
---|
[459] | 342 | #endif |
---|
| 343 | |
---|
[449] | 344 | unsigned int nic_channel; |
---|
| 345 | unsigned int cma_channel; |
---|
[440] | 346 | |
---|
[449] | 347 | // get a NIC_RX or NIC_TX channel index |
---|
[459] | 348 | if ( is_rx ) nic_channel = _atomic_increment( &_nic_rx_channel_allocator, 1 ); |
---|
| 349 | else nic_channel = _atomic_increment( &_nic_tx_channel_allocator, 1 ); |
---|
[449] | 350 | |
---|
| 351 | if ( (nic_channel >= NB_NIC_CHANNELS) ) |
---|
[440] | 352 | { |
---|
[449] | 353 | _printf("\n[GIET_ERROR] in _sys_nic_alloc() not enough NIC channels\n"); |
---|
[440] | 354 | return -1; |
---|
| 355 | } |
---|
[449] | 356 | |
---|
| 357 | // get a CMA channel index |
---|
[459] | 358 | cma_channel = _atomic_increment( &_cma_channel_allocator, 1 ); |
---|
[449] | 359 | |
---|
| 360 | if ( cma_channel >= NB_CMA_CHANNELS ) |
---|
| 361 | { |
---|
| 362 | _printf("\n[GIET_ERROR] in _sys_nic_alloc() not enough CMA channels\n"); |
---|
| 363 | return -1; |
---|
| 364 | } |
---|
[459] | 365 | |
---|
[449] | 366 | // register nic_index and cma_index in task context |
---|
| 367 | if ( is_rx ) |
---|
| 368 | { |
---|
| 369 | _set_context_slot( CTX_NIC_RX_ID, nic_channel ); |
---|
| 370 | _set_context_slot( CTX_CMA_RX_ID, cma_channel ); |
---|
| 371 | } |
---|
[440] | 372 | else |
---|
| 373 | { |
---|
[449] | 374 | _set_context_slot( CTX_NIC_TX_ID, nic_channel ); |
---|
| 375 | _set_context_slot( CTX_CMA_TX_ID, cma_channel ); |
---|
[440] | 376 | } |
---|
| 377 | |
---|
[449] | 378 | #if GIET_DEBUG_NIC |
---|
[478] | 379 | _printf("\n[GIET DEBUG NIC] Task %d exit _sys_nic_alloc() at cycle %d : " |
---|
[459] | 380 | "NIC channel = %d / CMA channel = %d\n", |
---|
[478] | 381 | thread, _get_proctime(), nic_channel, cma_channel ); |
---|
[449] | 382 | #endif |
---|
[440] | 383 | |
---|
[459] | 384 | return nic_channel; |
---|
| 385 | } // end _sys_nic_alloc() |
---|
[440] | 386 | |
---|
[449] | 387 | //////////////////////////////////////// |
---|
[489] | 388 | int _sys_nic_start( unsigned int is_rx, |
---|
| 389 | unsigned int channel ) |
---|
[440] | 390 | { |
---|
[459] | 391 | |
---|
| 392 | #if GIET_DEBUG_NIC |
---|
| 393 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
[478] | 394 | _printf("\n[GIET DEBUG NIC] Task %d enters _sys_nic_start() at cycle %d\n", |
---|
| 395 | thread , _get_proctime() ); |
---|
[459] | 396 | #endif |
---|
| 397 | |
---|
[449] | 398 | unsigned int nic_channel; |
---|
| 399 | unsigned int cma_channel; |
---|
| 400 | |
---|
| 401 | // get NIC channel index and CMA channel index |
---|
| 402 | if ( is_rx ) |
---|
| 403 | { |
---|
| 404 | nic_channel = _get_context_slot( CTX_NIC_RX_ID ); |
---|
| 405 | cma_channel = _get_context_slot( CTX_CMA_RX_ID ); |
---|
| 406 | } |
---|
| 407 | else |
---|
| 408 | { |
---|
| 409 | nic_channel = _get_context_slot( CTX_NIC_TX_ID ); |
---|
| 410 | cma_channel = _get_context_slot( CTX_CMA_TX_ID ); |
---|
| 411 | } |
---|
| 412 | |
---|
[459] | 413 | #if GIET_DEBUG_NIC |
---|
[478] | 414 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_start() at cycle %d" |
---|
[459] | 415 | " get NIC channel = %d / CMA channel = %d\n", |
---|
[478] | 416 | thread, _get_proctime(), nic_channel, cma_channel ); |
---|
[459] | 417 | #endif |
---|
| 418 | |
---|
[489] | 419 | if ( nic_channel != channel ) |
---|
[449] | 420 | { |
---|
[489] | 421 | _printf("\n[GIET_ERROR] in _sys_nic_start(): illegal NIC channel\n"); |
---|
[449] | 422 | return -1; |
---|
| 423 | } |
---|
| 424 | if ( cma_channel >= NB_CMA_CHANNELS ) |
---|
| 425 | { |
---|
[489] | 426 | _printf("\n[GIET_ERROR] in _sys_nic_start(): illegal CMA channel\n"); |
---|
[449] | 427 | return -1; |
---|
| 428 | } |
---|
| 429 | |
---|
[459] | 430 | unsigned long long nic_chbuf_pbase; // NIC chbuf physical address |
---|
| 431 | unsigned long long ker_chbuf_pbase; // kernel chbuf physical address |
---|
[449] | 432 | |
---|
[478] | 433 | // These variables are used for the various V2P translation |
---|
[459] | 434 | unsigned int ptab = _get_context_slot(CTX_PTAB_ID); |
---|
| 435 | unsigned int ppn; |
---|
| 436 | unsigned int flags; |
---|
| 437 | unsigned int vaddr; |
---|
| 438 | |
---|
[478] | 439 | // allocate two containers per cluster |
---|
| 440 | unsigned int cx; // container X coordinate |
---|
| 441 | unsigned int cy; // container Y coordinate |
---|
| 442 | unsigned int index; // container index in chbuf |
---|
| 443 | unsigned long long cont_paddr; // container physical address |
---|
| 444 | |
---|
| 445 | for ( cx = 0 ; cx < X_SIZE ; cx++ ) |
---|
| 446 | { |
---|
| 447 | for ( cy = 0 ; cy < Y_SIZE ; cy++ ) |
---|
| 448 | { |
---|
| 449 | // compute index in chbuf |
---|
| 450 | index = (cx * Y_SIZE) + cy; |
---|
| 451 | |
---|
| 452 | // allocate the container |
---|
| 453 | vaddr = (unsigned int)_remote_malloc( NIC_CONTAINER_SIZE, cx, cy ); |
---|
| 454 | |
---|
| 455 | // compute container physical address |
---|
| 456 | _v2p_translate( (page_table_t*)ptab, |
---|
| 457 | vaddr>>12, |
---|
| 458 | &ppn, |
---|
| 459 | &flags ); |
---|
| 460 | cont_paddr = (((unsigned long long)ppn) << 12) | (vaddr & 0x00000FFF); |
---|
| 461 | |
---|
| 462 | // initialize chbuf |
---|
| 463 | if ( is_rx ) _nic_rx_chbuf[nic_channel].buffer[index].desc = cont_paddr; |
---|
| 464 | else _nic_tx_chbuf[nic_channel].buffer[index].desc = cont_paddr; |
---|
| 465 | |
---|
| 466 | #if GIET_DEBUG_NIC |
---|
| 467 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_start()" |
---|
| 468 | " allocates container in cluster[%d,%d] : vaddr = %x / paddr = %l\n", |
---|
| 469 | thread , cx , cy , vaddr , cont_paddr ); |
---|
| 470 | #endif |
---|
| 471 | } |
---|
| 472 | } |
---|
| 473 | |
---|
| 474 | // compute the NIC chbuf descriptor physical address |
---|
[449] | 475 | unsigned int offset; |
---|
[459] | 476 | if ( is_rx ) offset = 0x4000; |
---|
[489] | 477 | else offset = 0x4080; |
---|
[459] | 478 | nic_chbuf_pbase = (((unsigned long long)((X_IO << Y_WIDTH) + Y_IO))<<32) | |
---|
| 479 | (SEG_NIC_BASE + (nic_channel<<15) + offset); |
---|
[449] | 480 | |
---|
[459] | 481 | #if GIET_DEBUG_NIC |
---|
[478] | 482 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_start()" |
---|
| 483 | " get NIC chbuf : paddr = %l\n", |
---|
| 484 | thread , nic_chbuf_pbase ); |
---|
[459] | 485 | #endif |
---|
[449] | 486 | |
---|
| 487 | // compute the kernel chbuf descriptor physical address |
---|
[459] | 488 | if ( is_rx ) vaddr = (unsigned int)( &_nic_rx_chbuf[nic_channel] ); |
---|
| 489 | else vaddr = (unsigned int)( &_nic_tx_chbuf[nic_channel] ); |
---|
[478] | 490 | _v2p_translate( (page_table_t*)ptab, |
---|
| 491 | vaddr>>12, |
---|
| 492 | &ppn, |
---|
| 493 | &flags ); |
---|
[459] | 494 | ker_chbuf_pbase = (((unsigned long long)ppn) << 12) | (vaddr & 0x00000FFF); |
---|
[440] | 495 | |
---|
[459] | 496 | #if GIET_DEBUG_NIC |
---|
[478] | 497 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_start()" |
---|
| 498 | " get kernel chbuf : vaddr = %x / paddr = %l\n", |
---|
| 499 | thread , vaddr , ker_chbuf_pbase ); |
---|
[459] | 500 | #endif |
---|
[440] | 501 | |
---|
[459] | 502 | // sync the kernel chbuf in L2 after write in L2 |
---|
| 503 | _mmc_sync( ker_chbuf_pbase, sizeof( nic_chbuf_t ) ); |
---|
| 504 | |
---|
| 505 | // initializes CMA registers defining the source & destination chbufs |
---|
| 506 | if ( is_rx ) // NIC to kernel |
---|
| 507 | { |
---|
| 508 | _cma_set_register( cma_channel, CHBUF_SRC_DESC , (unsigned int)(nic_chbuf_pbase) ); |
---|
| 509 | _cma_set_register( cma_channel, CHBUF_SRC_EXT , (unsigned int)(nic_chbuf_pbase>>32) ); |
---|
| 510 | _cma_set_register( cma_channel, CHBUF_SRC_NBUFS, 2 ); |
---|
| 511 | _cma_set_register( cma_channel, CHBUF_DST_DESC , (unsigned int)(ker_chbuf_pbase) ); |
---|
| 512 | _cma_set_register( cma_channel, CHBUF_DST_EXT , (unsigned int)(ker_chbuf_pbase>>32) ); |
---|
[478] | 513 | _cma_set_register( cma_channel, CHBUF_DST_NBUFS, X_SIZE*Y_SIZE ); |
---|
[459] | 514 | } |
---|
| 515 | else // kernel to NIC |
---|
| 516 | { |
---|
| 517 | _cma_set_register( cma_channel, CHBUF_SRC_DESC , (unsigned int)(ker_chbuf_pbase) ); |
---|
| 518 | _cma_set_register( cma_channel, CHBUF_SRC_EXT , (unsigned int)(ker_chbuf_pbase>>32) ); |
---|
[478] | 519 | _cma_set_register( cma_channel, CHBUF_SRC_NBUFS, X_SIZE*Y_SIZE ); |
---|
[459] | 520 | _cma_set_register( cma_channel, CHBUF_DST_DESC , (unsigned int)(nic_chbuf_pbase) ); |
---|
| 521 | _cma_set_register( cma_channel, CHBUF_DST_EXT , (unsigned int)(nic_chbuf_pbase>>32) ); |
---|
| 522 | _cma_set_register( cma_channel, CHBUF_DST_NBUFS, 2 ); |
---|
| 523 | } |
---|
| 524 | |
---|
[449] | 525 | // start CMA transfer |
---|
[478] | 526 | _cma_set_register( cma_channel, CHBUF_BUF_SIZE , NIC_CONTAINER_SIZE ); |
---|
| 527 | _cma_set_register( cma_channel, CHBUF_PERIOD , 0 ); // OUT_OF_ORDER mode |
---|
[449] | 528 | _cma_set_register( cma_channel, CHBUF_RUN , 1 ); |
---|
| 529 | |
---|
| 530 | // activates NIC channel |
---|
[459] | 531 | _nic_channel_start( nic_channel, is_rx, GIET_NIC_MAC4, GIET_NIC_MAC2 ); |
---|
| 532 | |
---|
| 533 | #if GIET_DEBUG_NIC |
---|
[478] | 534 | _printf("\n[GIET DEBUG NIC] Task %d exit _sys_nic_start() at cycle %d\n", |
---|
| 535 | thread , _get_proctime() ); |
---|
[459] | 536 | #endif |
---|
| 537 | |
---|
[449] | 538 | return 0; |
---|
[459] | 539 | } // end sys_nic_start() |
---|
[449] | 540 | |
---|
| 541 | ////////////////////////////////////// |
---|
| 542 | int _sys_nic_move( unsigned int is_rx, |
---|
[459] | 543 | unsigned int channel, |
---|
[449] | 544 | void* buffer ) |
---|
| 545 | { |
---|
| 546 | |
---|
[459] | 547 | #if GIET_DEBUG_NIC |
---|
| 548 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
[478] | 549 | _printf("\n[GIET DEBUG NIC] Task %d enters _sys_nic_move() at cycle %d\n", |
---|
| 550 | thread , _get_proctime() ); |
---|
[459] | 551 | #endif |
---|
| 552 | |
---|
[478] | 553 | // get cluster coordinates for the processor running the calling task |
---|
| 554 | unsigned int procid = _get_procid(); |
---|
| 555 | unsigned int cx = procid >> (Y_WIDTH + P_WIDTH); |
---|
| 556 | unsigned int cy = (procid >> P_WIDTH) & ((1<<Y_WIDTH)-1); |
---|
| 557 | |
---|
[459] | 558 | unsigned long long user_buffer_paddr; // user buffer physical address |
---|
| 559 | unsigned long long kernel_buffer_paddr; // kernel buffer physical address |
---|
| 560 | unsigned long long kernel_chbuf_paddr; // kernel chbuf physical address |
---|
[478] | 561 | unsigned long long buffer_desc; // kernel buffer descriptor |
---|
| 562 | unsigned long long buffer_desc_paddr; // kernel buffer descriptor physical address |
---|
| 563 | unsigned int index; // kernel buffer index in chbuf |
---|
[459] | 564 | |
---|
| 565 | // The following variables are used for V2P translation |
---|
| 566 | unsigned int ptab = _get_context_slot( CTX_PTAB_ID ); |
---|
[449] | 567 | unsigned int ppn; |
---|
| 568 | unsigned int flags; |
---|
[459] | 569 | unsigned int vaddr; |
---|
| 570 | |
---|
| 571 | // Compute user buffer physical address and check access rights |
---|
| 572 | vaddr = (unsigned int)buffer; |
---|
[478] | 573 | _v2p_translate( (page_table_t*)ptab, |
---|
| 574 | vaddr>>12, |
---|
| 575 | &ppn, |
---|
| 576 | &flags ); |
---|
| 577 | |
---|
[440] | 578 | if ( (flags & PTE_U) == 0 ) |
---|
| 579 | { |
---|
[449] | 580 | _printf("\n[GIET ERROR] in _sys_nic_tx_move() : illegal buffer address\n"); |
---|
[440] | 581 | return -1; |
---|
| 582 | } |
---|
[459] | 583 | user_buffer_paddr = ((unsigned long long)ppn << 12) | (vaddr & 0x00000FFF); |
---|
[440] | 584 | |
---|
[459] | 585 | #if GIET_DEBUG_NIC |
---|
[478] | 586 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() get user buffer : paddr = %l\n", |
---|
| 587 | thread, user_buffer_paddr ); |
---|
[459] | 588 | #endif |
---|
[440] | 589 | |
---|
[459] | 590 | // check NIC channel index |
---|
[449] | 591 | if ( channel >= NB_NIC_CHANNELS ) |
---|
| 592 | { |
---|
| 593 | _printf("\n[GIET_ERROR] in _sys_nic_move() : illegal NIC channel index\n"); |
---|
| 594 | return -1; |
---|
| 595 | } |
---|
| 596 | |
---|
[478] | 597 | // get kernel chbuf virtual address |
---|
[449] | 598 | nic_chbuf_t* chbuf; |
---|
[478] | 599 | if ( is_rx ) chbuf = &_nic_rx_chbuf[channel]; |
---|
| 600 | else chbuf = &_nic_tx_chbuf[channel]; |
---|
[449] | 601 | |
---|
[459] | 602 | // compute kernel chbuf physical address (required for sync) |
---|
| 603 | vaddr = (unsigned int)chbuf; |
---|
[478] | 604 | _v2p_translate( (page_table_t*)ptab, |
---|
| 605 | vaddr>>12, |
---|
| 606 | &ppn, |
---|
| 607 | &flags ); |
---|
[459] | 608 | kernel_chbuf_paddr = ((unsigned long long)ppn << 12) | (vaddr & 0x00000FFF); |
---|
| 609 | |
---|
[478] | 610 | // poll chbuf until success |
---|
| 611 | while ( 1 ) |
---|
[449] | 612 | { |
---|
[478] | 613 | // compute buffer index and buffer descriptor paddr |
---|
| 614 | index = (Y_SIZE * cx) + cy; |
---|
| 615 | buffer_desc_paddr = kernel_chbuf_paddr + (index<<6); |
---|
[459] | 616 | |
---|
[478] | 617 | // inval buffer descriptor in L2 before read in L2 |
---|
| 618 | _mmc_inval( buffer_desc_paddr , 8 ); |
---|
| 619 | buffer_desc = chbuf->buffer[index].desc; |
---|
[459] | 620 | |
---|
| 621 | #if GIET_DEBUG_NIC |
---|
[478] | 622 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() read buffer descriptor %d\n" |
---|
| 623 | " at cycle = %d / paddr = %l / buffer descriptor = %l\n", |
---|
| 624 | thread, index, _get_proctime(), buffer_desc_paddr, buffer_desc ); |
---|
[459] | 625 | #endif |
---|
| 626 | |
---|
[478] | 627 | // test buffer status and break if found |
---|
| 628 | if ( ( is_rx != 0 ) && (buffer_desc >> 63) == 1 ) break; |
---|
| 629 | if ( ( is_rx == 0 ) && (buffer_desc >> 63) == 0 ) break; |
---|
[449] | 630 | } |
---|
[459] | 631 | |
---|
| 632 | // compute kernel buffer physical address |
---|
[478] | 633 | kernel_buffer_paddr = buffer_desc & 0x0000FFFFFFFFFFFFULL; |
---|
[449] | 634 | |
---|
[459] | 635 | // move one container, using a physical_memcpy |
---|
| 636 | if ( is_rx ) |
---|
| 637 | { |
---|
| 638 | // inval kernel buffer in L2 before read in L2 |
---|
[478] | 639 | _mmc_inval( kernel_buffer_paddr, NIC_CONTAINER_SIZE ); |
---|
[449] | 640 | |
---|
[459] | 641 | // transfer data from kernel buffer to user buffer |
---|
| 642 | _physical_memcpy( user_buffer_paddr, |
---|
| 643 | kernel_buffer_paddr, |
---|
[478] | 644 | NIC_CONTAINER_SIZE ); |
---|
| 645 | #if GIET_DEBUG_NIC |
---|
| 646 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() transfer " |
---|
| 647 | "kernel buffer %l to user buffer %l at cycle %d\n", |
---|
| 648 | thread , kernel_buffer_paddr , user_buffer_paddr , _get_proctime() ); |
---|
| 649 | #endif |
---|
[449] | 650 | |
---|
[459] | 651 | } |
---|
| 652 | else |
---|
| 653 | { |
---|
| 654 | // transfer data from user buffer to kernel buffer |
---|
| 655 | _physical_memcpy( kernel_buffer_paddr, |
---|
| 656 | user_buffer_paddr, |
---|
[478] | 657 | NIC_CONTAINER_SIZE ); |
---|
[449] | 658 | |
---|
[459] | 659 | // sync kernel buffer in L2 after write in L2 |
---|
[478] | 660 | _mmc_sync( kernel_buffer_paddr, NIC_CONTAINER_SIZE ); |
---|
| 661 | |
---|
| 662 | #if GIET_DEBUG_NIC |
---|
| 663 | _printf("\n[GIET DEBUG NIC] Task %d in _sys_nic_move() transfer " |
---|
| 664 | "user buffer %l to kernel buffer %l at cycle %d\n", |
---|
| 665 | thread , user_buffer_paddr , kernel_buffer_paddr , _get_proctime() ); |
---|
| 666 | #endif |
---|
| 667 | |
---|
[459] | 668 | } |
---|
| 669 | |
---|
[478] | 670 | // update kernel chbuf status |
---|
| 671 | if ( is_rx ) chbuf->buffer[index].desc = kernel_buffer_paddr & 0x0000FFFFFFFFFFFFULL; |
---|
| 672 | else chbuf->buffer[index].desc = kernel_buffer_paddr | 0x8000000000000000ULL; |
---|
[459] | 673 | |
---|
| 674 | // sync kernel chbuf in L2 after write in L2 |
---|
[478] | 675 | _mmc_sync( kernel_chbuf_paddr + (index<<6) , 8 ); |
---|
[459] | 676 | |
---|
| 677 | #if GIET_DEBUG_NIC |
---|
[478] | 678 | _printf("\n[GIET DEBUG NIC] Task %d get buffer %d and exit _sys_nic_move() at cycle %d\n", |
---|
| 679 | thread , index , _get_proctime() ); |
---|
[459] | 680 | #endif |
---|
| 681 | |
---|
[440] | 682 | return 0; |
---|
[449] | 683 | } // end _sys_nic_move() |
---|
[440] | 684 | |
---|
[449] | 685 | //////////////////////////////////////// |
---|
[489] | 686 | int _sys_nic_stop( unsigned int is_rx, |
---|
| 687 | unsigned int channel ) |
---|
[440] | 688 | { |
---|
[449] | 689 | unsigned int nic_channel; |
---|
| 690 | unsigned int cma_channel; |
---|
[440] | 691 | |
---|
[449] | 692 | // get NIC channel index and CMA channel index |
---|
| 693 | if ( is_rx ) |
---|
[440] | 694 | { |
---|
[449] | 695 | nic_channel = _get_context_slot( CTX_NIC_RX_ID ); |
---|
| 696 | cma_channel = _get_context_slot( CTX_CMA_RX_ID ); |
---|
[440] | 697 | } |
---|
[449] | 698 | else |
---|
| 699 | { |
---|
| 700 | nic_channel = _get_context_slot( CTX_NIC_TX_ID ); |
---|
| 701 | cma_channel = _get_context_slot( CTX_CMA_TX_ID ); |
---|
| 702 | } |
---|
[440] | 703 | |
---|
[489] | 704 | if ( nic_channel != channel ) |
---|
[440] | 705 | { |
---|
[489] | 706 | _printf("\n[GIET_ERROR] in _sys_nic_stop(): illegal NIC channel\n" |
---|
| 707 | " allocated channel = %d / requested channel = %d\n", |
---|
| 708 | nic_channel , channel ); |
---|
[440] | 709 | return -1; |
---|
| 710 | } |
---|
[449] | 711 | if ( cma_channel >= NB_CMA_CHANNELS ) |
---|
[440] | 712 | { |
---|
[489] | 713 | _printf("\n[GIET_ERROR] in _sys_nic_stop(): illegal CMA channel\n"); |
---|
[440] | 714 | return -1; |
---|
| 715 | } |
---|
| 716 | |
---|
[449] | 717 | // desactivates the NIC channel |
---|
| 718 | _nic_channel_stop( nic_channel, is_rx ); |
---|
[440] | 719 | |
---|
[449] | 720 | // desactivates the CMA channel |
---|
| 721 | _cma_channel_stop( cma_channel ); |
---|
| 722 | |
---|
[440] | 723 | return 0; |
---|
| 724 | } |
---|
| 725 | |
---|
[459] | 726 | //////////////////////////////////////// |
---|
[489] | 727 | int _sys_nic_clear( unsigned int is_rx, |
---|
| 728 | unsigned int channel ) |
---|
[459] | 729 | { |
---|
| 730 | unsigned int nic_channel; |
---|
| 731 | |
---|
| 732 | // get NIC channel |
---|
| 733 | if ( is_rx ) nic_channel = _get_context_slot( CTX_NIC_RX_ID ); |
---|
| 734 | else nic_channel = _get_context_slot( CTX_NIC_TX_ID ); |
---|
| 735 | |
---|
[489] | 736 | if ( nic_channel != channel ) |
---|
[459] | 737 | { |
---|
[489] | 738 | _printf("\n[GIET_ERROR] in _sys_nic_clear(): illegal NIC channel\n"); |
---|
[459] | 739 | return -1; |
---|
| 740 | } |
---|
| 741 | |
---|
| 742 | if ( is_rx ) |
---|
| 743 | { |
---|
| 744 | _nic_set_global_register( NIC_G_NPKT_RX_G2S_RECEIVED , 0 ); |
---|
| 745 | _nic_set_global_register( NIC_G_NPKT_RX_DES_TOO_SMALL , 0 ); |
---|
| 746 | _nic_set_global_register( NIC_G_NPKT_RX_DES_TOO_BIG , 0 ); |
---|
| 747 | _nic_set_global_register( NIC_G_NPKT_RX_DES_MFIFO_FULL , 0 ); |
---|
| 748 | _nic_set_global_register( NIC_G_NPKT_RX_DES_CRC_FAIL , 0 ); |
---|
| 749 | _nic_set_global_register( NIC_G_NPKT_RX_DISPATCH_RECEIVED , 0 ); |
---|
| 750 | _nic_set_global_register( NIC_G_NPKT_RX_DISPATCH_BROADCAST , 0 ); |
---|
| 751 | _nic_set_global_register( NIC_G_NPKT_RX_DISPATCH_DST_FAIL , 0 ); |
---|
| 752 | _nic_set_global_register( NIC_G_NPKT_RX_DISPATCH_CH_FULL , 0 ); |
---|
| 753 | } |
---|
| 754 | else |
---|
| 755 | { |
---|
| 756 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_RECEIVED , 0 ); |
---|
| 757 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_TRANSMIT , 0 ); |
---|
| 758 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_TOO_BIG , 0 ); |
---|
| 759 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_TOO_SMALL , 0 ); |
---|
| 760 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_SRC_FAIL , 0 ); |
---|
| 761 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_BYPASS , 0 ); |
---|
| 762 | _nic_set_global_register( NIC_G_NPKT_TX_DISPATCH_BROADCAST , 0 ); |
---|
| 763 | } |
---|
| 764 | return 0; |
---|
| 765 | } |
---|
| 766 | |
---|
| 767 | //////////////////////////////////////// |
---|
[489] | 768 | int _sys_nic_stats( unsigned int is_rx, |
---|
| 769 | unsigned int channel ) |
---|
[459] | 770 | { |
---|
| 771 | unsigned int nic_channel; |
---|
| 772 | |
---|
| 773 | // get NIC channel |
---|
| 774 | if ( is_rx ) nic_channel = _get_context_slot( CTX_NIC_RX_ID ); |
---|
| 775 | else nic_channel = _get_context_slot( CTX_NIC_TX_ID ); |
---|
| 776 | |
---|
[489] | 777 | if ( nic_channel != channel ) |
---|
[459] | 778 | { |
---|
[489] | 779 | _printf("\n[GIET_ERROR] in _sys_nic_stats(): illegal NIC channel\n"); |
---|
[459] | 780 | return -1; |
---|
| 781 | } |
---|
| 782 | |
---|
| 783 | if ( is_rx ) |
---|
| 784 | { |
---|
| 785 | unsigned int received = _nic_get_global_register( NIC_G_NPKT_RX_G2S_RECEIVED ); |
---|
| 786 | unsigned int too_small = _nic_get_global_register( NIC_G_NPKT_RX_DES_TOO_SMALL ); |
---|
| 787 | unsigned int too_big = _nic_get_global_register( NIC_G_NPKT_RX_DES_TOO_BIG ); |
---|
| 788 | unsigned int fifo_full = _nic_get_global_register( NIC_G_NPKT_RX_DES_MFIFO_FULL ); |
---|
| 789 | unsigned int crc_fail = _nic_get_global_register( NIC_G_NPKT_RX_DES_CRC_FAIL ); |
---|
| 790 | unsigned int broadcast = _nic_get_global_register( NIC_G_NPKT_RX_DISPATCH_BROADCAST ); |
---|
| 791 | unsigned int dst_fail = _nic_get_global_register( NIC_G_NPKT_RX_DISPATCH_DST_FAIL ); |
---|
| 792 | unsigned int ch_full = _nic_get_global_register( NIC_G_NPKT_RX_DISPATCH_CH_FULL ); |
---|
| 793 | |
---|
| 794 | _printf("\n### Network Controller RX Statistics ###\n" |
---|
| 795 | "- packets received : %d\n" |
---|
| 796 | "- too small : %d\n" |
---|
| 797 | "- too big : %d\n" |
---|
| 798 | "- fifo full : %d\n" |
---|
| 799 | "- crc fail : %d\n" |
---|
| 800 | "- dst mac fail : %d\n" |
---|
| 801 | "- channel full : %d\n" |
---|
| 802 | "- broadcast : %d\n", |
---|
| 803 | received, |
---|
| 804 | too_small, |
---|
| 805 | too_big, |
---|
| 806 | fifo_full, |
---|
| 807 | crc_fail, |
---|
| 808 | dst_fail, |
---|
| 809 | ch_full, |
---|
| 810 | broadcast ); |
---|
| 811 | } |
---|
| 812 | else |
---|
| 813 | { |
---|
| 814 | unsigned int received = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_RECEIVED ); |
---|
| 815 | unsigned int too_big = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_TOO_BIG ); |
---|
| 816 | unsigned int too_small = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_TOO_SMALL ); |
---|
| 817 | unsigned int src_fail = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_SRC_FAIL ); |
---|
| 818 | unsigned int bypass = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_BYPASS ); |
---|
| 819 | unsigned int broadcast = _nic_get_global_register( NIC_G_NPKT_TX_DISPATCH_BROADCAST ); |
---|
| 820 | |
---|
| 821 | _printf("\n### Network Controller TX Statistics ###\n" |
---|
| 822 | "- packets received : %d\n" |
---|
| 823 | "- too small : %d\n" |
---|
| 824 | "- too big : %d\n" |
---|
| 825 | "- src mac fail : %d\n" |
---|
| 826 | "- bypass : %d\n" |
---|
| 827 | "- broadcast : %d\n", |
---|
| 828 | received, |
---|
| 829 | too_big, |
---|
| 830 | too_small, |
---|
| 831 | src_fail, |
---|
| 832 | bypass, |
---|
| 833 | broadcast ); |
---|
| 834 | } |
---|
| 835 | return 0; |
---|
| 836 | } |
---|
| 837 | |
---|
[440] | 838 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
| 839 | // FBF related syscall handlers |
---|
| 840 | ///////////////////////////////////////////////////////////////////////////////////////// |
---|
| 841 | |
---|
| 842 | ///////////////////////////////////////////// |
---|
| 843 | int _sys_fbf_sync_write( unsigned int offset, |
---|
| 844 | void* buffer, |
---|
| 845 | unsigned int length ) |
---|
| 846 | { |
---|
| 847 | char* fbf_address = (char *)SEG_FBF_BASE + offset; |
---|
| 848 | memcpy( fbf_address, buffer, length); |
---|
| 849 | |
---|
| 850 | return 0; |
---|
| 851 | } |
---|
| 852 | |
---|
| 853 | ///////////////////////////////////////////// |
---|
| 854 | int _sys_fbf_sync_read( unsigned int offset, |
---|
| 855 | void* buffer, |
---|
| 856 | unsigned int length ) |
---|
| 857 | { |
---|
| 858 | char* fbf_address = (char *)SEG_FBF_BASE + offset; |
---|
| 859 | memcpy( buffer, fbf_address, length); |
---|
| 860 | |
---|
| 861 | return 0; |
---|
| 862 | } |
---|
| 863 | |
---|
| 864 | //////////////////////// |
---|
| 865 | int _sys_fbf_cma_alloc() |
---|
| 866 | { |
---|
| 867 | // get a new CMA channel index |
---|
[459] | 868 | unsigned int channel = _atomic_increment( &_cma_channel_allocator, 1 ); |
---|
[440] | 869 | unsigned int thread = _get_context_slot( CTX_TRDID_ID ); |
---|
| 870 | unsigned int vspace = _get_context_slot( CTX_VSID_ID ); |
---|
| 871 | |
---|
| 872 | if ( channel >= NB_CMA_CHANNELS ) |
---|
| 873 | { |
---|
| 874 | _printf("\n[GIET ERROR] in _sys_fbf_cma_alloc() : not enough CMA channels\n"); |
---|
| 875 | return -1; |
---|
| 876 | } |
---|
| 877 | else |
---|
| 878 | { |
---|
| 879 | _printf("\n[GIET WARNING] FBF_CMA channel %d allocated " |
---|
| 880 | " to thread %d in vspace %d\n", channel, thread, vspace ); |
---|
[449] | 881 | _set_context_slot( CTX_CMA_FB_ID, channel ); |
---|
| 882 | return 0; |
---|
[440] | 883 | } |
---|
| 884 | } // end sys_fbf_cma_alloc() |
---|
| 885 | |
---|
| 886 | //////////////////////////////////////////// |
---|
| 887 | int _sys_fbf_cma_start( void* vbase0, |
---|
| 888 | void* vbase1, |
---|
| 889 | unsigned int length ) |
---|
| 890 | { |
---|
| 891 | #if NB_CMA_CHANNELS > 0 |
---|
| 892 | |
---|
| 893 | unsigned int ptab; // page table virtual address |
---|
| 894 | unsigned int vaddr; // virtual address |
---|
| 895 | unsigned int flags; // protection flags |
---|
| 896 | unsigned int ppn; // physical page number |
---|
| 897 | unsigned long long chbuf_paddr; // physical address of source chbuf descriptor |
---|
| 898 | |
---|
| 899 | // get channel index |
---|
[449] | 900 | unsigned int channel = _get_context_slot( CTX_CMA_FB_ID ); |
---|
[440] | 901 | |
---|
| 902 | if ( channel >= NB_CMA_CHANNELS ) |
---|
| 903 | { |
---|
| 904 | _printf("\n[GIET ERROR] in _fbf_cma_start() : CMA channel index too large\n"); |
---|
| 905 | return -1; |
---|
| 906 | } |
---|
| 907 | |
---|
| 908 | #if GIET_DEBUG_FBF_CMA |
---|
| 909 | _printf("\n[FBF_CMA DEBUG] enters _sys_fbf_cma_start()\n" |
---|
| 910 | " - channel = %d\n" |
---|
| 911 | " - buf0 vbase = %x\n" |
---|
| 912 | " - buf1 vbase = %x\n" |
---|
| 913 | " - buffer size = %x\n", |
---|
| 914 | channel, |
---|
| 915 | (unsigned int)vbase0, |
---|
| 916 | (unsigned int)vbase1, |
---|
| 917 | length ); |
---|
| 918 | #endif |
---|
| 919 | |
---|
| 920 | // checking user buffers virtual addresses and length alignment |
---|
| 921 | if ( ((unsigned int)vbase0 & 0x3) || ((unsigned int)vbase1 & 0x3) || (length & 0x3) ) |
---|
| 922 | { |
---|
| 923 | _printf("\n[GIET ERROR] in _fbf_cma_start() : user buffer not word aligned\n"); |
---|
| 924 | return -1; |
---|
| 925 | } |
---|
| 926 | |
---|
| 927 | // get page table virtual address |
---|
| 928 | ptab = _get_context_slot(CTX_PTAB_ID); |
---|
| 929 | |
---|
| 930 | // compute frame buffer physical address and initialize _fbf_chbuf[channel] |
---|
| 931 | vaddr = ((unsigned int)SEG_FBF_BASE); |
---|
[478] | 932 | _v2p_translate( (page_table_t*) ptab, |
---|
| 933 | (vaddr >> 12), |
---|
| 934 | &ppn, |
---|
| 935 | &flags ); |
---|
[440] | 936 | |
---|
[478] | 937 | _fbf_chbuf[channel].fbf.desc = ((paddr_t)ppn << 12) | (vaddr & 0x00000FFF); |
---|
[440] | 938 | |
---|
| 939 | // Compute user buffer 0 physical addresses and intialize _fbf_chbuf[channel] |
---|
| 940 | vaddr = (unsigned int)vbase0; |
---|
[478] | 941 | _v2p_translate( (page_table_t*) ptab, |
---|
| 942 | (vaddr >> 12), |
---|
| 943 | &ppn, |
---|
| 944 | &flags ); |
---|
[440] | 945 | if ((flags & PTE_U) == 0) |
---|
| 946 | { |
---|
| 947 | _printf("\n[GIET ERROR] in _fbf_cma_start() : user buffer 0 not in user space\n"); |
---|
| 948 | return -1; |
---|
| 949 | } |
---|
| 950 | |
---|
[478] | 951 | _fbf_chbuf[channel].buf0.desc = ((paddr_t)ppn << 12) | (vaddr & 0x00000FFF); |
---|
[440] | 952 | |
---|
| 953 | // Compute user buffer 1 physical addresses and intialize _fbf_chbuf[channel] |
---|
| 954 | vaddr = (unsigned int)vbase1; |
---|
[478] | 955 | _v2p_translate( (page_table_t*) ptab, |
---|
| 956 | (vaddr >> 12), |
---|
| 957 | &ppn, |
---|
| 958 | &flags ); |
---|
[440] | 959 | if ((flags & PTE_U) == 0) |
---|
| 960 | { |
---|
| 961 | _printf("\n[GIET ERROR] in _fbf_cma_start() : user buffer 1 not in user space\n"); |
---|
| 962 | return -1; |
---|
| 963 | } |
---|
| 964 | |
---|
[478] | 965 | _fbf_chbuf[channel].buf1.desc = ((paddr_t)ppn << 12) | (vaddr & 0x00000FFF); |
---|
[440] | 966 | |
---|
| 967 | // initializes buffer length |
---|
| 968 | _fbf_chbuf[channel].length = length; |
---|
| 969 | |
---|
| 970 | // Compute and register physical adress of the chbuf descriptor |
---|
| 971 | vaddr = (unsigned int)(&_fbf_chbuf[channel]); |
---|
[478] | 972 | _v2p_translate( (page_table_t*) ptab, |
---|
| 973 | (vaddr >> 12), |
---|
| 974 | &ppn, |
---|
| 975 | &flags ); |
---|
[440] | 976 | |
---|
| 977 | chbuf_paddr = (((paddr_t)ppn) << 12) | (vaddr & 0x00000FFF); |
---|
| 978 | |
---|
| 979 | _fbf_chbuf_paddr[channel] = chbuf_paddr; |
---|
| 980 | |
---|
| 981 | |
---|
| 982 | if ( USE_IOB ) |
---|
| 983 | { |
---|
| 984 | // SYNC request for channel descriptor |
---|
| 985 | _mmc_sync( chbuf_paddr, 32 ); |
---|
| 986 | } |
---|
| 987 | |
---|
| 988 | #if GIET_DEBUG_FBF_CMA |
---|
| 989 | _printf(" - fbf pbase = %l\n" |
---|
| 990 | " - buf0 pbase = %l\n" |
---|
| 991 | " - buf1 pbase = %l\n" |
---|
| 992 | " - chbuf pbase = %l\n", |
---|
[478] | 993 | _fbf_chbuf[channel].fbf.desc, |
---|
| 994 | _fbf_chbuf[channel].buf0.desc, |
---|
| 995 | _fbf_chbuf[channel].buf1.desc, |
---|
[440] | 996 | chbuf_paddr ); |
---|
| 997 | #endif |
---|
| 998 | |
---|
| 999 | // call CMA driver to start transfer |
---|
[449] | 1000 | _cma_channel_start( channel, |
---|
[440] | 1001 | chbuf_paddr, |
---|
| 1002 | 2, |
---|
[478] | 1003 | chbuf_paddr + 128, |
---|
[440] | 1004 | 1, |
---|
| 1005 | length ); |
---|
| 1006 | return 0; |
---|
| 1007 | |
---|
| 1008 | #else |
---|
| 1009 | |
---|
| 1010 | _printf("\n[GIET ERROR] in _sys_fbf_cma_start() : NB_CMA_CHANNELS = 0\n"); |
---|
| 1011 | return -1; |
---|
| 1012 | |
---|
| 1013 | #endif |
---|
| 1014 | } // end _sys_fbf_cma_start() |
---|
| 1015 | |
---|
| 1016 | ///////////////////////////////////////////////////// |
---|
| 1017 | int _sys_fbf_cma_display( unsigned int buffer_index ) |
---|
| 1018 | { |
---|
| 1019 | #if NB_CMA_CHANNELS > 0 |
---|
| 1020 | |
---|
[478] | 1021 | volatile unsigned int long long user_buffer_desc; |
---|
| 1022 | volatile unsigned int full = 1; |
---|
[440] | 1023 | |
---|
| 1024 | // get channel index |
---|
[449] | 1025 | unsigned int channel = _get_context_slot( CTX_CMA_FB_ID ); |
---|
[440] | 1026 | |
---|
| 1027 | if ( channel >= NB_CMA_CHANNELS ) |
---|
| 1028 | { |
---|
| 1029 | _printf("\n[GIET ERROR] in _sys_fbf_cma_display() : CMA channel index too large\n"); |
---|
| 1030 | return -1; |
---|
| 1031 | } |
---|
| 1032 | |
---|
| 1033 | #if GIET_DEBUG_FBF_CMA |
---|
| 1034 | _printf("\n[FBF_CMA DEBUG] enters _sys_fb_cma_display()\n" |
---|
| 1035 | " - channel = %d\n" |
---|
| 1036 | " - buffer = %d\n", |
---|
| 1037 | channel, buffer_index ); |
---|
| 1038 | #endif |
---|
| 1039 | |
---|
[478] | 1040 | if ( buffer_index == 0 ) // user buffer 0 |
---|
| 1041 | { |
---|
| 1042 | // waiting user buffer released by the CMA component) |
---|
| 1043 | while ( full ) |
---|
| 1044 | { |
---|
| 1045 | // INVAL L1 and L2 cache copies of user buffer descriptor, because |
---|
| 1046 | // it has been modified in RAM by the CMA component |
---|
| 1047 | _dcache_buf_invalidate( (unsigned int)&_fbf_chbuf[channel].buf0.desc , 8 ); |
---|
| 1048 | _mmc_inval( _fbf_chbuf_paddr[channel] , 8 ); |
---|
[440] | 1049 | |
---|
[478] | 1050 | // get user buffer descriptor |
---|
| 1051 | user_buffer_desc = _fbf_chbuf[channel].buf0.desc; |
---|
| 1052 | |
---|
| 1053 | // get user buffer descriptor status |
---|
| 1054 | full = ( (unsigned int)(user_buffer_desc>>63) ); |
---|
[440] | 1055 | } |
---|
| 1056 | |
---|
[478] | 1057 | // SYNC request for the user buffer, because |
---|
| 1058 | // it will be read from XRAM by the CMA component |
---|
| 1059 | _mmc_sync( user_buffer_desc, _fbf_chbuf[channel].length ); |
---|
[440] | 1060 | |
---|
[478] | 1061 | // set user buffer status, and SYNC request, because this buffer |
---|
| 1062 | // descriptor will be read from XRAM by the CMA component |
---|
| 1063 | _fbf_chbuf[channel].buf0.desc = user_buffer_desc | 0x8000000000000000ULL; |
---|
| 1064 | _mmc_sync( _fbf_chbuf_paddr[channel] , 8 ); |
---|
| 1065 | |
---|
| 1066 | // reset fbf buffer status, and SYNC request, because this buffer |
---|
| 1067 | // descriptor will be read from XRAM by the CMA component |
---|
| 1068 | _fbf_chbuf[channel].fbf.desc = _fbf_chbuf[channel].fbf.desc & 0x7FFFFFFFFFFFFFFFULL; |
---|
| 1069 | _mmc_sync( _fbf_chbuf_paddr[channel] + 128 , 8 ); |
---|
[440] | 1070 | } |
---|
[478] | 1071 | else // user buffer 1 |
---|
| 1072 | { |
---|
| 1073 | // waiting user buffer released by the CMA component) |
---|
| 1074 | while ( full ) |
---|
| 1075 | { |
---|
| 1076 | // INVAL L1 and L2 cache copies of user buffer descriptor, because |
---|
| 1077 | // it has been modified in RAM by the CMA component |
---|
| 1078 | _dcache_buf_invalidate( (unsigned int)&_fbf_chbuf[channel].buf1.desc , 8 ); |
---|
| 1079 | _mmc_inval( _fbf_chbuf_paddr[channel] + 64 , 8 ); |
---|
[440] | 1080 | |
---|
[478] | 1081 | // get user buffer descriptor |
---|
| 1082 | user_buffer_desc = _fbf_chbuf[channel].buf1.desc; |
---|
| 1083 | |
---|
| 1084 | // get user buffer descriptor status |
---|
| 1085 | full = ( (unsigned int)(user_buffer_desc>>63) ); |
---|
| 1086 | } |
---|
| 1087 | |
---|
[440] | 1088 | // SYNC request for the user buffer, because |
---|
| 1089 | // it will be read from XRAM by the CMA component |
---|
[478] | 1090 | _mmc_sync( user_buffer_desc, _fbf_chbuf[channel].length ); |
---|
[440] | 1091 | |
---|
[478] | 1092 | // set user buffer status, and SYNC request, because this buffer |
---|
| 1093 | // descriptor will be read from XRAM by the CMA component |
---|
| 1094 | _fbf_chbuf[channel].buf1.desc = user_buffer_desc | 0x8000000000000000ULL; |
---|
| 1095 | _mmc_sync( _fbf_chbuf_paddr[channel] , 8 ); |
---|
[440] | 1096 | |
---|
[478] | 1097 | // reset fbf buffer status, and SYNC request, because this buffer |
---|
| 1098 | // descriptor will be read from XRAM by the CMA component |
---|
| 1099 | _fbf_chbuf[channel].fbf.desc = _fbf_chbuf[channel].fbf.desc & 0x7FFFFFFFFFFFFFFFULL; |
---|
| 1100 | _mmc_sync( _fbf_chbuf_paddr[channel] + 128 , 8 ); |
---|
[440] | 1101 | } |
---|
| 1102 | |
---|
| 1103 | #if GIET_DEBUG_FBF_CMA |
---|
[478] | 1104 | _printf(" - fbf desc = %l\n" |
---|
| 1105 | " - buf0 desc = %l\n" |
---|
| 1106 | " - buf1 desc = %l\n", |
---|
| 1107 | _fbf_chbuf[channel].fbf.desc, |
---|
| 1108 | _fbf_chbuf[channel].buf0.desc, |
---|
| 1109 | _fbf_chbuf[channel].buf1.desc ); |
---|
[440] | 1110 | #endif |
---|
| 1111 | |
---|
| 1112 | return 0; |
---|
| 1113 | |
---|
| 1114 | #else |
---|
| 1115 | |
---|
| 1116 | _printf("\n[GIET ERROR] in _sys_fbf_cma_display() : no CMA channel allocated\n"); |
---|
| 1117 | return -1; |
---|
| 1118 | |
---|
| 1119 | #endif |
---|
| 1120 | } // end _sys_fbf_cma_display() |
---|
| 1121 | |
---|
[478] | 1122 | |
---|
[440] | 1123 | /////////////////////// |
---|
| 1124 | int _sys_fbf_cma_stop() |
---|
| 1125 | { |
---|
| 1126 | #if NB_CMA_CHANNELS > 0 |
---|
| 1127 | |
---|
| 1128 | // get channel index |
---|
[449] | 1129 | unsigned int channel = _get_context_slot( CTX_CMA_FB_ID ); |
---|
[440] | 1130 | |
---|
| 1131 | if ( channel >= NB_CMA_CHANNELS ) |
---|
| 1132 | { |
---|
| 1133 | _printf("\n[GIET ERROR] in _sys_fbf_cma_stop() : CMA channel index too large\n"); |
---|
| 1134 | return -1; |
---|
| 1135 | } |
---|
| 1136 | |
---|
| 1137 | // Desactivate CMA channel |
---|
[449] | 1138 | _cma_channel_stop( channel ); |
---|
[440] | 1139 | |
---|
| 1140 | return 0; |
---|
| 1141 | |
---|
| 1142 | #else |
---|
| 1143 | |
---|
| 1144 | _printf("\n[GIET ERROR] in _sys_fbf_cma_stop() : no CMA channel allocated\n"); |
---|
| 1145 | return -1; |
---|
| 1146 | |
---|
| 1147 | #endif |
---|
| 1148 | } // end _sys_fbf_cma_stop() |
---|
| 1149 | |
---|
| 1150 | |
---|
| 1151 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 1152 | // Miscelaneous syscall handlers |
---|
| 1153 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 1154 | |
---|
| 1155 | /////////////// |
---|
| 1156 | int _sys_ukn() |
---|
| 1157 | { |
---|
| 1158 | _printf("\n[GIET ERROR] Undefined System Call / EPC = %x\n", _get_epc() ); |
---|
| 1159 | return -1; |
---|
| 1160 | } |
---|
| 1161 | |
---|
| 1162 | //////////////////////////////////// |
---|
| 1163 | int _sys_proc_xyp( unsigned int* x, |
---|
| 1164 | unsigned int* y, |
---|
| 1165 | unsigned int* p ) |
---|
| 1166 | { |
---|
[428] | 1167 | unsigned int gpid = _get_procid(); // global processor index from CPO register |
---|
| 1168 | |
---|
| 1169 | *x = (gpid >> (Y_WIDTH + P_WIDTH)) & ((1<<X_WIDTH)-1); |
---|
| 1170 | *y = (gpid >> P_WIDTH) & ((1<<Y_WIDTH)-1); |
---|
| 1171 | *p = gpid & ((1<<P_WIDTH)-1); |
---|
[440] | 1172 | |
---|
| 1173 | return 0; |
---|
[428] | 1174 | } |
---|
[440] | 1175 | |
---|
| 1176 | ////////////////////////////////// |
---|
| 1177 | int _sys_task_exit( char* string ) |
---|
[258] | 1178 | { |
---|
[294] | 1179 | unsigned int date = _get_proctime(); |
---|
[428] | 1180 | |
---|
| 1181 | unsigned int gpid = _get_procid(); |
---|
| 1182 | unsigned int cluster_xy = gpid >> P_WIDTH; |
---|
[294] | 1183 | unsigned int y = cluster_xy & ((1<<Y_WIDTH)-1); |
---|
| 1184 | unsigned int x = cluster_xy >> Y_WIDTH; |
---|
[428] | 1185 | unsigned int lpid = gpid & ((1<<P_WIDTH)-1); |
---|
| 1186 | |
---|
[294] | 1187 | unsigned int task_id = _get_context_slot(CTX_LTID_ID); |
---|
[258] | 1188 | |
---|
[440] | 1189 | // print exit message |
---|
[294] | 1190 | _printf("\n[GIET] Exit task %d on processor[%d,%d,%d] at cycle %d" |
---|
| 1191 | "\n Cause : %s\n\n", |
---|
| 1192 | task_id, x, y, lpid, date, string ); |
---|
[258] | 1193 | |
---|
| 1194 | // goes to sleeping state |
---|
| 1195 | _set_context_slot(CTX_RUN_ID, 0); |
---|
| 1196 | |
---|
| 1197 | // deschedule |
---|
| 1198 | _context_switch(); |
---|
[440] | 1199 | |
---|
| 1200 | return 0; |
---|
[258] | 1201 | } |
---|
| 1202 | |
---|
[440] | 1203 | ////////////////////// |
---|
| 1204 | int _context_switch() |
---|
[258] | 1205 | { |
---|
[440] | 1206 | unsigned int save_sr; |
---|
[258] | 1207 | |
---|
[440] | 1208 | _it_disable( &save_sr ); |
---|
| 1209 | _ctx_switch(); |
---|
| 1210 | _it_restore( &save_sr ); |
---|
| 1211 | |
---|
| 1212 | return 0; |
---|
[258] | 1213 | } |
---|
| 1214 | |
---|
[440] | 1215 | //////////////////////// |
---|
| 1216 | int _sys_local_task_id() |
---|
[258] | 1217 | { |
---|
| 1218 | return _get_context_slot(CTX_LTID_ID); |
---|
| 1219 | } |
---|
| 1220 | |
---|
[440] | 1221 | ///////////////////////// |
---|
| 1222 | int _sys_global_task_id() |
---|
[258] | 1223 | { |
---|
| 1224 | return _get_context_slot(CTX_GTID_ID); |
---|
| 1225 | } |
---|
| 1226 | |
---|
[440] | 1227 | //////////////////// |
---|
| 1228 | int _sys_thread_id() |
---|
[267] | 1229 | { |
---|
| 1230 | return _get_context_slot(CTX_TRDID_ID); |
---|
| 1231 | } |
---|
| 1232 | |
---|
[440] | 1233 | ////////////////////////////////////// |
---|
| 1234 | int _sys_procs_number( unsigned int x, |
---|
| 1235 | unsigned int y, |
---|
| 1236 | unsigned int* number ) |
---|
[258] | 1237 | { |
---|
[440] | 1238 | mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE; |
---|
| 1239 | mapping_cluster_t * cluster = _get_cluster_base(header); |
---|
| 1240 | |
---|
| 1241 | if ( (x < X_SIZE) && (y < Y_SIZE) ) |
---|
| 1242 | { |
---|
| 1243 | *number = cluster[(x*Y_SIZE)+y].procs; |
---|
| 1244 | return 0; |
---|
| 1245 | } |
---|
| 1246 | else |
---|
| 1247 | { |
---|
| 1248 | _printf("\n[GIET ERROR] in _sys_procs_number() : illegal (x,y) coordinates\n" ); |
---|
| 1249 | return -1; |
---|
| 1250 | } |
---|
| 1251 | } |
---|
| 1252 | |
---|
| 1253 | /////////////////////////////////////////////////////// |
---|
| 1254 | int _sys_vobj_get_vbase( char* vspace_name, |
---|
| 1255 | char* vobj_name, |
---|
| 1256 | unsigned int* vbase ) |
---|
| 1257 | { |
---|
[322] | 1258 | mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE; |
---|
[258] | 1259 | mapping_vspace_t * vspace = _get_vspace_base(header); |
---|
| 1260 | mapping_vobj_t * vobj = _get_vobj_base(header); |
---|
| 1261 | |
---|
| 1262 | unsigned int vspace_id; |
---|
| 1263 | unsigned int vobj_id; |
---|
| 1264 | |
---|
| 1265 | // scan vspaces |
---|
| 1266 | for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) |
---|
| 1267 | { |
---|
| 1268 | if (_strncmp( vspace[vspace_id].name, vspace_name, 31) == 0) |
---|
| 1269 | { |
---|
| 1270 | // scan vobjs |
---|
| 1271 | for (vobj_id = vspace[vspace_id].vobj_offset; |
---|
| 1272 | vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs); |
---|
| 1273 | vobj_id++) |
---|
| 1274 | { |
---|
| 1275 | if (_strncmp(vobj[vobj_id].name, vobj_name, 31) == 0) |
---|
| 1276 | { |
---|
[440] | 1277 | *vbase = vobj[vobj_id].vbase; |
---|
[258] | 1278 | return 0; |
---|
| 1279 | } |
---|
| 1280 | } |
---|
| 1281 | } |
---|
| 1282 | } |
---|
[440] | 1283 | return -1; // not found |
---|
[258] | 1284 | } |
---|
| 1285 | |
---|
[440] | 1286 | ///////////////////////////////////////////////////////// |
---|
| 1287 | int _sys_vobj_get_length( char* vspace_name, |
---|
| 1288 | char* vobj_name, |
---|
| 1289 | unsigned int* length ) |
---|
[258] | 1290 | { |
---|
[440] | 1291 | mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE; |
---|
| 1292 | mapping_vspace_t * vspace = _get_vspace_base(header); |
---|
| 1293 | mapping_vobj_t * vobj = _get_vobj_base(header); |
---|
[258] | 1294 | |
---|
[440] | 1295 | unsigned int vspace_id; |
---|
| 1296 | unsigned int vobj_id; |
---|
| 1297 | |
---|
| 1298 | // scan vspaces |
---|
| 1299 | for (vspace_id = 0; vspace_id < header->vspaces; vspace_id++) |
---|
[258] | 1300 | { |
---|
[440] | 1301 | if (_strncmp( vspace[vspace_id].name, vspace_name, 31) == 0) |
---|
| 1302 | { |
---|
| 1303 | // scan vobjs |
---|
| 1304 | for (vobj_id = vspace[vspace_id].vobj_offset; |
---|
| 1305 | vobj_id < (vspace[vspace_id].vobj_offset + vspace[vspace_id].vobjs); |
---|
| 1306 | vobj_id++) |
---|
| 1307 | { |
---|
| 1308 | if (_strncmp(vobj[vobj_id].name, vobj_name, 31) == 0) |
---|
| 1309 | { |
---|
| 1310 | *length = vobj[vobj_id].length; |
---|
| 1311 | return 0; |
---|
| 1312 | } |
---|
| 1313 | } |
---|
| 1314 | } |
---|
| 1315 | } |
---|
| 1316 | return -1; // not found |
---|
[258] | 1317 | } |
---|
| 1318 | |
---|
[440] | 1319 | //////////////////////////////////////// |
---|
| 1320 | int _sys_xy_from_ptr( void* ptr, |
---|
| 1321 | unsigned int* x, |
---|
| 1322 | unsigned int* y ) |
---|
[396] | 1323 | { |
---|
| 1324 | unsigned int ppn; |
---|
| 1325 | unsigned int flags; |
---|
| 1326 | unsigned int vpn = (((unsigned int)ptr)>>12); |
---|
| 1327 | |
---|
| 1328 | // get the page table pointer |
---|
| 1329 | page_table_t* pt = (page_table_t*)_get_context_slot( CTX_PTAB_ID ); |
---|
| 1330 | |
---|
| 1331 | // compute the physical address |
---|
[478] | 1332 | _v2p_translate( pt, vpn, &ppn, &flags ); |
---|
[396] | 1333 | |
---|
[440] | 1334 | *x = (ppn>>24) & 0xF; |
---|
| 1335 | *y = (ppn>>20) & 0xF; |
---|
[396] | 1336 | return 0; |
---|
| 1337 | } |
---|
| 1338 | |
---|
[440] | 1339 | ///////////////////////////////////////// |
---|
| 1340 | int _sys_heap_info( unsigned int* vaddr, |
---|
| 1341 | unsigned int* length, |
---|
| 1342 | unsigned int x, |
---|
| 1343 | unsigned int y ) |
---|
[258] | 1344 | { |
---|
[440] | 1345 | mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE; |
---|
| 1346 | mapping_task_t * tasks = _get_task_base(header); |
---|
| 1347 | mapping_vobj_t * vobjs = _get_vobj_base(header); |
---|
| 1348 | mapping_vspace_t * vspaces = _get_vspace_base(header); |
---|
[294] | 1349 | |
---|
[440] | 1350 | unsigned int task_id; |
---|
| 1351 | unsigned int vspace_id; |
---|
| 1352 | unsigned int vobj_id = 0xFFFFFFFF; |
---|
[258] | 1353 | |
---|
[440] | 1354 | // searching the heap vobj_id |
---|
| 1355 | if ( (x < X_SIZE) && (y < Y_SIZE) ) // searching a task in cluster(x,y) |
---|
| 1356 | { |
---|
| 1357 | // get vspace global index |
---|
| 1358 | vspace_id = _get_context_slot(CTX_VSID_ID); |
---|
| 1359 | |
---|
| 1360 | // scan all tasks in vspace |
---|
| 1361 | unsigned int min = vspaces[vspace_id].task_offset ; |
---|
| 1362 | unsigned int max = min + vspaces[vspace_id].tasks ; |
---|
| 1363 | for ( task_id = min ; task_id < max ; task_id++ ) |
---|
| 1364 | { |
---|
| 1365 | if ( tasks[task_id].clusterid == (x * Y_SIZE + y) ) |
---|
| 1366 | { |
---|
| 1367 | vobj_id = tasks[task_id].heap_vobj_id; |
---|
| 1368 | if ( vobj_id != 0xFFFFFFFF ) break; |
---|
| 1369 | } |
---|
| 1370 | } |
---|
| 1371 | } |
---|
| 1372 | else // searching in the calling task |
---|
| 1373 | { |
---|
| 1374 | task_id = _get_context_slot(CTX_GTID_ID); |
---|
| 1375 | vobj_id = tasks[task_id].heap_vobj_id; |
---|
| 1376 | } |
---|
| 1377 | |
---|
| 1378 | // analysing the vobj_id |
---|
| 1379 | if ( vobj_id != 0xFFFFFFFF ) |
---|
| 1380 | { |
---|
| 1381 | *vaddr = vobjs[vobj_id].vbase; |
---|
| 1382 | *length = vobjs[vobj_id].length; |
---|
| 1383 | return 0; |
---|
| 1384 | } |
---|
| 1385 | else |
---|
| 1386 | { |
---|
| 1387 | *vaddr = 0; |
---|
| 1388 | *length = 0; |
---|
| 1389 | return -1; |
---|
| 1390 | } |
---|
| 1391 | } // end _sys_heap_info() |
---|
| 1392 | |
---|
| 1393 | |
---|
[258] | 1394 | // Local Variables: |
---|
| 1395 | // tab-width: 4 |
---|
| 1396 | // c-basic-offset: 4 |
---|
| 1397 | // c-file-offsets:((innamespace . 0)(inline-open . 0)) |
---|
| 1398 | // indent-tabs-mode: nil |
---|
| 1399 | // End: |
---|
| 1400 | // vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4 |
---|
| 1401 | |
---|