root/arch/arm/kvm/coproc.h

INCLUDED FROM

DEFINITIONS

1. print_cp_instr
2. ignore_write
3. read_zero
4. reset_unknown
5. reset_val
6. reset_unknown64
7. cmp_reg

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2012 - Virtual Open Systems and Columbia University
   4  * Authors: Christoffer Dall <c.dall@virtualopensystems.com>
   5  */
   6 
   7 #ifndef __ARM_KVM_COPROC_LOCAL_H__
   8 #define __ARM_KVM_COPROC_LOCAL_H__
   9 
  10 struct coproc_params {
  11         unsigned long CRn;
  12         unsigned long CRm;
  13         unsigned long Op1;
  14         unsigned long Op2;
  15         unsigned long Rt1;
  16         unsigned long Rt2;
  17         bool is_64bit;
  18         bool is_write;
  19 };
  20 
  21 struct coproc_reg {
  22         /* MRC/MCR/MRRC/MCRR instruction which accesses it. */
  23         unsigned long CRn;
  24         unsigned long CRm;
  25         unsigned long Op1;
  26         unsigned long Op2;
  27 
  28         bool is_64bit;
  29 
  30         /* Trapped access from guest, if non-NULL. */
  31         bool (*access)(struct kvm_vcpu *,
  32                        const struct coproc_params *,
  33                        const struct coproc_reg *);
  34 
  35         /* Initialization for vcpu. */
  36         void (*reset)(struct kvm_vcpu *, const struct coproc_reg *);
  37 
  38         /* Index into vcpu_cp15(vcpu, ...), or 0 if we don't need to save it. */
  39         unsigned long reg;
  40 
  41         /* Value (usually reset value) */
  42         u64 val;
  43 };
  44 
  45 static inline void print_cp_instr(const struct coproc_params *p)
  46 {
  47         /* Look, we even formatted it for you to paste into the table! */
  48         if (p->is_64bit) {
  49                 kvm_pr_unimpl(" { CRm64(%2lu), Op1(%2lu), is64, func_%s },\n",
  50                               p->CRn, p->Op1, p->is_write ? "write" : "read");
  51         } else {
  52                 kvm_pr_unimpl(" { CRn(%2lu), CRm(%2lu), Op1(%2lu), Op2(%2lu), is32,"
  53                               " func_%s },\n",
  54                               p->CRn, p->CRm, p->Op1, p->Op2,
  55                               p->is_write ? "write" : "read");
  56         }
  57 }
  58 
  59 static inline bool ignore_write(struct kvm_vcpu *vcpu,
  60                                 const struct coproc_params *p)
  61 {
  62         return true;
  63 }
  64 
  65 static inline bool read_zero(struct kvm_vcpu *vcpu,
  66                              const struct coproc_params *p)
  67 {
  68         *vcpu_reg(vcpu, p->Rt1) = 0;
  69         return true;
  70 }
  71 
  72 /* Reset functions */
  73 static inline void reset_unknown(struct kvm_vcpu *vcpu,
  74                                  const struct coproc_reg *r)
  75 {
  76         BUG_ON(!r->reg);
  77         BUG_ON(r->reg >= ARRAY_SIZE(vcpu->arch.ctxt.cp15));
  78         vcpu_cp15(vcpu, r->reg) = 0xdecafbad;
  79 }
  80 
  81 static inline void reset_val(struct kvm_vcpu *vcpu, const struct coproc_reg *r)
  82 {
  83         BUG_ON(!r->reg);
  84         BUG_ON(r->reg >= ARRAY_SIZE(vcpu->arch.ctxt.cp15));
  85         vcpu_cp15(vcpu, r->reg) = r->val;
  86 }
  87 
  88 static inline void reset_unknown64(struct kvm_vcpu *vcpu,
  89                                    const struct coproc_reg *r)
  90 {
  91         BUG_ON(!r->reg);
  92         BUG_ON(r->reg + 1 >= ARRAY_SIZE(vcpu->arch.ctxt.cp15));
  93 
  94         vcpu_cp15(vcpu, r->reg) = 0xdecafbad;
  95         vcpu_cp15(vcpu, r->reg+1) = 0xd0c0ffee;
  96 }
  97 
  98 static inline int cmp_reg(const struct coproc_reg *i1,
  99                           const struct coproc_reg *i2)
 100 {
 101         BUG_ON(i1 == i2);
 102         if (!i1)
 103                 return 1;
 104         else if (!i2)
 105                 return -1;
 106         if (i1->CRn != i2->CRn)
 107                 return i1->CRn - i2->CRn;
 108         if (i1->CRm != i2->CRm)
 109                 return i1->CRm - i2->CRm;
 110         if (i1->Op1 != i2->Op1)
 111                 return i1->Op1 - i2->Op1;
 112         if (i1->Op2 != i2->Op2)
 113                 return i1->Op2 - i2->Op2;
 114         return i2->is_64bit - i1->is_64bit;
 115 }
 116 
 117 
 118 #define CRn(_x)         .CRn = _x
 119 #define CRm(_x)         .CRm = _x
 120 #define CRm64(_x)       .CRn = _x, .CRm = 0
 121 #define Op1(_x)         .Op1 = _x
 122 #define Op2(_x)         .Op2 = _x
 123 #define is64            .is_64bit = true
 124 #define is32            .is_64bit = false
 125 
 126 bool access_vm_reg(struct kvm_vcpu *vcpu,
 127                    const struct coproc_params *p,
 128                    const struct coproc_reg *r);
 129 
 130 #endif /* __ARM_KVM_COPROC_LOCAL_H__ */