1 /*
2 * HPPA interrupt helper routines
3 *
4 * Copyright (c) 2017 Richard Henderson
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "migration/cpu.h"
23
24
get_psw(QEMUFile * f,void * opaque,size_t size,const VMStateField * field)25 static int get_psw(QEMUFile *f, void *opaque, size_t size,
26 const VMStateField *field)
27 {
28 CPUHPPAState *env = opaque;
29 cpu_hppa_put_psw(env, qemu_get_be64(f));
30 return 0;
31 }
32
put_psw(QEMUFile * f,void * opaque,size_t size,const VMStateField * field,JSONWriter * vmdesc)33 static int put_psw(QEMUFile *f, void *opaque, size_t size,
34 const VMStateField *field, JSONWriter *vmdesc)
35 {
36 CPUHPPAState *env = opaque;
37 qemu_put_be64(f, cpu_hppa_get_psw(env));
38 return 0;
39 }
40
41 static const VMStateInfo vmstate_psw = {
42 .name = "psw",
43 .get = get_psw,
44 .put = put_psw,
45 };
46
get_tlb(QEMUFile * f,void * opaque,size_t size,const VMStateField * field)47 static int get_tlb(QEMUFile *f, void *opaque, size_t size,
48 const VMStateField *field)
49 {
50 HPPATLBEntry *ent = opaque;
51 uint64_t val;
52
53 ent->itree.start = qemu_get_be64(f);
54 ent->itree.last = qemu_get_be64(f);
55 ent->pa = qemu_get_be64(f);
56 val = qemu_get_be64(f);
57
58 if (val) {
59 ent->t = extract64(val, 61, 1);
60 ent->d = extract64(val, 60, 1);
61 ent->b = extract64(val, 59, 1);
62 ent->ar_type = extract64(val, 56, 3);
63 ent->ar_pl1 = extract64(val, 54, 2);
64 ent->ar_pl2 = extract64(val, 52, 2);
65 ent->u = extract64(val, 51, 1);
66 /* o = bit 50 */
67 /* p = bit 49 */
68 ent->access_id = extract64(val, 1, 31);
69 ent->entry_valid = 1;
70 }
71 return 0;
72 }
73
put_tlb(QEMUFile * f,void * opaque,size_t size,const VMStateField * field,JSONWriter * vmdesc)74 static int put_tlb(QEMUFile *f, void *opaque, size_t size,
75 const VMStateField *field, JSONWriter *vmdesc)
76 {
77 HPPATLBEntry *ent = opaque;
78 uint64_t val = 0;
79
80 if (ent->entry_valid) {
81 val = 1;
82 val = deposit64(val, 61, 1, ent->t);
83 val = deposit64(val, 60, 1, ent->d);
84 val = deposit64(val, 59, 1, ent->b);
85 val = deposit64(val, 56, 3, ent->ar_type);
86 val = deposit64(val, 54, 2, ent->ar_pl1);
87 val = deposit64(val, 52, 2, ent->ar_pl2);
88 val = deposit64(val, 51, 1, ent->u);
89 /* o = bit 50 */
90 /* p = bit 49 */
91 val = deposit64(val, 1, 31, ent->access_id);
92 }
93
94 qemu_put_be64(f, ent->itree.start);
95 qemu_put_be64(f, ent->itree.last);
96 qemu_put_be64(f, ent->pa);
97 qemu_put_be64(f, val);
98 return 0;
99 }
100
101 static const VMStateInfo vmstate_tlb_entry = {
102 .name = "tlb entry",
103 .get = get_tlb,
104 .put = put_tlb,
105 };
106
tlb_pre_load(void * opaque)107 static int tlb_pre_load(void *opaque)
108 {
109 CPUHPPAState *env = opaque;
110
111 /*
112 * Zap the entire tlb, on-the-side data structures and all.
113 * Each tlb entry will have data re-filled by put_tlb.
114 */
115 memset(env->tlb, 0, sizeof(env->tlb));
116 memset(&env->tlb_root, 0, sizeof(env->tlb_root));
117 env->tlb_unused = NULL;
118 env->tlb_partial = NULL;
119
120 return 0;
121 }
122
tlb_post_load(void * opaque,int version_id)123 static int tlb_post_load(void *opaque, int version_id)
124 {
125 CPUHPPAState *env = opaque;
126 uint32_t btlb_entries = HPPA_BTLB_ENTRIES(env);
127 HPPATLBEntry **unused = &env->tlb_unused;
128 HPPATLBEntry *partial = NULL;
129
130 /*
131 * Re-create the interval tree from the valid entries.
132 * Truly invalid entries should have start == end == 0.
133 * Otherwise it should be the in-flight tlb_partial entry.
134 */
135 for (uint32_t i = 0; i < ARRAY_SIZE(env->tlb); ++i) {
136 HPPATLBEntry *e = &env->tlb[i];
137
138 if (e->entry_valid) {
139 interval_tree_insert(&e->itree, &env->tlb_root);
140 } else if (i < btlb_entries) {
141 /* btlb not in unused list */
142 } else if (partial == NULL && e->itree.start < e->itree.last) {
143 partial = e;
144 } else {
145 *unused = e;
146 unused = &e->unused_next;
147 }
148 }
149 env->tlb_partial = partial;
150 *unused = NULL;
151
152 return 0;
153 }
154
155 static const VMStateField vmstate_tlb_fields[] = {
156 VMSTATE_ARRAY(tlb, CPUHPPAState,
157 ARRAY_SIZE(((CPUHPPAState *)0)->tlb),
158 0, vmstate_tlb_entry, HPPATLBEntry),
159 VMSTATE_UINT32(tlb_last, CPUHPPAState),
160 VMSTATE_END_OF_LIST()
161 };
162
163 static const VMStateDescription vmstate_tlb = {
164 .name = "env/tlb",
165 .version_id = 1,
166 .minimum_version_id = 1,
167 .fields = vmstate_tlb_fields,
168 .pre_load = tlb_pre_load,
169 .post_load = tlb_post_load,
170 };
171
172 static const VMStateField vmstate_env_fields[] = {
173 VMSTATE_UINT64_ARRAY(gr, CPUHPPAState, 32),
174 VMSTATE_UINT64_ARRAY(fr, CPUHPPAState, 32),
175 VMSTATE_UINT64_ARRAY(sr, CPUHPPAState, 8),
176 VMSTATE_UINT64_ARRAY(cr, CPUHPPAState, 32),
177 VMSTATE_UINT64_ARRAY(cr_back, CPUHPPAState, 2),
178 VMSTATE_UINT64_ARRAY(shadow, CPUHPPAState, 7),
179
180 /* Save the architecture value of the psw, not the internally
181 expanded version. Since this architecture value does not
182 exist in memory to be stored, this requires a but of hoop
183 jumping. We want OFFSET=0 so that we effectively pass ENV
184 to the helper functions, and we need to fill in the name by
185 hand since there's no field of that name. */
186 {
187 .name = "psw",
188 .version_id = 0,
189 .size = sizeof(uint64_t),
190 .info = &vmstate_psw,
191 .flags = VMS_SINGLE,
192 .offset = 0
193 },
194
195 VMSTATE_UINT64(iaoq_f, CPUHPPAState),
196 VMSTATE_UINT64(iaoq_b, CPUHPPAState),
197 VMSTATE_UINT64(iasq_f, CPUHPPAState),
198 VMSTATE_UINT64(iasq_b, CPUHPPAState),
199
200 VMSTATE_UINT32(fr0_shadow, CPUHPPAState),
201 VMSTATE_END_OF_LIST()
202 };
203
204 static const VMStateDescription * const vmstate_env_subsections[] = {
205 &vmstate_tlb,
206 NULL
207 };
208
209 static const VMStateDescription vmstate_env = {
210 .name = "env",
211 .version_id = 3,
212 .minimum_version_id = 3,
213 .fields = vmstate_env_fields,
214 .subsections = vmstate_env_subsections,
215 };
216
217 static const VMStateField vmstate_cpu_fields[] = {
218 VMSTATE_CPU(),
219 VMSTATE_STRUCT(env, HPPACPU, 1, vmstate_env, CPUHPPAState),
220 VMSTATE_END_OF_LIST()
221 };
222
223 const VMStateDescription vmstate_hppa_cpu = {
224 .name = "cpu",
225 .version_id = 1,
226 .minimum_version_id = 1,
227 .fields = vmstate_cpu_fields,
228 };
229