1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright 2015 IBM Corp. 4 */ 5 6 7 #include <linux/compiler.h> 8 #include <linux/types.h> 9 #include <linux/delay.h> 10 #include <asm/byteorder.h> 11 #include "hcalls.h" 12 #include "trace.h" 13 14 #define CXL_HCALL_TIMEOUT 60000 15 #define CXL_HCALL_TIMEOUT_DOWNLOAD 120000 16 17 #define H_ATTACH_CA_PROCESS 0x344 18 #define H_CONTROL_CA_FUNCTION 0x348 19 #define H_DETACH_CA_PROCESS 0x34C 20 #define H_COLLECT_CA_INT_INFO 0x350 21 #define H_CONTROL_CA_FAULTS 0x354 22 #define H_DOWNLOAD_CA_FUNCTION 0x35C 23 #define H_DOWNLOAD_CA_FACILITY 0x364 24 #define H_CONTROL_CA_FACILITY 0x368 25 26 #define H_CONTROL_CA_FUNCTION_RESET 1 /* perform a reset */ 27 #define H_CONTROL_CA_FUNCTION_SUSPEND_PROCESS 2 /* suspend a process from being executed */ 28 #define H_CONTROL_CA_FUNCTION_RESUME_PROCESS 3 /* resume a process to be executed */ 29 #define H_CONTROL_CA_FUNCTION_READ_ERR_STATE 4 /* read the error state */ 30 #define H_CONTROL_CA_FUNCTION_GET_AFU_ERR 5 /* collect the AFU error buffer */ 31 #define H_CONTROL_CA_FUNCTION_GET_CONFIG 6 /* collect configuration record */ 32 #define H_CONTROL_CA_FUNCTION_GET_DOWNLOAD_STATE 7 /* query to return download status */ 33 #define H_CONTROL_CA_FUNCTION_TERMINATE_PROCESS 8 /* terminate the process before completion */ 34 #define H_CONTROL_CA_FUNCTION_COLLECT_VPD 9 /* collect VPD */ 35 #define H_CONTROL_CA_FUNCTION_GET_FUNCTION_ERR_INT 11 /* read the function-wide error data based on an interrupt */ 36 #define H_CONTROL_CA_FUNCTION_ACK_FUNCTION_ERR_INT 12 /* acknowledge function-wide error data based on an interrupt */ 37 #define H_CONTROL_CA_FUNCTION_GET_ERROR_LOG 13 /* retrieve the Platform Log ID (PLID) of an error log */ 38 39 #define H_CONTROL_CA_FAULTS_RESPOND_PSL 1 40 #define H_CONTROL_CA_FAULTS_RESPOND_AFU 2 41 42 #define H_CONTROL_CA_FACILITY_RESET 1 /* perform a reset */ 43 #define H_CONTROL_CA_FACILITY_COLLECT_VPD 2 /* collect VPD */ 44 45 #define H_DOWNLOAD_CA_FACILITY_DOWNLOAD 1 /* download adapter image */ 46 #define H_DOWNLOAD_CA_FACILITY_VALIDATE 2 /* validate adapter image */ 47 48 49 #define _CXL_LOOP_HCALL(call, rc, retbuf, fn, ...) \ 50 { \ 51 unsigned int delay, total_delay = 0; \ 52 u64 token = 0; \ 53 \ 54 memset(retbuf, 0, sizeof(retbuf)); \ 55 while (1) { \ 56 rc = call(fn, retbuf, __VA_ARGS__, token); \ 57 token = retbuf[0]; \ 58 if (rc != H_BUSY && !H_IS_LONG_BUSY(rc)) \ 59 break; \ 60 \ 61 if (rc == H_BUSY) \ 62 delay = 10; \ 63 else \ 64 delay = get_longbusy_msecs(rc); \ 65 \ 66 total_delay += delay; \ 67 if (total_delay > CXL_HCALL_TIMEOUT) { \ 68 WARN(1, "Warning: Giving up waiting for CXL hcall " \ 69 "%#x after %u msec\n", fn, total_delay); \ 70 rc = H_BUSY; \ 71 break; \ 72 } \ 73 msleep(delay); \ 74 } \ 75 } 76 #define CXL_H_WAIT_UNTIL_DONE(...) _CXL_LOOP_HCALL(plpar_hcall, __VA_ARGS__) 77 #define CXL_H9_WAIT_UNTIL_DONE(...) _CXL_LOOP_HCALL(plpar_hcall9, __VA_ARGS__) 78 79 #define _PRINT_MSG(rc, format, ...) \ 80 { \ 81 if ((rc != H_SUCCESS) && (rc != H_CONTINUE)) \ 82 pr_err(format, __VA_ARGS__); \ 83 else \ 84 pr_devel(format, __VA_ARGS__); \ 85 } \ 86 87 88 static char *afu_op_names[] = { 89 "UNKNOWN_OP", /* 0 undefined */ 90 "RESET", /* 1 */ 91 "SUSPEND_PROCESS", /* 2 */ 92 "RESUME_PROCESS", /* 3 */ 93 "READ_ERR_STATE", /* 4 */ 94 "GET_AFU_ERR", /* 5 */ 95 "GET_CONFIG", /* 6 */ 96 "GET_DOWNLOAD_STATE", /* 7 */ 97 "TERMINATE_PROCESS", /* 8 */ 98 "COLLECT_VPD", /* 9 */ 99 "UNKNOWN_OP", /* 10 undefined */ 100 "GET_FUNCTION_ERR_INT", /* 11 */ 101 "ACK_FUNCTION_ERR_INT", /* 12 */ 102 "GET_ERROR_LOG", /* 13 */ 103 }; 104 105 static char *control_adapter_op_names[] = { 106 "UNKNOWN_OP", /* 0 undefined */ 107 "RESET", /* 1 */ 108 "COLLECT_VPD", /* 2 */ 109 }; 110 111 static char *download_op_names[] = { 112 "UNKNOWN_OP", /* 0 undefined */ 113 "DOWNLOAD", /* 1 */ 114 "VALIDATE", /* 2 */ 115 }; 116 117 static char *op_str(unsigned int op, char *name_array[], int array_len) 118 { 119 if (op >= array_len) 120 return "UNKNOWN_OP"; 121 return name_array[op]; 122 } 123 124 #define OP_STR(op, name_array) op_str(op, name_array, ARRAY_SIZE(name_array)) 125 126 #define OP_STR_AFU(op) OP_STR(op, afu_op_names) 127 #define OP_STR_CONTROL_ADAPTER(op) OP_STR(op, control_adapter_op_names) 128 #define OP_STR_DOWNLOAD_ADAPTER(op) OP_STR(op, download_op_names) 129 130 131 long cxl_h_attach_process(u64 unit_address, 132 struct cxl_process_element_hcall *element, 133 u64 *process_token, u64 *mmio_addr, u64 *mmio_size) 134 { 135 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 136 long rc; 137 138 CXL_H_WAIT_UNTIL_DONE(rc, retbuf, H_ATTACH_CA_PROCESS, unit_address, virt_to_phys(element)); 139 _PRINT_MSG(rc, "cxl_h_attach_process(%#.16llx, %#.16lx): %li\n", 140 unit_address, virt_to_phys(element), rc); 141 trace_cxl_hcall_attach(unit_address, virt_to_phys(element), retbuf[0], retbuf[1], retbuf[2], rc); 142 143 pr_devel("token: 0x%.8lx mmio_addr: 0x%lx mmio_size: 0x%lx\nProcess Element Structure:\n", 144 retbuf[0], retbuf[1], retbuf[2]); 145 cxl_dump_debug_buffer(element, sizeof(*element)); 146 147 switch (rc) { 148 case H_SUCCESS: /* The process info is attached to the coherent platform function */ 149 *process_token = retbuf[0]; 150 if (mmio_addr) 151 *mmio_addr = retbuf[1]; 152 if (mmio_size) 153 *mmio_size = retbuf[2]; 154 return 0; 155 case H_PARAMETER: /* An incorrect parameter was supplied. */ 156 case H_FUNCTION: /* The function is not supported. */ 157 return -EINVAL; 158 case H_AUTHORITY: /* The partition does not have authority to perform this hcall */ 159 case H_RESOURCE: /* The coherent platform function does not have enough additional resource to attach the process */ 160 case H_HARDWARE: /* A hardware event prevented the attach operation */ 161 case H_STATE: /* The coherent platform function is not in a valid state */ 162 case H_BUSY: 163 return -EBUSY; 164 default: 165 WARN(1, "Unexpected return code: %lx", rc); 166 return -EINVAL; 167 } 168 } 169 170 /** 171 * cxl_h_detach_process - Detach a process element from a coherent 172 * platform function. 173 */ 174 long cxl_h_detach_process(u64 unit_address, u64 process_token) 175 { 176 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 177 long rc; 178 179 CXL_H_WAIT_UNTIL_DONE(rc, retbuf, H_DETACH_CA_PROCESS, unit_address, process_token); 180 _PRINT_MSG(rc, "cxl_h_detach_process(%#.16llx, 0x%.8llx): %li\n", unit_address, process_token, rc); 181 trace_cxl_hcall_detach(unit_address, process_token, rc); 182 183 switch (rc) { 184 case H_SUCCESS: /* The process was detached from the coherent platform function */ 185 return 0; 186 case H_PARAMETER: /* An incorrect parameter was supplied. */ 187 return -EINVAL; 188 case H_AUTHORITY: /* The partition does not have authority to perform this hcall */ 189 case H_RESOURCE: /* The function has page table mappings for MMIO */ 190 case H_HARDWARE: /* A hardware event prevented the detach operation */ 191 case H_STATE: /* The coherent platform function is not in a valid state */ 192 case H_BUSY: 193 return -EBUSY; 194 default: 195 WARN(1, "Unexpected return code: %lx", rc); 196 return -EINVAL; 197 } 198 } 199 200 /** 201 * cxl_h_control_function - This H_CONTROL_CA_FUNCTION hypervisor call allows 202 * the partition to manipulate or query 203 * certain coherent platform function behaviors. 204 */ 205 static long cxl_h_control_function(u64 unit_address, u64 op, 206 u64 p1, u64 p2, u64 p3, u64 p4, u64 *out) 207 { 208 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; 209 long rc; 210 211 CXL_H9_WAIT_UNTIL_DONE(rc, retbuf, H_CONTROL_CA_FUNCTION, unit_address, op, p1, p2, p3, p4); 212 _PRINT_MSG(rc, "cxl_h_control_function(%#.16llx, %s(%#llx, %#llx, %#llx, %#llx, R4: %#lx)): %li\n", 213 unit_address, OP_STR_AFU(op), p1, p2, p3, p4, retbuf[0], rc); 214 trace_cxl_hcall_control_function(unit_address, OP_STR_AFU(op), p1, p2, p3, p4, retbuf[0], rc); 215 216 switch (rc) { 217 case H_SUCCESS: /* The operation is completed for the coherent platform function */ 218 if ((op == H_CONTROL_CA_FUNCTION_GET_FUNCTION_ERR_INT || 219 op == H_CONTROL_CA_FUNCTION_READ_ERR_STATE || 220 op == H_CONTROL_CA_FUNCTION_COLLECT_VPD)) 221 *out = retbuf[0]; 222 return 0; 223 case H_PARAMETER: /* An incorrect parameter was supplied. */ 224 case H_FUNCTION: /* The function is not supported. */ 225 case H_NOT_FOUND: /* The operation supplied was not valid */ 226 case H_NOT_AVAILABLE: /* The operation cannot be performed because the AFU has not been downloaded */ 227 case H_SG_LIST: /* An block list entry was invalid */ 228 return -EINVAL; 229 case H_AUTHORITY: /* The partition does not have authority to perform this hcall */ 230 case H_RESOURCE: /* The function has page table mappings for MMIO */ 231 case H_HARDWARE: /* A hardware event prevented the attach operation */ 232 case H_STATE: /* The coherent platform function is not in a valid state */ 233 case H_BUSY: 234 return -EBUSY; 235 default: 236 WARN(1, "Unexpected return code: %lx", rc); 237 return -EINVAL; 238 } 239 } 240 241 /** 242 * cxl_h_reset_afu - Perform a reset to the coherent platform function. 243 */ 244 long cxl_h_reset_afu(u64 unit_address) 245 { 246 return cxl_h_control_function(unit_address, 247 H_CONTROL_CA_FUNCTION_RESET, 248 0, 0, 0, 0, 249 NULL); 250 } 251 252 /** 253 * cxl_h_suspend_process - Suspend a process from being executed 254 * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when 255 * process was attached. 256 */ 257 long cxl_h_suspend_process(u64 unit_address, u64 process_token) 258 { 259 return cxl_h_control_function(unit_address, 260 H_CONTROL_CA_FUNCTION_SUSPEND_PROCESS, 261 process_token, 0, 0, 0, 262 NULL); 263 } 264 265 /** 266 * cxl_h_resume_process - Resume a process to be executed 267 * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when 268 * process was attached. 269 */ 270 long cxl_h_resume_process(u64 unit_address, u64 process_token) 271 { 272 return cxl_h_control_function(unit_address, 273 H_CONTROL_CA_FUNCTION_RESUME_PROCESS, 274 process_token, 0, 0, 0, 275 NULL); 276 } 277 278 /** 279 * cxl_h_read_error_state - Checks the error state of the coherent 280 * platform function. 281 * R4 contains the error state 282 */ 283 long cxl_h_read_error_state(u64 unit_address, u64 *state) 284 { 285 return cxl_h_control_function(unit_address, 286 H_CONTROL_CA_FUNCTION_READ_ERR_STATE, 287 0, 0, 0, 0, 288 state); 289 } 290 291 /** 292 * cxl_h_get_afu_err - collect the AFU error buffer 293 * Parameter1 = byte offset into error buffer to retrieve, valid values 294 * are between 0 and (ibm,error-buffer-size - 1) 295 * Parameter2 = 4K aligned real address of error buffer, to be filled in 296 * Parameter3 = length of error buffer, valid values are 4K or less 297 */ 298 long cxl_h_get_afu_err(u64 unit_address, u64 offset, 299 u64 buf_address, u64 len) 300 { 301 return cxl_h_control_function(unit_address, 302 H_CONTROL_CA_FUNCTION_GET_AFU_ERR, 303 offset, buf_address, len, 0, 304 NULL); 305 } 306 307 /** 308 * cxl_h_get_config - collect configuration record for the 309 * coherent platform function 310 * Parameter1 = # of configuration record to retrieve, valid values are 311 * between 0 and (ibm,#config-records - 1) 312 * Parameter2 = byte offset into configuration record to retrieve, 313 * valid values are between 0 and (ibm,config-record-size - 1) 314 * Parameter3 = 4K aligned real address of configuration record buffer, 315 * to be filled in 316 * Parameter4 = length of configuration buffer, valid values are 4K or less 317 */ 318 long cxl_h_get_config(u64 unit_address, u64 cr_num, u64 offset, 319 u64 buf_address, u64 len) 320 { 321 return cxl_h_control_function(unit_address, 322 H_CONTROL_CA_FUNCTION_GET_CONFIG, 323 cr_num, offset, buf_address, len, 324 NULL); 325 } 326 327 /** 328 * cxl_h_terminate_process - Terminate the process before completion 329 * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when 330 * process was attached. 331 */ 332 long cxl_h_terminate_process(u64 unit_address, u64 process_token) 333 { 334 return cxl_h_control_function(unit_address, 335 H_CONTROL_CA_FUNCTION_TERMINATE_PROCESS, 336 process_token, 0, 0, 0, 337 NULL); 338 } 339 340 /** 341 * cxl_h_collect_vpd - Collect VPD for the coherent platform function. 342 * Parameter1 = # of VPD record to retrieve, valid values are between 0 343 * and (ibm,#config-records - 1). 344 * Parameter2 = 4K naturally aligned real buffer containing block 345 * list entries 346 * Parameter3 = number of block list entries in the block list, valid 347 * values are between 0 and 256 348 */ 349 long cxl_h_collect_vpd(u64 unit_address, u64 record, u64 list_address, 350 u64 num, u64 *out) 351 { 352 return cxl_h_control_function(unit_address, 353 H_CONTROL_CA_FUNCTION_COLLECT_VPD, 354 record, list_address, num, 0, 355 out); 356 } 357 358 /** 359 * cxl_h_get_fn_error_interrupt - Read the function-wide error data based on an interrupt 360 */ 361 long cxl_h_get_fn_error_interrupt(u64 unit_address, u64 *reg) 362 { 363 return cxl_h_control_function(unit_address, 364 H_CONTROL_CA_FUNCTION_GET_FUNCTION_ERR_INT, 365 0, 0, 0, 0, reg); 366 } 367 368 /** 369 * cxl_h_ack_fn_error_interrupt - Acknowledge function-wide error data 370 * based on an interrupt 371 * Parameter1 = value to write to the function-wide error interrupt register 372 */ 373 long cxl_h_ack_fn_error_interrupt(u64 unit_address, u64 value) 374 { 375 return cxl_h_control_function(unit_address, 376 H_CONTROL_CA_FUNCTION_ACK_FUNCTION_ERR_INT, 377 value, 0, 0, 0, 378 NULL); 379 } 380 381 /** 382 * cxl_h_get_error_log - Retrieve the Platform Log ID (PLID) of 383 * an error log 384 */ 385 long cxl_h_get_error_log(u64 unit_address, u64 value) 386 { 387 return cxl_h_control_function(unit_address, 388 H_CONTROL_CA_FUNCTION_GET_ERROR_LOG, 389 0, 0, 0, 0, 390 NULL); 391 } 392 393 /** 394 * cxl_h_collect_int_info - Collect interrupt info about a coherent 395 * platform function after an interrupt occurred. 396 */ 397 long cxl_h_collect_int_info(u64 unit_address, u64 process_token, 398 struct cxl_irq_info *info) 399 { 400 long rc; 401 402 BUG_ON(sizeof(*info) != sizeof(unsigned long[PLPAR_HCALL9_BUFSIZE])); 403 404 rc = plpar_hcall9(H_COLLECT_CA_INT_INFO, (unsigned long *) info, 405 unit_address, process_token); 406 _PRINT_MSG(rc, "cxl_h_collect_int_info(%#.16llx, 0x%llx): %li\n", 407 unit_address, process_token, rc); 408 trace_cxl_hcall_collect_int_info(unit_address, process_token, rc); 409 410 switch (rc) { 411 case H_SUCCESS: /* The interrupt info is returned in return registers. */ 412 pr_devel("dsisr:%#llx, dar:%#llx, dsr:%#llx, pid_tid:%#llx, afu_err:%#llx, errstat:%#llx\n", 413 info->dsisr, info->dar, info->dsr, info->reserved, 414 info->afu_err, info->errstat); 415 return 0; 416 case H_PARAMETER: /* An incorrect parameter was supplied. */ 417 return -EINVAL; 418 case H_AUTHORITY: /* The partition does not have authority to perform this hcall. */ 419 case H_HARDWARE: /* A hardware event prevented the collection of the interrupt info.*/ 420 case H_STATE: /* The coherent platform function is not in a valid state to collect interrupt info. */ 421 return -EBUSY; 422 default: 423 WARN(1, "Unexpected return code: %lx", rc); 424 return -EINVAL; 425 } 426 } 427 428 /** 429 * cxl_h_control_faults - Control the operation of a coherent platform 430 * function after a fault occurs. 431 * 432 * Parameters 433 * control-mask: value to control the faults 434 * looks like PSL_TFC_An shifted >> 32 435 * reset-mask: mask to control reset of function faults 436 * Set reset_mask = 1 to reset PSL errors 437 */ 438 long cxl_h_control_faults(u64 unit_address, u64 process_token, 439 u64 control_mask, u64 reset_mask) 440 { 441 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 442 long rc; 443 444 memset(retbuf, 0, sizeof(retbuf)); 445 446 rc = plpar_hcall(H_CONTROL_CA_FAULTS, retbuf, unit_address, 447 H_CONTROL_CA_FAULTS_RESPOND_PSL, process_token, 448 control_mask, reset_mask); 449 _PRINT_MSG(rc, "cxl_h_control_faults(%#.16llx, 0x%llx, %#llx, %#llx): %li (%#lx)\n", 450 unit_address, process_token, control_mask, reset_mask, 451 rc, retbuf[0]); 452 trace_cxl_hcall_control_faults(unit_address, process_token, 453 control_mask, reset_mask, retbuf[0], rc); 454 455 switch (rc) { 456 case H_SUCCESS: /* Faults were successfully controlled for the function. */ 457 return 0; 458 case H_PARAMETER: /* An incorrect parameter was supplied. */ 459 return -EINVAL; 460 case H_HARDWARE: /* A hardware event prevented the control of faults. */ 461 case H_STATE: /* The function was in an invalid state. */ 462 case H_AUTHORITY: /* The partition does not have authority to perform this hcall; the coherent platform facilities may need to be licensed. */ 463 return -EBUSY; 464 case H_FUNCTION: /* The function is not supported */ 465 case H_NOT_FOUND: /* The operation supplied was not valid */ 466 return -EINVAL; 467 default: 468 WARN(1, "Unexpected return code: %lx", rc); 469 return -EINVAL; 470 } 471 } 472 473 /** 474 * cxl_h_control_facility - This H_CONTROL_CA_FACILITY hypervisor call 475 * allows the partition to manipulate or query 476 * certain coherent platform facility behaviors. 477 */ 478 static long cxl_h_control_facility(u64 unit_address, u64 op, 479 u64 p1, u64 p2, u64 p3, u64 p4, u64 *out) 480 { 481 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; 482 long rc; 483 484 CXL_H9_WAIT_UNTIL_DONE(rc, retbuf, H_CONTROL_CA_FACILITY, unit_address, op, p1, p2, p3, p4); 485 _PRINT_MSG(rc, "cxl_h_control_facility(%#.16llx, %s(%#llx, %#llx, %#llx, %#llx, R4: %#lx)): %li\n", 486 unit_address, OP_STR_CONTROL_ADAPTER(op), p1, p2, p3, p4, retbuf[0], rc); 487 trace_cxl_hcall_control_facility(unit_address, OP_STR_CONTROL_ADAPTER(op), p1, p2, p3, p4, retbuf[0], rc); 488 489 switch (rc) { 490 case H_SUCCESS: /* The operation is completed for the coherent platform facility */ 491 if (op == H_CONTROL_CA_FACILITY_COLLECT_VPD) 492 *out = retbuf[0]; 493 return 0; 494 case H_PARAMETER: /* An incorrect parameter was supplied. */ 495 case H_FUNCTION: /* The function is not supported. */ 496 case H_NOT_FOUND: /* The operation supplied was not valid */ 497 case H_NOT_AVAILABLE: /* The operation cannot be performed because the AFU has not been downloaded */ 498 case H_SG_LIST: /* An block list entry was invalid */ 499 return -EINVAL; 500 case H_AUTHORITY: /* The partition does not have authority to perform this hcall */ 501 case H_RESOURCE: /* The function has page table mappings for MMIO */ 502 case H_HARDWARE: /* A hardware event prevented the attach operation */ 503 case H_STATE: /* The coherent platform facility is not in a valid state */ 504 case H_BUSY: 505 return -EBUSY; 506 default: 507 WARN(1, "Unexpected return code: %lx", rc); 508 return -EINVAL; 509 } 510 } 511 512 /** 513 * cxl_h_reset_adapter - Perform a reset to the coherent platform facility. 514 */ 515 long cxl_h_reset_adapter(u64 unit_address) 516 { 517 return cxl_h_control_facility(unit_address, 518 H_CONTROL_CA_FACILITY_RESET, 519 0, 0, 0, 0, 520 NULL); 521 } 522 523 /** 524 * cxl_h_collect_vpd - Collect VPD for the coherent platform function. 525 * Parameter1 = 4K naturally aligned real buffer containing block 526 * list entries 527 * Parameter2 = number of block list entries in the block list, valid 528 * values are between 0 and 256 529 */ 530 long cxl_h_collect_vpd_adapter(u64 unit_address, u64 list_address, 531 u64 num, u64 *out) 532 { 533 return cxl_h_control_facility(unit_address, 534 H_CONTROL_CA_FACILITY_COLLECT_VPD, 535 list_address, num, 0, 0, 536 out); 537 } 538 539 /** 540 * cxl_h_download_facility - This H_DOWNLOAD_CA_FACILITY 541 * hypervisor call provide platform support for 542 * downloading a base adapter image to the coherent 543 * platform facility, and for validating the entire 544 * image after the download. 545 * Parameters 546 * op: operation to perform to the coherent platform function 547 * Download: operation = 1, the base image in the coherent platform 548 * facility is first erased, and then 549 * programmed using the image supplied 550 * in the scatter/gather list. 551 * Validate: operation = 2, the base image in the coherent platform 552 * facility is compared with the image 553 * supplied in the scatter/gather list. 554 * list_address: 4K naturally aligned real buffer containing 555 * scatter/gather list entries. 556 * num: number of block list entries in the scatter/gather list. 557 */ 558 static long cxl_h_download_facility(u64 unit_address, u64 op, 559 u64 list_address, u64 num, 560 u64 *out) 561 { 562 unsigned long retbuf[PLPAR_HCALL_BUFSIZE]; 563 unsigned int delay, total_delay = 0; 564 u64 token = 0; 565 long rc; 566 567 if (*out != 0) 568 token = *out; 569 570 memset(retbuf, 0, sizeof(retbuf)); 571 while (1) { 572 rc = plpar_hcall(H_DOWNLOAD_CA_FACILITY, retbuf, 573 unit_address, op, list_address, num, 574 token); 575 token = retbuf[0]; 576 if (rc != H_BUSY && !H_IS_LONG_BUSY(rc)) 577 break; 578 579 if (rc != H_BUSY) { 580 delay = get_longbusy_msecs(rc); 581 total_delay += delay; 582 if (total_delay > CXL_HCALL_TIMEOUT_DOWNLOAD) { 583 WARN(1, "Warning: Giving up waiting for CXL hcall " 584 "%#x after %u msec\n", 585 H_DOWNLOAD_CA_FACILITY, total_delay); 586 rc = H_BUSY; 587 break; 588 } 589 msleep(delay); 590 } 591 } 592 _PRINT_MSG(rc, "cxl_h_download_facility(%#.16llx, %s(%#llx, %#llx), %#lx): %li\n", 593 unit_address, OP_STR_DOWNLOAD_ADAPTER(op), list_address, num, retbuf[0], rc); 594 trace_cxl_hcall_download_facility(unit_address, OP_STR_DOWNLOAD_ADAPTER(op), list_address, num, retbuf[0], rc); 595 596 switch (rc) { 597 case H_SUCCESS: /* The operation is completed for the coherent platform facility */ 598 return 0; 599 case H_PARAMETER: /* An incorrect parameter was supplied */ 600 case H_FUNCTION: /* The function is not supported. */ 601 case H_SG_LIST: /* An block list entry was invalid */ 602 case H_BAD_DATA: /* Image verification failed */ 603 return -EINVAL; 604 case H_AUTHORITY: /* The partition does not have authority to perform this hcall */ 605 case H_RESOURCE: /* The function has page table mappings for MMIO */ 606 case H_HARDWARE: /* A hardware event prevented the attach operation */ 607 case H_STATE: /* The coherent platform facility is not in a valid state */ 608 case H_BUSY: 609 return -EBUSY; 610 case H_CONTINUE: 611 *out = retbuf[0]; 612 return 1; /* More data is needed for the complete image */ 613 default: 614 WARN(1, "Unexpected return code: %lx", rc); 615 return -EINVAL; 616 } 617 } 618 619 /** 620 * cxl_h_download_adapter_image - Download the base image to the coherent 621 * platform facility. 622 */ 623 long cxl_h_download_adapter_image(u64 unit_address, 624 u64 list_address, u64 num, 625 u64 *out) 626 { 627 return cxl_h_download_facility(unit_address, 628 H_DOWNLOAD_CA_FACILITY_DOWNLOAD, 629 list_address, num, out); 630 } 631 632 /** 633 * cxl_h_validate_adapter_image - Validate the base image in the coherent 634 * platform facility. 635 */ 636 long cxl_h_validate_adapter_image(u64 unit_address, 637 u64 list_address, u64 num, 638 u64 *out) 639 { 640 return cxl_h_download_facility(unit_address, 641 H_DOWNLOAD_CA_FACILITY_VALIDATE, 642 list_address, num, out); 643 } 644