drivers/misc/cxl/hcalls.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Copyright 2015 IBM Corp.
   4  */
   5
   6 #ifndef _HCALLS_H
   7 #define _HCALLS_H
   8
   9 #include <linux/types.h>
  10 #include <asm/byteorder.h>
  11 #include <asm/hvcall.h>
  12 #include "cxl.h"
  13
  14 #define SG_BUFFER_SIZE 4096
  15 #define SG_MAX_ENTRIES 256
  16
  17 struct sg_list {
  18         u64 phys_addr;
  19         u64 len;
  20 };
  21
  22 /*
  23  * This is straight out of PAPR, but replacing some of the compound fields with
  24  * a single field, where they were identical to the register layout.
  25  *
  26  * The 'flags' parameter regroups the various bit-fields
  27  */
  28 #define CXL_PE_CSRP_VALID                       (1ULL << 63)
  29 #define CXL_PE_PROBLEM_STATE                    (1ULL << 62)
  30 #define CXL_PE_SECONDARY_SEGMENT_TBL_SRCH       (1ULL << 61)
  31 #define CXL_PE_TAGS_ACTIVE                      (1ULL << 60)
  32 #define CXL_PE_USER_STATE                       (1ULL << 59)
  33 #define CXL_PE_TRANSLATION_ENABLED              (1ULL << 58)
  34 #define CXL_PE_64_BIT                           (1ULL << 57)
  35 #define CXL_PE_PRIVILEGED_PROCESS               (1ULL << 56)
  36
  37 #define CXL_PROCESS_ELEMENT_VERSION 1
  38 struct cxl_process_element_hcall {
  39         __be64 version;
  40         __be64 flags;
  41         u8     reserved0[12];
  42         __be32 pslVirtualIsn;
  43         u8     applicationVirtualIsnBitmap[256];
  44         u8     reserved1[144];
  45         struct cxl_process_element_common common;
  46         u8     reserved4[12];
  47 } __packed;
  48
  49 #define H_STATE_NORMAL              1
  50 #define H_STATE_DISABLE             2
  51 #define H_STATE_TEMP_UNAVAILABLE    3
  52 #define H_STATE_PERM_UNAVAILABLE    4
  53
  54 /* NOTE: element must be a logical real address, and must be pinned */
  55 long cxl_h_attach_process(u64 unit_address, struct cxl_process_element_hcall *element,
  56                         u64 *process_token, u64 *mmio_addr, u64 *mmio_size);
  57
  58 /**
  59  * cxl_h_detach_process - Detach a process element from a coherent
  60  *                        platform function.
  61  */
  62 long cxl_h_detach_process(u64 unit_address, u64 process_token);
  63
  64 /**
  65  * cxl_h_reset_afu - Perform a reset to the coherent platform function.
  66  */
  67 long cxl_h_reset_afu(u64 unit_address);
  68
  69 /**
  70  * cxl_h_suspend_process - Suspend a process from being executed
  71  * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when
  72  *              process was attached.
  73  */
  74 long cxl_h_suspend_process(u64 unit_address, u64 process_token);
  75
  76 /**
  77  * cxl_h_resume_process - Resume a process to be executed
  78  * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when
  79  *              process was attached.
  80  */
  81 long cxl_h_resume_process(u64 unit_address, u64 process_token);
  82
  83 /**
  84  * cxl_h_read_error_state - Reads the error state of the coherent
  85  *                          platform function.
  86  * R4 contains the error state
  87  */
  88 long cxl_h_read_error_state(u64 unit_address, u64 *state);
  89
  90 /**
  91  * cxl_h_get_afu_err - collect the AFU error buffer
  92  * Parameter1 = byte offset into error buffer to retrieve, valid values
  93  *              are between 0 and (ibm,error-buffer-size - 1)
  94  * Parameter2 = 4K aligned real address of error buffer, to be filled in
  95  * Parameter3 = length of error buffer, valid values are 4K or less
  96  */
  97 long cxl_h_get_afu_err(u64 unit_address, u64 offset, u64 buf_address, u64 len);
  98
  99 /**
 100  * cxl_h_get_config - collect configuration record for the
 101  *                    coherent platform function
 102  * Parameter1 = # of configuration record to retrieve, valid values are
 103  *              between 0 and (ibm,#config-records - 1)
 104  * Parameter2 = byte offset into configuration record to retrieve,
 105  *              valid values are between 0 and (ibm,config-record-size - 1)
 106  * Parameter3 = 4K aligned real address of configuration record buffer,
 107  *              to be filled in
 108  * Parameter4 = length of configuration buffer, valid values are 4K or less
 109  */
 110 long cxl_h_get_config(u64 unit_address, u64 cr_num, u64 offset,
 111                 u64 buf_address, u64 len);
 112
 113 /**
 114  * cxl_h_terminate_process - Terminate the process before completion
 115  * Parameter1 = process-token as returned from H_ATTACH_CA_PROCESS when
 116  *              process was attached.
 117  */
 118 long cxl_h_terminate_process(u64 unit_address, u64 process_token);
 119
 120 /**
 121  * cxl_h_collect_vpd - Collect VPD for the coherent platform function.
 122  * Parameter1 = # of VPD record to retrieve, valid values are between 0
 123  *              and (ibm,#config-records - 1).
 124  * Parameter2 = 4K naturally aligned real buffer containing block
 125  *              list entries
 126  * Parameter3 = number of block list entries in the block list, valid
 127  *              values are between 0 and 256
 128  */
 129 long cxl_h_collect_vpd(u64 unit_address, u64 record, u64 list_address,
 130                        u64 num, u64 *out);
 131
 132 /**
 133  * cxl_h_get_fn_error_interrupt - Read the function-wide error data based on an interrupt
 134  */
 135 long cxl_h_get_fn_error_interrupt(u64 unit_address, u64 *reg);
 136
 137 /**
 138  * cxl_h_ack_fn_error_interrupt - Acknowledge function-wide error data
 139  *                                based on an interrupt
 140  * Parameter1 = value to write to the function-wide error interrupt register
 141  */
 142 long cxl_h_ack_fn_error_interrupt(u64 unit_address, u64 value);
 143
 144 /**
 145  * cxl_h_get_error_log - Retrieve the Platform Log ID (PLID) of
 146  *                       an error log
 147  */
 148 long cxl_h_get_error_log(u64 unit_address, u64 value);
 149
 150 /**
 151  * cxl_h_collect_int_info - Collect interrupt info about a coherent
 152  *                          platform function after an interrupt occurred.
 153  */
 154 long cxl_h_collect_int_info(u64 unit_address, u64 process_token,
 155                         struct cxl_irq_info *info);
 156
 157 /**
 158  * cxl_h_control_faults - Control the operation of a coherent platform
 159  *                        function after a fault occurs.
 160  *
 161  * Parameters
 162  *    control-mask: value to control the faults
 163  *                  looks like PSL_TFC_An shifted >> 32
 164  *    reset-mask: mask to control reset of function faults
 165  *                Set reset_mask = 1 to reset PSL errors
 166  */
 167 long cxl_h_control_faults(u64 unit_address, u64 process_token,
 168                         u64 control_mask, u64 reset_mask);
 169
 170 /**
 171  * cxl_h_reset_adapter - Perform a reset to the coherent platform facility.
 172  */
 173 long cxl_h_reset_adapter(u64 unit_address);
 174
 175 /**
 176  * cxl_h_collect_vpd - Collect VPD for the coherent platform function.
 177  * Parameter1 = 4K naturally aligned real buffer containing block
 178  *              list entries
 179  * Parameter2 = number of block list entries in the block list, valid
 180  *              values are between 0 and 256
 181  */
 182 long cxl_h_collect_vpd_adapter(u64 unit_address, u64 list_address,
 183                                u64 num, u64 *out);
 184
 185 /**
 186  * cxl_h_download_adapter_image - Download the base image to the coherent
 187  *                                platform facility.
 188  */
 189 long cxl_h_download_adapter_image(u64 unit_address,
 190                                   u64 list_address, u64 num,
 191                                   u64 *out);
 192
 193 /**
 194  * cxl_h_validate_adapter_image - Validate the base image in the coherent
 195  *                                platform facility.
 196  */
 197 long cxl_h_validate_adapter_image(u64 unit_address,
 198                                   u64 list_address, u64 num,
 199                                   u64 *out);
 200 #endif /* _HCALLS_H */