drivers/misc/cxl/hcalls.c

   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 }