1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2013 Hudson River Trading LLC
5 * Written by: John H. Baldwin <[email protected]>
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32
33 #include <sys/types.h>
34 #include <machine/vmm.h>
35
36 #include <assert.h>
37 #include <errno.h>
38 #include <pthread.h>
39 #include <signal.h>
40 #include <vmmapi.h>
41
42 #include "acpi.h"
43 #include "inout.h"
44 #include "mevent.h"
45 #include "pci_irq.h"
46 #include "pci_lpc.h"
47
48 static pthread_mutex_t pm_lock = PTHREAD_MUTEX_INITIALIZER;
49 static struct mevent *power_button;
50 static sig_t old_power_handler;
51
52 static unsigned gpe0_active;
53 static unsigned gpe0_enabled;
54 static const unsigned gpe0_valid = (1u << GPE_VMGENC);
55
56 /*
57 * Reset Control register at I/O port 0xcf9. Bit 2 forces a system
58 * reset when it transitions from 0 to 1. Bit 1 selects the type of
59 * reset to attempt: 0 selects a "soft" reset, and 1 selects a "hard"
60 * reset.
61 */
62 static int
reset_handler(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)63 reset_handler(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
64 uint32_t *eax, void *arg)
65 {
66 int error;
67
68 static uint8_t reset_control;
69
70 if (bytes != 1)
71 return (-1);
72 if (in)
73 *eax = reset_control;
74 else {
75 reset_control = *eax;
76
77 /* Treat hard and soft resets the same. */
78 if (reset_control & 0x4) {
79 error = vm_suspend(ctx, VM_SUSPEND_RESET);
80 assert(error == 0 || errno == EALREADY);
81 }
82 }
83 return (0);
84 }
85 INOUT_PORT(reset_reg, 0xCF9, IOPORT_F_INOUT, reset_handler);
86
87 /*
88 * ACPI's SCI is a level-triggered interrupt.
89 */
90 static int sci_active;
91
92 static void
sci_assert(struct vmctx * ctx)93 sci_assert(struct vmctx *ctx)
94 {
95
96 if (sci_active)
97 return;
98 vm_isa_assert_irq(ctx, SCI_INT, SCI_INT);
99 sci_active = 1;
100 }
101
102 static void
sci_deassert(struct vmctx * ctx)103 sci_deassert(struct vmctx *ctx)
104 {
105
106 if (!sci_active)
107 return;
108 vm_isa_deassert_irq(ctx, SCI_INT, SCI_INT);
109 sci_active = 0;
110 }
111
112 /*
113 * Power Management 1 Event Registers
114 *
115 * The only power management event supported is a power button upon
116 * receiving SIGTERM.
117 */
118 static uint16_t pm1_enable, pm1_status;
119
120 #define PM1_TMR_STS 0x0001
121 #define PM1_BM_STS 0x0010
122 #define PM1_GBL_STS 0x0020
123 #define PM1_PWRBTN_STS 0x0100
124 #define PM1_SLPBTN_STS 0x0200
125 #define PM1_RTC_STS 0x0400
126 #define PM1_WAK_STS 0x8000
127
128 #define PM1_TMR_EN 0x0001
129 #define PM1_GBL_EN 0x0020
130 #define PM1_PWRBTN_EN 0x0100
131 #define PM1_SLPBTN_EN 0x0200
132 #define PM1_RTC_EN 0x0400
133
134 static void
sci_update(struct vmctx * ctx)135 sci_update(struct vmctx *ctx)
136 {
137 int need_sci;
138
139 /* See if the SCI should be active or not. */
140 need_sci = 0;
141 if ((pm1_enable & PM1_TMR_EN) && (pm1_status & PM1_TMR_STS))
142 need_sci = 1;
143 if ((pm1_enable & PM1_GBL_EN) && (pm1_status & PM1_GBL_STS))
144 need_sci = 1;
145 if ((pm1_enable & PM1_PWRBTN_EN) && (pm1_status & PM1_PWRBTN_STS))
146 need_sci = 1;
147 if ((pm1_enable & PM1_SLPBTN_EN) && (pm1_status & PM1_SLPBTN_STS))
148 need_sci = 1;
149 if ((pm1_enable & PM1_RTC_EN) && (pm1_status & PM1_RTC_STS))
150 need_sci = 1;
151 if ((gpe0_enabled & gpe0_active) != 0)
152 need_sci = 1;
153
154 if (need_sci)
155 sci_assert(ctx);
156 else
157 sci_deassert(ctx);
158 }
159
160 static int
pm1_status_handler(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)161 pm1_status_handler(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
162 uint32_t *eax, void *arg)
163 {
164
165 if (bytes != 2)
166 return (-1);
167
168 pthread_mutex_lock(&pm_lock);
169 if (in)
170 *eax = pm1_status;
171 else {
172 /*
173 * Writes are only permitted to clear certain bits by
174 * writing 1 to those flags.
175 */
176 pm1_status &= ~(*eax & (PM1_WAK_STS | PM1_RTC_STS |
177 PM1_SLPBTN_STS | PM1_PWRBTN_STS | PM1_BM_STS));
178 sci_update(ctx);
179 }
180 pthread_mutex_unlock(&pm_lock);
181 return (0);
182 }
183
184 static int
pm1_enable_handler(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)185 pm1_enable_handler(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
186 uint32_t *eax, void *arg)
187 {
188
189 if (bytes != 2)
190 return (-1);
191
192 pthread_mutex_lock(&pm_lock);
193 if (in)
194 *eax = pm1_enable;
195 else {
196 /*
197 * Only permit certain bits to be set. We never use
198 * the global lock, but ACPI-CA whines profusely if it
199 * can't set GBL_EN.
200 */
201 pm1_enable = *eax & (PM1_RTC_EN | PM1_PWRBTN_EN | PM1_GBL_EN);
202 sci_update(ctx);
203 }
204 pthread_mutex_unlock(&pm_lock);
205 return (0);
206 }
207 INOUT_PORT(pm1_status, PM1A_EVT_ADDR, IOPORT_F_INOUT, pm1_status_handler);
208 INOUT_PORT(pm1_enable, PM1A_EVT_ADDR + 2, IOPORT_F_INOUT, pm1_enable_handler);
209
210 static void
power_button_handler(int signal,enum ev_type type,void * arg)211 power_button_handler(int signal, enum ev_type type, void *arg)
212 {
213 struct vmctx *ctx;
214
215 ctx = arg;
216 pthread_mutex_lock(&pm_lock);
217 if (!(pm1_status & PM1_PWRBTN_STS)) {
218 pm1_status |= PM1_PWRBTN_STS;
219 sci_update(ctx);
220 }
221 pthread_mutex_unlock(&pm_lock);
222 }
223
224 /*
225 * Power Management 1 Control Register
226 *
227 * This is mostly unimplemented except that we wish to handle writes that
228 * set SPL_EN to handle S5 (soft power off).
229 */
230 static uint16_t pm1_control;
231
232 #define PM1_SCI_EN 0x0001
233 #define PM1_SLP_TYP 0x1c00
234 #define PM1_SLP_EN 0x2000
235 #define PM1_ALWAYS_ZERO 0xc003
236
237 static int
pm1_control_handler(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)238 pm1_control_handler(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
239 uint32_t *eax, void *arg)
240 {
241 int error;
242
243 if (bytes != 2)
244 return (-1);
245 if (in)
246 *eax = pm1_control;
247 else {
248 /*
249 * Various bits are write-only or reserved, so force them
250 * to zero in pm1_control. Always preserve SCI_EN as OSPM
251 * can never change it.
252 */
253 pm1_control = (pm1_control & PM1_SCI_EN) |
254 (*eax & ~(PM1_SLP_EN | PM1_ALWAYS_ZERO));
255
256 /*
257 * If SLP_EN is set, check for S5. Bhyve's _S5_ method
258 * says that '5' should be stored in SLP_TYP for S5.
259 */
260 if (*eax & PM1_SLP_EN) {
261 if ((pm1_control & PM1_SLP_TYP) >> 10 == 5) {
262 error = vm_suspend(ctx, VM_SUSPEND_POWEROFF);
263 assert(error == 0 || errno == EALREADY);
264 }
265 }
266 }
267 return (0);
268 }
269 INOUT_PORT(pm1_control, PM1A_CNT_ADDR, IOPORT_F_INOUT, pm1_control_handler);
270 SYSRES_IO(PM1A_EVT_ADDR, 8);
271
272 void
acpi_raise_gpe(struct vmctx * ctx,unsigned bit)273 acpi_raise_gpe(struct vmctx *ctx, unsigned bit)
274 {
275 unsigned mask;
276
277 assert(bit < (IO_GPE0_LEN * (8 / 2)));
278 mask = (1u << bit);
279 assert((mask & ~gpe0_valid) == 0);
280
281 pthread_mutex_lock(&pm_lock);
282 gpe0_active |= mask;
283 sci_update(ctx);
284 pthread_mutex_unlock(&pm_lock);
285 }
286
287 static int
gpe0_sts(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)288 gpe0_sts(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
289 uint32_t *eax, void *arg)
290 {
291 /*
292 * ACPI 6.2 specifies the GPE register blocks are accessed
293 * byte-at-a-time.
294 */
295 if (bytes != 1)
296 return (-1);
297
298 pthread_mutex_lock(&pm_lock);
299 if (in)
300 *eax = gpe0_active;
301 else {
302 /* W1C */
303 gpe0_active &= ~(*eax & gpe0_valid);
304 sci_update(ctx);
305 }
306 pthread_mutex_unlock(&pm_lock);
307 return (0);
308 }
309 INOUT_PORT(gpe0_sts, IO_GPE0_STS, IOPORT_F_INOUT, gpe0_sts);
310
311 static int
gpe0_en(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)312 gpe0_en(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
313 uint32_t *eax, void *arg)
314 {
315 if (bytes != 1)
316 return (-1);
317
318 pthread_mutex_lock(&pm_lock);
319 if (in)
320 *eax = gpe0_enabled;
321 else {
322 gpe0_enabled = (*eax & gpe0_valid);
323 sci_update(ctx);
324 }
325 pthread_mutex_unlock(&pm_lock);
326 return (0);
327 }
328 INOUT_PORT(gpe0_en, IO_GPE0_EN, IOPORT_F_INOUT, gpe0_en);
329
330 /*
331 * ACPI SMI Command Register
332 *
333 * This write-only register is used to enable and disable ACPI.
334 */
335 static int
smi_cmd_handler(struct vmctx * ctx,int vcpu,int in,int port,int bytes,uint32_t * eax,void * arg)336 smi_cmd_handler(struct vmctx *ctx, int vcpu, int in, int port, int bytes,
337 uint32_t *eax, void *arg)
338 {
339
340 assert(!in);
341 if (bytes != 1)
342 return (-1);
343
344 pthread_mutex_lock(&pm_lock);
345 switch (*eax) {
346 case BHYVE_ACPI_ENABLE:
347 pm1_control |= PM1_SCI_EN;
348 if (power_button == NULL) {
349 power_button = mevent_add(SIGTERM, EVF_SIGNAL,
350 power_button_handler, ctx);
351 old_power_handler = signal(SIGTERM, SIG_IGN);
352 }
353 break;
354 case BHYVE_ACPI_DISABLE:
355 pm1_control &= ~PM1_SCI_EN;
356 if (power_button != NULL) {
357 mevent_delete(power_button);
358 power_button = NULL;
359 signal(SIGTERM, old_power_handler);
360 }
361 break;
362 }
363 pthread_mutex_unlock(&pm_lock);
364 return (0);
365 }
366 INOUT_PORT(smi_cmd, SMI_CMD, IOPORT_F_OUT, smi_cmd_handler);
367 SYSRES_IO(SMI_CMD, 1);
368
369 void
sci_init(struct vmctx * ctx)370 sci_init(struct vmctx *ctx)
371 {
372
373 /*
374 * Mark ACPI's SCI as level trigger and bump its use count
375 * in the PIRQ router.
376 */
377 pci_irq_use(SCI_INT);
378 vm_isa_set_irq_trigger(ctx, SCI_INT, LEVEL_TRIGGER);
379 }
380