GNU Linux-libre 6.7.9-gnu
[releases.git] / arch / riscv / kvm / vcpu_fp.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2021 Western Digital Corporation or its affiliates.
4  *
5  * Authors:
6  *     Atish Patra <atish.patra@wdc.com>
7  *     Anup Patel <anup.patel@wdc.com>
8  */
9
10 #include <linux/errno.h>
11 #include <linux/err.h>
12 #include <linux/kvm_host.h>
13 #include <linux/uaccess.h>
14 #include <asm/cpufeature.h>
15
16 #ifdef CONFIG_FPU
17 void kvm_riscv_vcpu_fp_reset(struct kvm_vcpu *vcpu)
18 {
19         struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;
20
21         cntx->sstatus &= ~SR_FS;
22         if (riscv_isa_extension_available(vcpu->arch.isa, f) ||
23             riscv_isa_extension_available(vcpu->arch.isa, d))
24                 cntx->sstatus |= SR_FS_INITIAL;
25         else
26                 cntx->sstatus |= SR_FS_OFF;
27 }
28
29 static void kvm_riscv_vcpu_fp_clean(struct kvm_cpu_context *cntx)
30 {
31         cntx->sstatus &= ~SR_FS;
32         cntx->sstatus |= SR_FS_CLEAN;
33 }
34
35 void kvm_riscv_vcpu_guest_fp_save(struct kvm_cpu_context *cntx,
36                                   const unsigned long *isa)
37 {
38         if ((cntx->sstatus & SR_FS) == SR_FS_DIRTY) {
39                 if (riscv_isa_extension_available(isa, d))
40                         __kvm_riscv_fp_d_save(cntx);
41                 else if (riscv_isa_extension_available(isa, f))
42                         __kvm_riscv_fp_f_save(cntx);
43                 kvm_riscv_vcpu_fp_clean(cntx);
44         }
45 }
46
47 void kvm_riscv_vcpu_guest_fp_restore(struct kvm_cpu_context *cntx,
48                                      const unsigned long *isa)
49 {
50         if ((cntx->sstatus & SR_FS) != SR_FS_OFF) {
51                 if (riscv_isa_extension_available(isa, d))
52                         __kvm_riscv_fp_d_restore(cntx);
53                 else if (riscv_isa_extension_available(isa, f))
54                         __kvm_riscv_fp_f_restore(cntx);
55                 kvm_riscv_vcpu_fp_clean(cntx);
56         }
57 }
58
59 void kvm_riscv_vcpu_host_fp_save(struct kvm_cpu_context *cntx)
60 {
61         /* No need to check host sstatus as it can be modified outside */
62         if (riscv_isa_extension_available(NULL, d))
63                 __kvm_riscv_fp_d_save(cntx);
64         else if (riscv_isa_extension_available(NULL, f))
65                 __kvm_riscv_fp_f_save(cntx);
66 }
67
68 void kvm_riscv_vcpu_host_fp_restore(struct kvm_cpu_context *cntx)
69 {
70         if (riscv_isa_extension_available(NULL, d))
71                 __kvm_riscv_fp_d_restore(cntx);
72         else if (riscv_isa_extension_available(NULL, f))
73                 __kvm_riscv_fp_f_restore(cntx);
74 }
75 #endif
76
77 int kvm_riscv_vcpu_get_reg_fp(struct kvm_vcpu *vcpu,
78                               const struct kvm_one_reg *reg,
79                               unsigned long rtype)
80 {
81         struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;
82         unsigned long __user *uaddr =
83                         (unsigned long __user *)(unsigned long)reg->addr;
84         unsigned long reg_num = reg->id & ~(KVM_REG_ARCH_MASK |
85                                             KVM_REG_SIZE_MASK |
86                                             rtype);
87         void *reg_val;
88
89         if ((rtype == KVM_REG_RISCV_FP_F) &&
90             riscv_isa_extension_available(vcpu->arch.isa, f)) {
91                 if (KVM_REG_SIZE(reg->id) != sizeof(u32))
92                         return -EINVAL;
93                 if (reg_num == KVM_REG_RISCV_FP_F_REG(fcsr))
94                         reg_val = &cntx->fp.f.fcsr;
95                 else if ((KVM_REG_RISCV_FP_F_REG(f[0]) <= reg_num) &&
96                           reg_num <= KVM_REG_RISCV_FP_F_REG(f[31]))
97                         reg_val = &cntx->fp.f.f[reg_num];
98                 else
99                         return -ENOENT;
100         } else if ((rtype == KVM_REG_RISCV_FP_D) &&
101                    riscv_isa_extension_available(vcpu->arch.isa, d)) {
102                 if (reg_num == KVM_REG_RISCV_FP_D_REG(fcsr)) {
103                         if (KVM_REG_SIZE(reg->id) != sizeof(u32))
104                                 return -EINVAL;
105                         reg_val = &cntx->fp.d.fcsr;
106                 } else if ((KVM_REG_RISCV_FP_D_REG(f[0]) <= reg_num) &&
107                            reg_num <= KVM_REG_RISCV_FP_D_REG(f[31])) {
108                         if (KVM_REG_SIZE(reg->id) != sizeof(u64))
109                                 return -EINVAL;
110                         reg_val = &cntx->fp.d.f[reg_num];
111                 } else
112                         return -ENOENT;
113         } else
114                 return -ENOENT;
115
116         if (copy_to_user(uaddr, reg_val, KVM_REG_SIZE(reg->id)))
117                 return -EFAULT;
118
119         return 0;
120 }
121
122 int kvm_riscv_vcpu_set_reg_fp(struct kvm_vcpu *vcpu,
123                               const struct kvm_one_reg *reg,
124                               unsigned long rtype)
125 {
126         struct kvm_cpu_context *cntx = &vcpu->arch.guest_context;
127         unsigned long __user *uaddr =
128                         (unsigned long __user *)(unsigned long)reg->addr;
129         unsigned long reg_num = reg->id & ~(KVM_REG_ARCH_MASK |
130                                             KVM_REG_SIZE_MASK |
131                                             rtype);
132         void *reg_val;
133
134         if ((rtype == KVM_REG_RISCV_FP_F) &&
135             riscv_isa_extension_available(vcpu->arch.isa, f)) {
136                 if (KVM_REG_SIZE(reg->id) != sizeof(u32))
137                         return -EINVAL;
138                 if (reg_num == KVM_REG_RISCV_FP_F_REG(fcsr))
139                         reg_val = &cntx->fp.f.fcsr;
140                 else if ((KVM_REG_RISCV_FP_F_REG(f[0]) <= reg_num) &&
141                           reg_num <= KVM_REG_RISCV_FP_F_REG(f[31]))
142                         reg_val = &cntx->fp.f.f[reg_num];
143                 else
144                         return -ENOENT;
145         } else if ((rtype == KVM_REG_RISCV_FP_D) &&
146                    riscv_isa_extension_available(vcpu->arch.isa, d)) {
147                 if (reg_num == KVM_REG_RISCV_FP_D_REG(fcsr)) {
148                         if (KVM_REG_SIZE(reg->id) != sizeof(u32))
149                                 return -EINVAL;
150                         reg_val = &cntx->fp.d.fcsr;
151                 } else if ((KVM_REG_RISCV_FP_D_REG(f[0]) <= reg_num) &&
152                            reg_num <= KVM_REG_RISCV_FP_D_REG(f[31])) {
153                         if (KVM_REG_SIZE(reg->id) != sizeof(u64))
154                                 return -EINVAL;
155                         reg_val = &cntx->fp.d.f[reg_num];
156                 } else
157                         return -ENOENT;
158         } else
159                 return -ENOENT;
160
161         if (copy_from_user(reg_val, uaddr, KVM_REG_SIZE(reg->id)))
162                 return -EFAULT;
163
164         return 0;
165 }