Commit | Line | Data |
---|---|---|
7c8c5e6a MZ |
1 | /* |
2 | * Copyright (C) 2012,2013 - ARM Ltd | |
3 | * Author: Marc Zyngier <marc.zyngier@arm.com> | |
4 | * | |
5 | * Derived from arch/arm/kvm/coproc.h | |
6 | * Copyright (C) 2012 - Virtual Open Systems and Columbia University | |
7 | * Authors: Christoffer Dall <c.dall@virtualopensystems.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License, version 2, as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
20 | */ | |
21 | ||
22 | #ifndef __ARM64_KVM_SYS_REGS_LOCAL_H__ | |
23 | #define __ARM64_KVM_SYS_REGS_LOCAL_H__ | |
24 | ||
25 | struct sys_reg_params { | |
26 | u8 Op0; | |
27 | u8 Op1; | |
28 | u8 CRn; | |
29 | u8 CRm; | |
30 | u8 Op2; | |
2ec5be3d | 31 | u64 regval; |
7c8c5e6a | 32 | bool is_write; |
2072d29c MZ |
33 | bool is_aarch32; |
34 | bool is_32bit; /* Only valid if is_aarch32 is true */ | |
7c8c5e6a MZ |
35 | }; |
36 | ||
37 | struct sys_reg_desc { | |
38 | /* MRS/MSR instruction which accesses it. */ | |
39 | u8 Op0; | |
40 | u8 Op1; | |
41 | u8 CRn; | |
42 | u8 CRm; | |
43 | u8 Op2; | |
44 | ||
45 | /* Trapped access from guest, if non-NULL. */ | |
46 | bool (*access)(struct kvm_vcpu *, | |
3fec037d | 47 | struct sys_reg_params *, |
7c8c5e6a MZ |
48 | const struct sys_reg_desc *); |
49 | ||
50 | /* Initialization for vcpu. */ | |
51 | void (*reset)(struct kvm_vcpu *, const struct sys_reg_desc *); | |
52 | ||
53 | /* Index into sys_reg[], or 0 if we don't need to save it. */ | |
54 | int reg; | |
55 | ||
56 | /* Value (usually reset value) */ | |
57 | u64 val; | |
84e690bf AB |
58 | |
59 | /* Custom get/set_user functions, fallback to generic if NULL */ | |
60 | int (*get_user)(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd, | |
61 | const struct kvm_one_reg *reg, void __user *uaddr); | |
62 | int (*set_user)(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd, | |
63 | const struct kvm_one_reg *reg, void __user *uaddr); | |
7c8c5e6a MZ |
64 | }; |
65 | ||
66 | static inline void print_sys_reg_instr(const struct sys_reg_params *p) | |
67 | { | |
68 | /* Look, we even formatted it for you to paste into the table! */ | |
69 | kvm_pr_unimpl(" { Op0(%2u), Op1(%2u), CRn(%2u), CRm(%2u), Op2(%2u), func_%s },\n", | |
70 | p->Op0, p->Op1, p->CRn, p->CRm, p->Op2, p->is_write ? "write" : "read"); | |
71 | } | |
72 | ||
73 | static inline bool ignore_write(struct kvm_vcpu *vcpu, | |
74 | const struct sys_reg_params *p) | |
75 | { | |
76 | return true; | |
77 | } | |
78 | ||
79 | static inline bool read_zero(struct kvm_vcpu *vcpu, | |
3fec037d | 80 | struct sys_reg_params *p) |
7c8c5e6a | 81 | { |
2ec5be3d | 82 | p->regval = 0; |
7c8c5e6a MZ |
83 | return true; |
84 | } | |
85 | ||
86 | static inline bool write_to_read_only(struct kvm_vcpu *vcpu, | |
87 | const struct sys_reg_params *params) | |
88 | { | |
89 | kvm_debug("sys_reg write to read-only register at: %lx\n", | |
90 | *vcpu_pc(vcpu)); | |
91 | print_sys_reg_instr(params); | |
92 | return false; | |
93 | } | |
94 | ||
95 | static inline bool read_from_write_only(struct kvm_vcpu *vcpu, | |
96 | const struct sys_reg_params *params) | |
97 | { | |
98 | kvm_debug("sys_reg read to write-only register at: %lx\n", | |
99 | *vcpu_pc(vcpu)); | |
100 | print_sys_reg_instr(params); | |
101 | return false; | |
102 | } | |
103 | ||
104 | /* Reset functions */ | |
105 | static inline void reset_unknown(struct kvm_vcpu *vcpu, | |
106 | const struct sys_reg_desc *r) | |
107 | { | |
108 | BUG_ON(!r->reg); | |
109 | BUG_ON(r->reg >= NR_SYS_REGS); | |
110 | vcpu_sys_reg(vcpu, r->reg) = 0x1de7ec7edbadc0deULL; | |
111 | } | |
112 | ||
113 | static inline void reset_val(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r) | |
114 | { | |
115 | BUG_ON(!r->reg); | |
116 | BUG_ON(r->reg >= NR_SYS_REGS); | |
117 | vcpu_sys_reg(vcpu, r->reg) = r->val; | |
118 | } | |
119 | ||
120 | static inline int cmp_sys_reg(const struct sys_reg_desc *i1, | |
121 | const struct sys_reg_desc *i2) | |
122 | { | |
123 | BUG_ON(i1 == i2); | |
124 | if (!i1) | |
125 | return 1; | |
126 | else if (!i2) | |
127 | return -1; | |
128 | if (i1->Op0 != i2->Op0) | |
129 | return i1->Op0 - i2->Op0; | |
130 | if (i1->Op1 != i2->Op1) | |
131 | return i1->Op1 - i2->Op1; | |
132 | if (i1->CRn != i2->CRn) | |
133 | return i1->CRn - i2->CRn; | |
134 | if (i1->CRm != i2->CRm) | |
135 | return i1->CRm - i2->CRm; | |
136 | return i1->Op2 - i2->Op2; | |
137 | } | |
138 | ||
139 | ||
140 | #define Op0(_x) .Op0 = _x | |
141 | #define Op1(_x) .Op1 = _x | |
142 | #define CRn(_x) .CRn = _x | |
143 | #define CRm(_x) .CRm = _x | |
144 | #define Op2(_x) .Op2 = _x | |
145 | ||
146 | #endif /* __ARM64_KVM_SYS_REGS_LOCAL_H__ */ |