1/***********************license start*************** 2 * Copyright (c) 2003-2010 Cavium Inc. (support@cavium.com). All rights 3 * reserved. 4 * 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * * Redistributions in binary form must reproduce the above 14 * copyright notice, this list of conditions and the following 15 * disclaimer in the documentation and/or other materials provided 16 * with the distribution. 17 18 * * Neither the name of Cavium Inc. nor the names of 19 * its contributors may be used to endorse or promote products 20 * derived from this software without specific prior written 21 * permission. 22 23 * This Software, including technical data, may be subject to U.S. export control 24 * laws, including the U.S. Export Administration Act and its associated 25 * regulations, and may be subject to export or import regulations in other 26 * countries. 27 28 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" 29 * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR 30 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO 31 * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR 32 * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM 33 * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE, 34 * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF 35 * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR 36 * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR 37 * PERFORMANCE OF THE SOFTWARE LIES WITH YOU. 38 ***********************license end**************************************/ 39 40/** 41 * @file 42 * 43 * Provides APIs for applications to register for hotplug. It also provides 44 * APIs for requesting shutdown of a running target application. 45 * 46 * <hr>$Revision: $<hr> 47 */ 48 49#include "cvmx-app-hotplug.h" 50#include "cvmx-spinlock.h" 51#include "cvmx-debug.h" 52 53//#define DEBUG 1 54 55static cvmx_app_hotplug_global_t *hotplug_global_ptr = 0; 56 57#ifndef CVMX_BUILD_FOR_LINUX_USER 58 59static CVMX_SHARED cvmx_spinlock_t cvmx_app_hotplug_sync_lock = { CVMX_SPINLOCK_UNLOCKED_VAL }; 60static CVMX_SHARED cvmx_spinlock_t cvmx_app_hotplug_lock = { CVMX_SPINLOCK_UNLOCKED_VAL }; 61static CVMX_SHARED cvmx_app_hotplug_info_t *cvmx_app_hotplug_info_ptr = NULL; 62 63static void __cvmx_app_hotplug_shutdown(int irq_number, uint64_t registers[32], void *user_arg); 64static void __cvmx_app_hotplug_sync(void); 65static void __cvmx_app_hotplug_reset(void); 66 67/* Declaring this array here is a compile time check to ensure that the 68 size of cvmx_app_hotplug_info_t is 1024. If the size is not 1024 69 the size of the array will be -1 and this results in a compilation 70 error */ 71char __hotplug_info_check[(sizeof(cvmx_app_hotplug_info_t) == 1024) ? 1 : -1]; 72/** 73 * This routine registers an application for hotplug. It installs a handler for 74 * any incoming shutdown request. It also registers a callback routine from the 75 * application. This callback is invoked when the application receives a 76 * shutdown notification. 77 * 78 * This routine only needs to be called once per application. 79 * 80 * @param fn Callback routine from the application. 81 * @param arg Argument to the application callback routine. 82 * @return Return 0 on success, -1 on failure 83 * 84 */ 85int cvmx_app_hotplug_register(void(*fn)(void*), void* arg) 86{ 87 /* Find the list of applications launched by bootoct utility. */ 88 89 if (!(cvmx_app_hotplug_info_ptr = cvmx_app_hotplug_get_info(cvmx_sysinfo_get()->core_mask))) 90 { 91 /* Application not launched by bootoct? */ 92 printf("ERROR: cmvx_app_hotplug_register() failed\n"); 93 return -1; 94 } 95 96 /* Register the callback */ 97 cvmx_app_hotplug_info_ptr->data = CAST64(arg); 98 cvmx_app_hotplug_info_ptr->shutdown_callback = CAST64(fn); 99 100#ifdef DEBUG 101 printf("cvmx_app_hotplug_register(): coremask 0x%x valid %d\n", 102 cvmx_app_hotplug_info_ptr->coremask, cvmx_app_hotplug_info_ptr->valid); 103#endif 104 105 cvmx_interrupt_register(CVMX_IRQ_MBOX0, __cvmx_app_hotplug_shutdown, NULL); 106 107 return 0; 108} 109 110/** 111 * This routine deprecates the the cvmx_app_hotplug_register method. This 112 * registers application for hotplug and the application will have CPU 113 * hotplug callbacks. Various callbacks are specified in cb. 114 * cvmx_app_hotplug_callbacks_t documents the callbacks 115 * 116 * This routine only needs to be called once per application. 117 * 118 * @param cb Callback routine from the application. 119 * @param arg Argument to the application callback routins 120 * @param app_shutdown When set to 1 the application will invoke core_shutdown 121 on each core. When set to 0 core shutdown will be 122 called invoked automatically after invoking the 123 application callback. 124 * @return Return index of app on success, -1 on failure 125 * 126 */ 127int cvmx_app_hotplug_register_cb(cvmx_app_hotplug_callbacks_t *cb, void* arg, 128 int app_shutdown) 129{ 130 cvmx_app_hotplug_info_t *app_info; 131 132 /* Find the list of applications launched by bootoct utility. */ 133 app_info = cvmx_app_hotplug_get_info(cvmx_sysinfo_get()->core_mask); 134 cvmx_app_hotplug_info_ptr = app_info; 135 if (!app_info) 136 { 137 /* Application not launched by bootoct? */ 138 printf("ERROR: cmvx_app_hotplug_register() failed\n"); 139 return -1; 140 } 141 /* Register the callback */ 142 app_info->data = CAST64(arg); 143 app_info->shutdown_callback = CAST64(cb->shutdown_callback); 144 app_info->cores_added_callback = CAST64(cb->cores_added_callback); 145 app_info->cores_removed_callback = CAST64(cb->cores_removed_callback); 146 app_info->unplug_callback = CAST64(cb->unplug_core_callback); 147 app_info->hotplug_start = CAST64(cb->hotplug_start); 148 app_info->app_shutdown = app_shutdown; 149#ifdef DEBUG 150 printf("cvmx_app_hotplug_register(): coremask 0x%x valid %d\n", 151 app_info->coremask, app_info->valid); 152#endif 153 154 cvmx_interrupt_register(CVMX_IRQ_MBOX0, __cvmx_app_hotplug_shutdown, NULL); 155 return 0; 156 157} 158 159void cvmx_app_hotplug_remove_self_from_core_mask(void) 160{ 161 int core = cvmx_get_core_num(); 162 uint32_t core_mask = 1ull << core; 163 164 cvmx_spinlock_lock(&cvmx_app_hotplug_lock); 165 cvmx_app_hotplug_info_ptr->coremask = cvmx_app_hotplug_info_ptr->coremask & ~core_mask ; 166 cvmx_app_hotplug_info_ptr->hotplug_activated_coremask = 167 cvmx_app_hotplug_info_ptr->hotplug_activated_coremask & ~core_mask ; 168 cvmx_spinlock_unlock(&cvmx_app_hotplug_lock); 169} 170 171 172 173/** 174* Returns 1 if the running core is being unplugged, else it returns 0. 175*/ 176int is_core_being_unplugged(void) 177{ 178 if (cvmx_app_hotplug_info_ptr->unplug_cores & 179 (1ull << cvmx_get_core_num())) 180 return 1; 181 return 0; 182} 183 184 185/** 186 * Activate the current application core for receiving hotplug shutdown requests. 187 * 188 * This routine makes sure that each core belonging to the application is enabled 189 * to receive the shutdown notification and also provides a barrier sync to make 190 * sure that all cores are ready. 191 */ 192int cvmx_app_hotplug_activate(void) 193{ 194 uint64_t cnt = 0; 195 uint64_t cnt_interval = 10000000; 196 197 while (!cvmx_app_hotplug_info_ptr) 198 { 199 cnt++; 200 if ((cnt % cnt_interval) == 0) 201 printf("waiting for cnt=%lld\n", (unsigned long long)cnt); 202 } 203 204 if (cvmx_app_hotplug_info_ptr->hplugged_cores & (1ull << cvmx_get_core_num())) 205 { 206#ifdef DEBUG 207 printf("core=%d : is being hotplugged \n", cvmx_get_core_num()); 208#endif 209 cvmx_sysinfo_t *sys_info_ptr = cvmx_sysinfo_get(); 210 sys_info_ptr->core_mask |= 1ull << cvmx_get_core_num(); 211 } 212 else 213 { 214 __cvmx_app_hotplug_sync(); 215 } 216 cvmx_spinlock_lock(&cvmx_app_hotplug_lock); 217 if (!cvmx_app_hotplug_info_ptr) 218 { 219 cvmx_spinlock_unlock(&cvmx_app_hotplug_lock); 220 printf("ERROR: This application is not registered for hotplug\n"); 221 return -1; 222 } 223 /* Enable the interrupt before we mark the core as activated */ 224 cvmx_interrupt_unmask_irq(CVMX_IRQ_MBOX0); 225 cvmx_app_hotplug_info_ptr->hotplug_activated_coremask |= (1ull<<cvmx_get_core_num()); 226 227#ifdef DEBUG 228 printf("cvmx_app_hotplug_activate(): coremask 0x%x valid %d sizeof %d\n", 229 cvmx_app_hotplug_info_ptr->coremask, cvmx_app_hotplug_info_ptr->valid, 230 sizeof(*cvmx_app_hotplug_info_ptr)); 231#endif 232 233 cvmx_spinlock_unlock(&cvmx_app_hotplug_lock); 234 235 return 0; 236} 237 238/** 239 * This routine is only required if cvmx_app_hotplug_shutdown_request() was called 240 * with wait=0. This routine waits for the application shutdown to complete. 241 * 242 * @param coremask Coremask the application is running on. 243 * @return 0 on success, -1 on error 244 * 245 */ 246int cvmx_app_hotplug_shutdown_complete(uint32_t coremask) 247{ 248 cvmx_app_hotplug_info_t *hotplug_info_ptr; 249 250 if (!(hotplug_info_ptr = cvmx_app_hotplug_get_info(coremask))) 251 { 252 printf("\nERROR: Failed to get hotplug info for coremask: 0x%x\n", (unsigned int)coremask); 253 return -1; 254 } 255 256 while(!hotplug_info_ptr->shutdown_done); 257 258 /* Clean up the hotplug info region for this app */ 259 bzero(hotplug_info_ptr, sizeof(*hotplug_info_ptr)); 260 261 return 0; 262} 263 264/** 265 * Disable recognition of any incoming shutdown request. 266 */ 267 268void cvmx_app_hotplug_shutdown_disable(void) 269{ 270 cvmx_interrupt_mask_irq(CVMX_IRQ_MBOX0); 271} 272 273/** 274 * Re-enable recognition of incoming shutdown requests. 275 */ 276 277void cvmx_app_hotplug_shutdown_enable(void) 278{ 279 cvmx_interrupt_unmask_irq(CVMX_IRQ_MBOX0); 280} 281 282/** 283* Request shutdown of the currently running core. Should be 284* called by the application when it has been registered with 285* app_shutdown option set to 1. 286*/ 287void cvmx_app_hotplug_core_shutdown(void) 288{ 289 uint32_t flags; 290 if (cvmx_app_hotplug_info_ptr->shutdown_cores) 291 { 292 cvmx_sysinfo_t *sys_info_ptr = cvmx_sysinfo_get(); 293 __cvmx_app_hotplug_sync(); 294 if (cvmx_coremask_first_core(sys_info_ptr->core_mask)) 295 { 296 bzero(cvmx_app_hotplug_info_ptr, 297 sizeof(*cvmx_app_hotplug_info_ptr)); 298 #ifdef DEBUG 299 printf("__cvmx_app_hotplug_shutdown(): setting shutdown done! \n"); 300 #endif 301 cvmx_app_hotplug_info_ptr->shutdown_done = 1; 302 } 303 /* Tell the debugger that this application is finishing. */ 304 cvmx_debug_finish (); 305 flags = cvmx_interrupt_disable_save(); 306 __cvmx_app_hotplug_sync(); 307 /* Reset the core */ 308 __cvmx_app_hotplug_reset(); 309 } 310 else 311 { 312 cvmx_sysinfo_remove_self_from_core_mask(); 313 cvmx_app_hotplug_remove_self_from_core_mask(); 314 flags = cvmx_interrupt_disable_save(); 315 __cvmx_app_hotplug_reset(); 316 } 317} 318 319/* 320 * ISR for the incoming shutdown request interrupt. 321 */ 322static void __cvmx_app_hotplug_shutdown(int irq_number, uint64_t registers[32], 323 void *user_arg) 324{ 325 cvmx_sysinfo_t *sys_info_ptr = cvmx_sysinfo_get(); 326 uint64_t mbox; 327 cvmx_app_hotplug_info_t *ai = cvmx_app_hotplug_info_ptr; 328 int dbg = 0; 329 330#ifdef DEBUG 331 dbg = 1; 332#endif 333 cvmx_interrupt_mask_irq(CVMX_IRQ_MBOX0); 334 335 mbox = cvmx_read_csr(CVMX_CIU_MBOX_CLRX(cvmx_get_core_num())); 336 /* Clear the interrupt */ 337 cvmx_write_csr(CVMX_CIU_MBOX_CLRX(cvmx_get_core_num()), mbox); 338 339 /* Make sure the write above completes */ 340 cvmx_read_csr(CVMX_CIU_MBOX_CLRX(cvmx_get_core_num())); 341 342 343 if (!cvmx_app_hotplug_info_ptr) 344 { 345 printf("ERROR: Application is not registered for hotplug!\n"); 346 return; 347 } 348 349 if (ai->hotplug_activated_coremask != sys_info_ptr->core_mask) 350 { 351 printf("ERROR: Shutdown requested when not all app cores have " 352 "activated hotplug\n" "Application coremask: 0x%x Hotplug " 353 "coremask: 0x%x\n", (unsigned int)sys_info_ptr->core_mask, 354 (unsigned int)ai->hotplug_activated_coremask); 355 return; 356 } 357 358 if (mbox & 1ull) 359 { 360 int core = cvmx_get_core_num(); 361 if (dbg) 362 printf("Shutting down application .\n"); 363 /* Call the application's own callback function */ 364 if (ai->shutdown_callback) 365 { 366 ((void(*)(void*))(long)ai->shutdown_callback)(CASTPTR(void *, ai->data)); 367 } 368 else 369 { 370 printf("ERROR : Shutdown callback has not been registered\n"); 371 } 372 if (!ai->app_shutdown) 373 { 374 if (dbg) 375 printf("%s : core = %d Invoking app shutdown\n", __FUNCTION__, core); 376 cvmx_app_hotplug_core_shutdown(); 377 } 378 } 379 else if (mbox & 2ull) 380 { 381 int core = cvmx_get_core_num(); 382 int unplug = is_core_being_unplugged(); 383 if (dbg) printf("%s : core=%d Unplug event \n", __FUNCTION__, core); 384 385 if (unplug) 386 { 387 /* Call the application's own callback function */ 388 if (ai->unplug_callback) 389 { 390 if (dbg) printf("%s : core=%d Calling unplug callback\n", 391 __FUNCTION__, core); 392 ((void(*)(void*))(long)ai->unplug_callback)(CASTPTR(void *, 393 ai->data)); 394 } 395 if (!ai->app_shutdown) 396 { 397 if (dbg) printf("%s : core = %d Invoking app shutdown\n", 398 __FUNCTION__, core); 399 cvmx_app_hotplug_core_shutdown(); 400 } 401 } 402 else 403 { 404 if (ai->cores_removed_callback) 405 { 406 if (dbg) printf("%s : core=%d Calling cores removed callback\n", 407 __FUNCTION__, core); 408 ((void(*)(uint32_t, void*))(long)ai->cores_removed_callback) 409 (ai->unplug_cores, CASTPTR(void *, ai->data)); 410 } 411 cvmx_interrupt_unmask_irq(CVMX_IRQ_MBOX0); 412 } 413 } 414 else if (mbox & 4ull) 415 { 416 int core = cvmx_get_core_num(); 417 if (dbg) printf("%s : core=%d Add cores event \n", __FUNCTION__, core); 418 419 if (ai->cores_added_callback) 420 { 421 if (dbg) printf("%s : core=%d Calling cores added callback\n", 422 __FUNCTION__, core); 423 ((void(*)(uint32_t, void*))(long)ai->cores_added_callback) 424 (ai->hplugged_cores, CASTPTR(void *, ai->data)); 425 } 426 cvmx_interrupt_unmask_irq(CVMX_IRQ_MBOX0); 427 } 428 else 429 { 430 printf("ERROR: unexpected mbox=%llx\n", (unsigned long long)mbox); 431 } 432 433} 434 435void __cvmx_app_hotplug_reset(void) 436{ 437#define IDLE_CORE_BLOCK_NAME "idle-core-loop" 438#define HPLUG_MAKE_XKPHYS(x) ((1ULL << 63) | (x)) 439 uint64_t reset_addr; 440 const cvmx_bootmem_named_block_desc_t *block_desc; 441 442 block_desc = cvmx_bootmem_find_named_block(IDLE_CORE_BLOCK_NAME); 443 if (!block_desc) { 444 cvmx_dprintf("Named block(%s) is not created\n", IDLE_CORE_BLOCK_NAME); 445 /* loop here, should not happen */ 446 __asm__ volatile ( 447 ".set noreorder \n" 448 "\tsync \n" 449 "\tnop \n" 450 "1:\twait \n" 451 "\tb 1b \n" 452 "\tnop \n" 453 ".set reorder \n" 454 :: 455 ); 456 } 457 458 reset_addr = HPLUG_MAKE_XKPHYS(block_desc->base_addr); 459 asm volatile (" .set push \n" 460 " .set mips64 \n" 461 " .set noreorder \n" 462 " move $2, %[addr] \n" 463 " jr $2 \n" 464 " nop \n" 465 " .set pop " 466 :: [addr] "r"(reset_addr) 467 : "$2"); 468 469 /*Should never reach here*/ 470 while (1) ; 471 472} 473 474/* 475 * We need a separate sync operation from cvmx_coremask_barrier_sync() to 476 * avoid a deadlock on state.lock, since the application itself maybe doing a 477 * cvmx_coremask_barrier_sync(). 478 */ 479static void __cvmx_app_hotplug_sync(void) 480{ 481 static CVMX_SHARED volatile uint32_t sync_coremask = 0; 482 cvmx_sysinfo_t *sys_info_ptr = cvmx_sysinfo_get(); 483 484 cvmx_spinlock_lock(&cvmx_app_hotplug_sync_lock); 485 486 sync_coremask |= cvmx_coremask_core(cvmx_get_core_num()); 487 488 cvmx_spinlock_unlock(&cvmx_app_hotplug_sync_lock); 489 490 while (sync_coremask != sys_info_ptr->core_mask); 491 492 cvmx_spinlock_lock(&cvmx_app_hotplug_sync_lock); 493 sync_coremask = 0; 494 cvmx_spinlock_unlock(&cvmx_app_hotplug_sync_lock); 495 496 497} 498 499#endif /* CVMX_BUILD_FOR_LINUX_USER */ 500 501/** 502* Returns 1 if the running core is being hotplugged, else it returns 0. 503*/ 504int is_core_being_hot_plugged(void) 505{ 506 507#ifndef CVMX_BUILD_FOR_LINUX_USER 508 if (!cvmx_app_hotplug_info_ptr) return 0; 509 if (cvmx_app_hotplug_info_ptr->hplugged_cores & 510 (1ull << cvmx_get_core_num())) 511 return 1; 512 return 0; 513#else 514 return 0; 515#endif 516} 517 518static cvmx_app_hotplug_global_t *cvmx_app_get_hotplug_global_ptr(void) 519{ 520 const struct cvmx_bootmem_named_block_desc *block_desc; 521 cvmx_app_hotplug_global_t *hgp; 522 523 if(hotplug_global_ptr != 0) return hotplug_global_ptr; 524 525 block_desc = cvmx_bootmem_find_named_block(CVMX_APP_HOTPLUG_INFO_REGION_NAME); 526 if (!block_desc) 527 { 528 printf("ERROR: Hotplug info region is not setup\n"); 529 return NULL; 530 } 531 else 532#ifdef CVMX_BUILD_FOR_LINUX_USER 533 { 534 size_t pg_sz = sysconf(_SC_PAGESIZE), size; 535 off_t offset; 536 char *vaddr; 537 int fd; 538 539 if ((fd = open("/dev/mem", O_RDWR)) == -1) { 540 perror("open"); 541 return NULL; 542 } 543 544 /* 545 * We need to mmap() this memory, since this was allocated from the 546 * kernel bootup code and does not reside in the RESERVE32 region. 547 */ 548 size = CVMX_APP_HOTPLUG_INFO_REGION_SIZE + pg_sz-1; 549 offset = block_desc->base_addr & ~(pg_sz-1); 550 if ((vaddr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset)) 551 == MAP_FAILED) 552 { 553 perror("mmap"); 554 return NULL; 555 } 556 557 hgp = (cvmx_app_hotplug_global_t *)(vaddr + ( block_desc->base_addr & (pg_sz-1))); 558 } 559#else 560 hgp = CASTPTR(void, CVMX_ADD_SEG(CVMX_MIPS_SPACE_XKPHYS, block_desc->base_addr)); 561#endif 562 hotplug_global_ptr = hgp; 563 return hgp; 564 565} 566 567/** 568 * Return the hotplug info structure (cvmx_app_hotplug_info_t) pointer for the 569 * application running on the given coremask. 570 * 571 * @param coremask Coremask of application. 572 * @return Returns hotplug info struct on success, NULL on failure 573 * 574 */ 575cvmx_app_hotplug_info_t* cvmx_app_hotplug_get_info(uint32_t coremask) 576{ 577 cvmx_app_hotplug_info_t *hip; 578 cvmx_app_hotplug_global_t *hgp; 579 int i; 580 int dbg = 0; 581 582#ifdef DEBUG 583 dbg = 1; 584#endif 585 hgp = cvmx_app_get_hotplug_global_ptr(); 586 if (!hgp) return NULL; 587 hip = hgp->hotplug_info_array; 588 589 /* Look for the current app's info */ 590 for (i=0; i<CVMX_APP_HOTPLUG_MAX_APPS; i++) 591 { 592 if (hip[i].coremask == coremask) 593 { 594 if (dbg) 595 printf("cvmx_app_hotplug_get_info(): coremask match %d -- coremask 0x%x, valid %d\n", i, (unsigned int)hip[i].coremask, (unsigned int)hip[i].valid); 596 return &hip[i]; 597 } 598 } 599 return NULL; 600} 601 602/** 603 * Return the hotplug application index structure for the application running on the 604 * given coremask. 605 * 606 * @param coremask Coremask of application. 607 * @return Returns hotplug application index on success. -1 on failure 608 * 609 */ 610int cvmx_app_hotplug_get_index(uint32_t coremask) 611{ 612 cvmx_app_hotplug_info_t *hip; 613 cvmx_app_hotplug_global_t *hgp; 614 int i; 615 int dbg = 0; 616 617#ifdef DEBUG 618 dbg = 1; 619#endif 620 hgp = cvmx_app_get_hotplug_global_ptr(); 621 if (!hgp) return -1; 622 hip = hgp->hotplug_info_array; 623 624 /* Look for the current app's info */ 625 for (i=0; i<CVMX_APP_HOTPLUG_MAX_APPS; i++) 626 { 627 if (hip[i].coremask == coremask) 628 { 629 if (dbg) 630 printf("cvmx_app_hotplug_get_info(): coremask match %d -- coremask 0x%x valid %d\n", i, (unsigned int)hip[i].coremask, (unsigned int)hip[i].valid); 631 return i; 632 } 633 } 634 return -1; 635} 636 637void print_hot_plug_info(cvmx_app_hotplug_info_t* hpinfo) 638{ 639 printf("name=%s coremask=%08x hotplugged coremask=%08x valid=%d\n", hpinfo->app_name, 640 (unsigned int)hpinfo->coremask, (unsigned int)hpinfo->hotplug_activated_coremask, (unsigned int)hpinfo->valid); 641} 642 643/** 644 * Return the hotplug info structure (cvmx_app_hotplug_info_t) pointer for the 645 * application with the specified index. 646 * 647 * @param index index of application. 648 * @return Returns hotplug info struct on success, NULL on failure 649 * 650 */ 651cvmx_app_hotplug_info_t* cvmx_app_hotplug_get_info_at_index(int index) 652{ 653 cvmx_app_hotplug_info_t *hip; 654 cvmx_app_hotplug_global_t *hgp; 655 656 hgp = cvmx_app_get_hotplug_global_ptr(); 657 if (!hgp) return NULL; 658 hip = hgp->hotplug_info_array; 659 660#ifdef DEBUG 661 printf("cvmx_app_hotplug_get_info(): hotplug_info phy addr 0x%llx ptr %p\n", 662 block_desc->base_addr, hgp); 663#endif 664 if (index < CVMX_APP_HOTPLUG_MAX_APPS) 665 { 666 if (hip[index].valid) 667 { 668 //print_hot_plug_info( &hip[index] ); 669 return &hip[index]; 670 } 671 } 672 return NULL; 673} 674 675/** 676 * Determines if SE application at the index specified is hotpluggable. 677 * 678 * @param index index of application. 679 * @return Returns -1 on error. 680 * 0 -> The application is not hotpluggable 681 * 1 -> The application is hotpluggable 682*/ 683int is_app_hotpluggable(int index) 684{ 685 cvmx_app_hotplug_info_t *ai; 686 687 if (!(ai = cvmx_app_hotplug_get_info_at_index(index))) 688 { 689 printf("\nERROR: Failed to get hotplug info for app at index=%d\n", index); 690 return -1; 691 } 692 if (ai->hotplug_activated_coremask) return 1; 693 return 0; 694} 695 696/** 697 * This routine sends a shutdown request to a running target application. 698 * 699 * @param coremask Coremask the application is running on. 700 * @param wait 1 - Wait for shutdown completion 701 * 0 - Do not wait 702 * @return 0 on success, -1 on error 703 * 704 */ 705 706int cvmx_app_hotplug_shutdown_request(uint32_t coremask, int wait) 707{ 708 int i; 709 cvmx_app_hotplug_info_t *hotplug_info_ptr; 710 711 if (!(hotplug_info_ptr = cvmx_app_hotplug_get_info(coremask))) 712 { 713 printf("\nERROR: Failed to get hotplug info for coremask: 0x%x\n", (unsigned int)coremask); 714 return -1; 715 } 716 hotplug_info_ptr->shutdown_cores = coremask; 717 if (!hotplug_info_ptr->shutdown_callback) 718 { 719 printf("\nERROR: Target application has not registered for hotplug!\n"); 720 return -1; 721 } 722 723 if (hotplug_info_ptr->hotplug_activated_coremask != coremask) 724 { 725 printf("\nERROR: Not all application cores have activated hotplug\n"); 726 return -1; 727 } 728 729 /* Send IPIs to all application cores to request shutdown */ 730 for (i=0; i<CVMX_MAX_CORES; i++) { 731 if (coremask & (1ull<<i)) 732 cvmx_write_csr(CVMX_CIU_MBOX_SETX(i), 1); 733 } 734 735 if (wait) 736 { 737 while (!hotplug_info_ptr->shutdown_done); 738 739 /* Clean up the hotplug info region for this application */ 740 bzero(hotplug_info_ptr, sizeof(*hotplug_info_ptr)); 741 } 742 743 return 0; 744} 745 746 747 748/** 749 * This routine invokes the invoked the cores_added callbacks. 750 */ 751int cvmx_app_hotplug_call_add_cores_callback(int index) 752{ 753 cvmx_app_hotplug_info_t *ai; 754 int i; 755 if (!(ai = cvmx_app_hotplug_get_info_at_index(index))) 756 { 757 printf("\nERROR: Failed to get hotplug info for app at index=%d\n", index); 758 return -1; 759 } 760 /* Send IPIs to all application cores to request add_cores callback*/ 761 for (i=0; i<CVMX_MAX_CORES; i++) { 762 if (ai->coremask & (1ull<<i)) 763 cvmx_write_csr(CVMX_CIU_MBOX_SETX(i), 4); 764 } 765 return 0; 766} 767 768/** 769 * This routine sends a request to a running target application 770 * to unplug a specified set cores 771 * @param index is the index of the target application 772 * @param coremask Coremask of the cores to be unplugged from the app. 773 * @param wait 1 - Wait for shutdown completion 774 * 0 - Do not wait 775 * @return 0 on success, -1 on error 776 * 777 */ 778int cvmx_app_hotplug_unplug_cores(int index, uint32_t coremask, int wait) 779{ 780 cvmx_app_hotplug_info_t *ai; 781 int i; 782 783 if (!(ai = cvmx_app_hotplug_get_info_at_index(index))) 784 { 785 printf("\nERROR: Failed to get hotplug info for app at index=%d\n", index); 786 return -1; 787 } 788 ai->unplug_cores = coremask; 789#if 0 790 if (!ai->shutdown_callback) 791 { 792 printf("\nERROR: Target application has not registered for hotplug!\n"); 793 return -1; 794 } 795#endif 796 if ( (ai->coremask | coremask ) != ai->coremask) 797 { 798 printf("\nERROR: Not all cores requested are a part of the app " 799 "r=%08x:%08x\n", (unsigned int)coremask, (unsigned int)ai->coremask); 800 return -1; 801 } 802 if (ai->coremask == coremask) 803 { 804 printf("\nERROR: Trying to remove all cores in app. " 805 "r=%08x:%08x\n", (unsigned int)coremask, (unsigned int)ai->coremask); 806 return -1; 807 } 808 /* Send IPIs to all application cores to request unplug/remove_cores 809 callback */ 810 for (i=0; i<CVMX_MAX_CORES; i++) { 811 if (ai->coremask & (1ull<<i)) 812 cvmx_write_csr(CVMX_CIU_MBOX_SETX(i), 2); 813 } 814 815#if 0 816 if (wait) 817 { 818 while (!ai->shutdown_done); 819 820 /* Clean up the hotplug info region for this application */ 821 bzero(ai, sizeof(*ai)); 822 } 823#endif 824 return 0; 825} 826 827/** 828 * Returns 1 if any app is currently being currently booted , hotplugged or 829 * shutdown. Only one app can be under a boot, hotplug or shutdown condition. 830 * Before booting an app this methods should be used to check whether boot or 831 * shutdown activity is in progress and proceed with the boot or shutdown only 832 * when there is no other activity. 833 * 834 */ 835int is_app_under_boot_or_shutdown(void) 836{ 837 int ret=0; 838 cvmx_app_hotplug_global_t *hgp; 839 840 hgp = cvmx_app_get_hotplug_global_ptr(); 841 cvmx_spinlock_lock(&hgp->hotplug_global_lock); 842 if (hgp->app_under_boot || hgp->app_under_shutdown) ret=1; 843 cvmx_spinlock_unlock(&hgp->hotplug_global_lock); 844 return ret; 845 846} 847 848/** 849 * Sets or clear the app_under_boot value. This when set signifies that an app 850 * is being currently booted or hotplugged with a new core. 851 * 852 * 853 * @param val sets the app_under_boot to the specified value. This should be 854 * set to 1 while app any is being booted and cleared after the 855 * application has booted up. 856 * 857 */ 858void set_app_unber_boot(int val) 859{ 860 cvmx_app_hotplug_global_t *hgp; 861 862 hgp = cvmx_app_get_hotplug_global_ptr(); 863 cvmx_spinlock_lock(&hgp->hotplug_global_lock); 864 hgp->app_under_boot = val; 865 cvmx_spinlock_unlock(&hgp->hotplug_global_lock); 866} 867 868/** 869 * Sets or clear the app_under_shutdown value. This when set signifies that an 870 * app is being currently shutdown or some cores of an app are being shutdown. 871 * 872 * @param val sets the app_under_shutdown to the specified value. This 873 * should be set to 1 while any app is being shutdown and cleared 874 * after the shutdown of the app is complete. 875 * 876 */ 877void set_app_under_shutdown(int val) 878{ 879 cvmx_app_hotplug_global_t *hgp; 880 881 hgp = cvmx_app_get_hotplug_global_ptr(); 882 cvmx_spinlock_lock(&hgp->hotplug_global_lock); 883 hgp->app_under_shutdown = val; 884 cvmx_spinlock_unlock(&hgp->hotplug_global_lock); 885} 886