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