1/* SPDX-License-Identifier: GPL-2.0-or-later */ 2/* 3 * Copyright 2016-17 IBM Corp. 4 */ 5 6#ifndef _ASM_POWERPC_VAS_H 7#define _ASM_POWERPC_VAS_H 8#include <linux/sched/mm.h> 9#include <linux/mmu_context.h> 10#include <asm/icswx.h> 11#include <uapi/asm/vas-api.h> 12 13/* 14 * Min and max FIFO sizes are based on Version 1.05 Section 3.1.4.25 15 * (Local FIFO Size Register) of the VAS workbook. 16 */ 17#define VAS_RX_FIFO_SIZE_MIN (1 << 10) /* 1KB */ 18#define VAS_RX_FIFO_SIZE_MAX (8 << 20) /* 8MB */ 19 20/* 21 * Threshold Control Mode: Have paste operation fail if the number of 22 * requests in receive FIFO exceeds a threshold. 23 * 24 * NOTE: No special error code yet if paste is rejected because of these 25 * limits. So users can't distinguish between this and other errors. 26 */ 27#define VAS_THRESH_DISABLED 0 28#define VAS_THRESH_FIFO_GT_HALF_FULL 1 29#define VAS_THRESH_FIFO_GT_QTR_FULL 2 30#define VAS_THRESH_FIFO_GT_EIGHTH_FULL 3 31 32/* 33 * VAS window Linux status bits 34 */ 35#define VAS_WIN_ACTIVE 0x0 /* Used in platform independent */ 36 /* vas mmap() */ 37/* Window is closed in the hypervisor due to lost credit */ 38#define VAS_WIN_NO_CRED_CLOSE 0x00000001 39/* Window is closed due to migration */ 40#define VAS_WIN_MIGRATE_CLOSE 0x00000002 41 42/* 43 * Get/Set bit fields 44 */ 45#define GET_FIELD(m, v) (((v) & (m)) >> MASK_LSH(m)) 46#define MASK_LSH(m) (__builtin_ffsl(m) - 1) 47#define SET_FIELD(m, v, val) \ 48 (((v) & ~(m)) | ((((typeof(v))(val)) << MASK_LSH(m)) & (m))) 49 50/* 51 * Co-processor Engine type. 52 */ 53enum vas_cop_type { 54 VAS_COP_TYPE_FAULT, 55 VAS_COP_TYPE_842, 56 VAS_COP_TYPE_842_HIPRI, 57 VAS_COP_TYPE_GZIP, 58 VAS_COP_TYPE_GZIP_HIPRI, 59 VAS_COP_TYPE_FTW, 60 VAS_COP_TYPE_MAX, 61}; 62 63/* 64 * User space VAS windows are opened by tasks and take references 65 * to pid and mm until windows are closed. 66 * Stores pid, mm, and tgid for each window. 67 */ 68struct vas_user_win_ref { 69 struct pid *pid; /* PID of owner */ 70 struct pid *tgid; /* Thread group ID of owner */ 71 struct mm_struct *mm; /* Linux process mm_struct */ 72 struct mutex mmap_mutex; /* protects paste address mmap() */ 73 /* with DLPAR close/open windows */ 74 struct vm_area_struct *vma; /* Save VMA and used in DLPAR ops */ 75}; 76 77/* 78 * Common VAS window struct on PowerNV and PowerVM 79 */ 80struct vas_window { 81 u32 winid; 82 u32 wcreds_max; /* Window credits */ 83 u32 status; /* Window status used in OS */ 84 enum vas_cop_type cop; 85 struct vas_user_win_ref task_ref; 86 char *dbgname; 87 struct dentry *dbgdir; 88}; 89 90/* 91 * User space window operations used for powernv and powerVM 92 */ 93struct vas_user_win_ops { 94 struct vas_window * (*open_win)(int vas_id, u64 flags, 95 enum vas_cop_type); 96 u64 (*paste_addr)(struct vas_window *); 97 int (*close_win)(struct vas_window *); 98}; 99 100static inline void put_vas_user_win_ref(struct vas_user_win_ref *ref) 101{ 102 /* Drop references to pid, tgid, and mm */ 103 put_pid(ref->pid); 104 put_pid(ref->tgid); 105 if (ref->mm) 106 mmdrop(ref->mm); 107} 108 109static inline void vas_user_win_add_mm_context(struct vas_user_win_ref *ref) 110{ 111 mm_context_add_vas_window(ref->mm); 112 /* 113 * Even a process that has no foreign real address mapping can 114 * use an unpaired COPY instruction (to no real effect). Issue 115 * CP_ABORT to clear any pending COPY and prevent a covert 116 * channel. 117 * 118 * __switch_to() will issue CP_ABORT on future context switches 119 * if process / thread has any open VAS window (Use 120 * current->mm->context.vas_windows). 121 */ 122 asm volatile(PPC_CP_ABORT); 123} 124 125/* 126 * Receive window attributes specified by the (in-kernel) owner of window. 127 */ 128struct vas_rx_win_attr { 129 u64 rx_fifo; 130 int rx_fifo_size; 131 int wcreds_max; 132 133 bool pin_win; 134 bool rej_no_credit; 135 bool tx_wcred_mode; 136 bool rx_wcred_mode; 137 bool tx_win_ord_mode; 138 bool rx_win_ord_mode; 139 bool data_stamp; 140 bool nx_win; 141 bool fault_win; 142 bool user_win; 143 bool notify_disable; 144 bool intr_disable; 145 bool notify_early; 146 147 int lnotify_lpid; 148 int lnotify_pid; 149 int lnotify_tid; 150 u32 pswid; 151 152 int tc_mode; 153}; 154 155/* 156 * Window attributes specified by the in-kernel owner of a send window. 157 */ 158struct vas_tx_win_attr { 159 enum vas_cop_type cop; 160 int wcreds_max; 161 int lpid; 162 int pidr; /* hardware PID (from SPRN_PID) */ 163 int pswid; 164 int rsvd_txbuf_count; 165 int tc_mode; 166 167 bool user_win; 168 bool pin_win; 169 bool rej_no_credit; 170 bool rsvd_txbuf_enable; 171 bool tx_wcred_mode; 172 bool rx_wcred_mode; 173 bool tx_win_ord_mode; 174 bool rx_win_ord_mode; 175}; 176 177#ifdef CONFIG_PPC_POWERNV 178/* 179 * Helper to map a chip id to VAS id. 180 * For POWER9, this is a 1:1 mapping. In the future this maybe a 1:N 181 * mapping in which case, we will need to update this helper. 182 * 183 * Return the VAS id or -1 if no matching vasid is found. 184 */ 185int chip_to_vas_id(int chipid); 186 187/* 188 * Helper to initialize receive window attributes to defaults for an 189 * NX window. 190 */ 191void vas_init_rx_win_attr(struct vas_rx_win_attr *rxattr, enum vas_cop_type cop); 192 193/* 194 * Open a VAS receive window for the instance of VAS identified by @vasid 195 * Use @attr to initialize the attributes of the window. 196 * 197 * Return a handle to the window or ERR_PTR() on error. 198 */ 199struct vas_window *vas_rx_win_open(int vasid, enum vas_cop_type cop, 200 struct vas_rx_win_attr *attr); 201 202/* 203 * Helper to initialize send window attributes to defaults for an NX window. 204 */ 205extern void vas_init_tx_win_attr(struct vas_tx_win_attr *txattr, 206 enum vas_cop_type cop); 207 208/* 209 * Open a VAS send window for the instance of VAS identified by @vasid 210 * and the co-processor type @cop. Use @attr to initialize attributes 211 * of the window. 212 * 213 * Note: The instance of VAS must already have an open receive window for 214 * the coprocessor type @cop. 215 * 216 * Return a handle to the send window or ERR_PTR() on error. 217 */ 218struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop, 219 struct vas_tx_win_attr *attr); 220 221/* 222 * Close the send or receive window identified by @win. For receive windows 223 * return -EAGAIN if there are active send windows attached to this receive 224 * window. 225 */ 226int vas_win_close(struct vas_window *win); 227 228/* 229 * Copy the co-processor request block (CRB) @crb into the local L2 cache. 230 */ 231int vas_copy_crb(void *crb, int offset); 232 233/* 234 * Paste a previously copied CRB (see vas_copy_crb()) from the L2 cache to 235 * the hardware address associated with the window @win. @re is expected/ 236 * assumed to be true for NX windows. 237 */ 238int vas_paste_crb(struct vas_window *win, int offset, bool re); 239 240int vas_register_api_powernv(struct module *mod, enum vas_cop_type cop_type, 241 const char *name); 242void vas_unregister_api_powernv(void); 243#endif 244 245#ifdef CONFIG_PPC_PSERIES 246 247/* VAS Capabilities */ 248#define VAS_GZIP_QOS_FEAT 0x1 249#define VAS_GZIP_DEF_FEAT 0x2 250#define VAS_GZIP_QOS_FEAT_BIT PPC_BIT(VAS_GZIP_QOS_FEAT) /* Bit 1 */ 251#define VAS_GZIP_DEF_FEAT_BIT PPC_BIT(VAS_GZIP_DEF_FEAT) /* Bit 2 */ 252 253/* NX Capabilities */ 254#define VAS_NX_GZIP_FEAT 0x1 255#define VAS_NX_GZIP_FEAT_BIT PPC_BIT(VAS_NX_GZIP_FEAT) /* Bit 1 */ 256 257/* 258 * These structs are used to retrieve overall VAS capabilities that 259 * the hypervisor provides. 260 */ 261struct hv_vas_all_caps { 262 __be64 descriptor; 263 __be64 feat_type; 264} __packed __aligned(0x1000); 265 266struct vas_all_caps { 267 u64 descriptor; 268 u64 feat_type; 269}; 270 271int h_query_vas_capabilities(const u64 hcall, u8 query_type, u64 result); 272int vas_register_api_pseries(struct module *mod, 273 enum vas_cop_type cop_type, const char *name); 274void vas_unregister_api_pseries(void); 275#endif 276 277/* 278 * Register / unregister coprocessor type to VAS API which will be exported 279 * to user space. Applications can use this API to open / close window 280 * which can be used to send / receive requests directly to cooprcessor. 281 * 282 * Only NX GZIP coprocessor type is supported now, but this API can be 283 * used for others in future. 284 */ 285int vas_register_coproc_api(struct module *mod, enum vas_cop_type cop_type, 286 const char *name, 287 const struct vas_user_win_ops *vops); 288void vas_unregister_coproc_api(void); 289 290int get_vas_user_win_ref(struct vas_user_win_ref *task_ref); 291void vas_update_csb(struct coprocessor_request_block *crb, 292 struct vas_user_win_ref *task_ref); 293void vas_dump_crb(struct coprocessor_request_block *crb); 294#endif /* __ASM_POWERPC_VAS_H */ 295