arch/powerpc/include/asm/vas.h

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