linux-user: stack_base is now mandatory on all targets
[qemu.git] / hw / acpi.c
1 /*
2 * ACPI implementation
3 *
4 * Copyright (c) 2006 Fabrice Bellard
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 version 2 as published by the Free Software Foundation.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, see <http://www.gnu.org/licenses/>
17 *
18 * Contributions after 2012-01-13 are licensed under the terms of the
19 * GNU GPL, version 2 or (at your option) any later version.
20 */
21 #include "sysemu.h"
22 #include "hw.h"
23 #include "pc.h"
24 #include "acpi.h"
25
26 struct acpi_table_header {
27 uint16_t _length; /* our length, not actual part of the hdr */
28 /* XXX why we have 2 length fields here? */
29 char sig[4]; /* ACPI signature (4 ASCII characters) */
30 uint32_t length; /* Length of table, in bytes, including header */
31 uint8_t revision; /* ACPI Specification minor version # */
32 uint8_t checksum; /* To make sum of entire table == 0 */
33 char oem_id[6]; /* OEM identification */
34 char oem_table_id[8]; /* OEM table identification */
35 uint32_t oem_revision; /* OEM revision number */
36 char asl_compiler_id[4]; /* ASL compiler vendor ID */
37 uint32_t asl_compiler_revision; /* ASL compiler revision number */
38 } QEMU_PACKED;
39
40 #define ACPI_TABLE_HDR_SIZE sizeof(struct acpi_table_header)
41 #define ACPI_TABLE_PFX_SIZE sizeof(uint16_t) /* size of the extra prefix */
42
43 static const char dfl_hdr[ACPI_TABLE_HDR_SIZE] =
44 "\0\0" /* fake _length (2) */
45 "QEMU\0\0\0\0\1\0" /* sig (4), len(4), revno (1), csum (1) */
46 "QEMUQEQEMUQEMU\1\0\0\0" /* OEM id (6), table (8), revno (4) */
47 "QEMU\1\0\0\0" /* ASL compiler ID (4), version (4) */
48 ;
49
50 char *acpi_tables;
51 size_t acpi_tables_len;
52
53 static int acpi_checksum(const uint8_t *data, int len)
54 {
55 int sum, i;
56 sum = 0;
57 for (i = 0; i < len; i++) {
58 sum += data[i];
59 }
60 return (-sum) & 0xff;
61 }
62
63 /* like strncpy() but zero-fills the tail of destination */
64 static void strzcpy(char *dst, const char *src, size_t size)
65 {
66 size_t len = strlen(src);
67 if (len >= size) {
68 len = size;
69 } else {
70 memset(dst + len, 0, size - len);
71 }
72 memcpy(dst, src, len);
73 }
74
75 /* XXX fixme: this function uses obsolete argument parsing interface */
76 int acpi_table_add(const char *t)
77 {
78 char buf[1024], *p, *f;
79 unsigned long val;
80 size_t len, start, allen;
81 bool has_header;
82 int changed;
83 int r;
84 struct acpi_table_header hdr;
85
86 r = 0;
87 r |= get_param_value(buf, sizeof(buf), "data", t) ? 1 : 0;
88 r |= get_param_value(buf, sizeof(buf), "file", t) ? 2 : 0;
89 switch (r) {
90 case 0:
91 buf[0] = '\0';
92 /* fallthrough for default behavior */
93 case 1:
94 has_header = false;
95 break;
96 case 2:
97 has_header = true;
98 break;
99 default:
100 fprintf(stderr, "acpitable: both data and file are specified\n");
101 return -1;
102 }
103
104 if (!acpi_tables) {
105 allen = sizeof(uint16_t);
106 acpi_tables = g_malloc0(allen);
107 } else {
108 allen = acpi_tables_len;
109 }
110
111 start = allen;
112 acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE);
113 allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE;
114
115 /* now read in the data files, reallocating buffer as needed */
116
117 for (f = strtok(buf, ":"); f; f = strtok(NULL, ":")) {
118 int fd = open(f, O_RDONLY);
119
120 if (fd < 0) {
121 fprintf(stderr, "can't open file %s: %s\n", f, strerror(errno));
122 return -1;
123 }
124
125 for (;;) {
126 char data[8192];
127 r = read(fd, data, sizeof(data));
128 if (r == 0) {
129 break;
130 } else if (r > 0) {
131 acpi_tables = g_realloc(acpi_tables, allen + r);
132 memcpy(acpi_tables + allen, data, r);
133 allen += r;
134 } else if (errno != EINTR) {
135 fprintf(stderr, "can't read file %s: %s\n",
136 f, strerror(errno));
137 close(fd);
138 return -1;
139 }
140 }
141
142 close(fd);
143 }
144
145 /* now fill in the header fields */
146
147 f = acpi_tables + start; /* start of the table */
148 changed = 0;
149
150 /* copy the header to temp place to align the fields */
151 memcpy(&hdr, has_header ? f : dfl_hdr, ACPI_TABLE_HDR_SIZE);
152
153 /* length of the table minus our prefix */
154 len = allen - start - ACPI_TABLE_PFX_SIZE;
155
156 hdr._length = cpu_to_le16(len);
157
158 if (get_param_value(buf, sizeof(buf), "sig", t)) {
159 strzcpy(hdr.sig, buf, sizeof(hdr.sig));
160 ++changed;
161 }
162
163 /* length of the table including header, in bytes */
164 if (has_header) {
165 /* check if actual length is correct */
166 val = le32_to_cpu(hdr.length);
167 if (val != len) {
168 fprintf(stderr,
169 "warning: acpitable has wrong length,"
170 " header says %lu, actual size %zu bytes\n",
171 val, len);
172 ++changed;
173 }
174 }
175 /* we may avoid putting length here if has_header is true */
176 hdr.length = cpu_to_le32(len);
177
178 if (get_param_value(buf, sizeof(buf), "rev", t)) {
179 val = strtoul(buf, &p, 0);
180 if (val > 255 || *p) {
181 fprintf(stderr, "acpitable: \"rev=%s\" is invalid\n", buf);
182 return -1;
183 }
184 hdr.revision = (uint8_t)val;
185 ++changed;
186 }
187
188 if (get_param_value(buf, sizeof(buf), "oem_id", t)) {
189 strzcpy(hdr.oem_id, buf, sizeof(hdr.oem_id));
190 ++changed;
191 }
192
193 if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) {
194 strzcpy(hdr.oem_table_id, buf, sizeof(hdr.oem_table_id));
195 ++changed;
196 }
197
198 if (get_param_value(buf, sizeof(buf), "oem_rev", t)) {
199 val = strtol(buf, &p, 0);
200 if (*p) {
201 fprintf(stderr, "acpitable: \"oem_rev=%s\" is invalid\n", buf);
202 return -1;
203 }
204 hdr.oem_revision = cpu_to_le32(val);
205 ++changed;
206 }
207
208 if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) {
209 strzcpy(hdr.asl_compiler_id, buf, sizeof(hdr.asl_compiler_id));
210 ++changed;
211 }
212
213 if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) {
214 val = strtol(buf, &p, 0);
215 if (*p) {
216 fprintf(stderr, "acpitable: \"%s=%s\" is invalid\n",
217 "asl_compiler_rev", buf);
218 return -1;
219 }
220 hdr.asl_compiler_revision = cpu_to_le32(val);
221 ++changed;
222 }
223
224 if (!has_header && !changed) {
225 fprintf(stderr, "warning: acpitable: no table headers are specified\n");
226 }
227
228
229 /* now calculate checksum of the table, complete with the header */
230 /* we may as well leave checksum intact if has_header is true */
231 /* alternatively there may be a way to set cksum to a given value */
232 hdr.checksum = 0; /* for checksum calculation */
233
234 /* put header back */
235 memcpy(f, &hdr, sizeof(hdr));
236
237 if (changed || !has_header || 1) {
238 ((struct acpi_table_header *)f)->checksum =
239 acpi_checksum((uint8_t *)f + ACPI_TABLE_PFX_SIZE, len);
240 }
241
242 /* increase number of tables */
243 (*(uint16_t *)acpi_tables) =
244 cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1);
245
246 acpi_tables_len = allen;
247 return 0;
248
249 }
250
251 /* ACPI PM1a EVT */
252 uint16_t acpi_pm1_evt_get_sts(ACPIPM1EVT *pm1, int64_t overflow_time)
253 {
254 int64_t d = acpi_pm_tmr_get_clock();
255 if (d >= overflow_time) {
256 pm1->sts |= ACPI_BITMASK_TIMER_STATUS;
257 }
258 return pm1->sts;
259 }
260
261 void acpi_pm1_evt_write_sts(ACPIPM1EVT *pm1, ACPIPMTimer *tmr, uint16_t val)
262 {
263 uint16_t pm1_sts = acpi_pm1_evt_get_sts(pm1, tmr->overflow_time);
264 if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
265 /* if TMRSTS is reset, then compute the new overflow time */
266 acpi_pm_tmr_calc_overflow_time(tmr);
267 }
268 pm1->sts &= ~val;
269 }
270
271 void acpi_pm1_evt_power_down(ACPIPM1EVT *pm1, ACPIPMTimer *tmr)
272 {
273 if (!pm1) {
274 qemu_system_shutdown_request();
275 } else if (pm1->en & ACPI_BITMASK_POWER_BUTTON_ENABLE) {
276 pm1->sts |= ACPI_BITMASK_POWER_BUTTON_STATUS;
277 tmr->update_sci(tmr);
278 }
279 }
280
281 void acpi_pm1_evt_reset(ACPIPM1EVT *pm1)
282 {
283 pm1->sts = 0;
284 pm1->en = 0;
285 }
286
287 /* ACPI PM_TMR */
288 void acpi_pm_tmr_update(ACPIPMTimer *tmr, bool enable)
289 {
290 int64_t expire_time;
291
292 /* schedule a timer interruption if needed */
293 if (enable) {
294 expire_time = muldiv64(tmr->overflow_time, get_ticks_per_sec(),
295 PM_TIMER_FREQUENCY);
296 qemu_mod_timer(tmr->timer, expire_time);
297 } else {
298 qemu_del_timer(tmr->timer);
299 }
300 }
301
302 void acpi_pm_tmr_calc_overflow_time(ACPIPMTimer *tmr)
303 {
304 int64_t d = acpi_pm_tmr_get_clock();
305 tmr->overflow_time = (d + 0x800000LL) & ~0x7fffffLL;
306 }
307
308 uint32_t acpi_pm_tmr_get(ACPIPMTimer *tmr)
309 {
310 uint32_t d = acpi_pm_tmr_get_clock();
311 return d & 0xffffff;
312 }
313
314 static void acpi_pm_tmr_timer(void *opaque)
315 {
316 ACPIPMTimer *tmr = opaque;
317 tmr->update_sci(tmr);
318 }
319
320 void acpi_pm_tmr_init(ACPIPMTimer *tmr, acpi_update_sci_fn update_sci)
321 {
322 tmr->update_sci = update_sci;
323 tmr->timer = qemu_new_timer_ns(vm_clock, acpi_pm_tmr_timer, tmr);
324 }
325
326 void acpi_pm_tmr_reset(ACPIPMTimer *tmr)
327 {
328 tmr->overflow_time = 0;
329 qemu_del_timer(tmr->timer);
330 }
331
332 /* ACPI PM1aCNT */
333 void acpi_pm1_cnt_init(ACPIPM1CNT *pm1_cnt, qemu_irq cmos_s3)
334 {
335 pm1_cnt->cmos_s3 = cmos_s3;
336 }
337
338 void acpi_pm1_cnt_write(ACPIPM1EVT *pm1a, ACPIPM1CNT *pm1_cnt, uint16_t val)
339 {
340 pm1_cnt->cnt = val & ~(ACPI_BITMASK_SLEEP_ENABLE);
341
342 if (val & ACPI_BITMASK_SLEEP_ENABLE) {
343 /* change suspend type */
344 uint16_t sus_typ = (val >> 10) & 7;
345 switch(sus_typ) {
346 case 0: /* soft power off */
347 qemu_system_shutdown_request();
348 break;
349 case 1:
350 /* ACPI_BITMASK_WAKE_STATUS should be set on resume.
351 Pretend that resume was caused by power button */
352 pm1a->sts |=
353 (ACPI_BITMASK_WAKE_STATUS | ACPI_BITMASK_POWER_BUTTON_STATUS);
354 qemu_system_reset_request();
355 qemu_irq_raise(pm1_cnt->cmos_s3);
356 default:
357 break;
358 }
359 }
360 }
361
362 void acpi_pm1_cnt_update(ACPIPM1CNT *pm1_cnt,
363 bool sci_enable, bool sci_disable)
364 {
365 /* ACPI specs 3.0, 4.7.2.5 */
366 if (sci_enable) {
367 pm1_cnt->cnt |= ACPI_BITMASK_SCI_ENABLE;
368 } else if (sci_disable) {
369 pm1_cnt->cnt &= ~ACPI_BITMASK_SCI_ENABLE;
370 }
371 }
372
373 void acpi_pm1_cnt_reset(ACPIPM1CNT *pm1_cnt)
374 {
375 pm1_cnt->cnt = 0;
376 if (pm1_cnt->cmos_s3) {
377 qemu_irq_lower(pm1_cnt->cmos_s3);
378 }
379 }
380
381 /* ACPI GPE */
382 void acpi_gpe_init(ACPIGPE *gpe, uint8_t len)
383 {
384 gpe->len = len;
385 gpe->sts = g_malloc0(len / 2);
386 gpe->en = g_malloc0(len / 2);
387 }
388
389 void acpi_gpe_blk(ACPIGPE *gpe, uint32_t blk)
390 {
391 gpe->blk = blk;
392 }
393
394 void acpi_gpe_reset(ACPIGPE *gpe)
395 {
396 memset(gpe->sts, 0, gpe->len / 2);
397 memset(gpe->en, 0, gpe->len / 2);
398 }
399
400 static uint8_t *acpi_gpe_ioport_get_ptr(ACPIGPE *gpe, uint32_t addr)
401 {
402 uint8_t *cur = NULL;
403
404 if (addr < gpe->len / 2) {
405 cur = gpe->sts + addr;
406 } else if (addr < gpe->len) {
407 cur = gpe->en + addr - gpe->len / 2;
408 } else {
409 abort();
410 }
411
412 return cur;
413 }
414
415 void acpi_gpe_ioport_writeb(ACPIGPE *gpe, uint32_t addr, uint32_t val)
416 {
417 uint8_t *cur;
418
419 addr -= gpe->blk;
420 cur = acpi_gpe_ioport_get_ptr(gpe, addr);
421 if (addr < gpe->len / 2) {
422 /* GPE_STS */
423 *cur = (*cur) & ~val;
424 } else if (addr < gpe->len) {
425 /* GPE_EN */
426 *cur = val;
427 } else {
428 abort();
429 }
430 }
431
432 uint32_t acpi_gpe_ioport_readb(ACPIGPE *gpe, uint32_t addr)
433 {
434 uint8_t *cur;
435 uint32_t val;
436
437 addr -= gpe->blk;
438 cur = acpi_gpe_ioport_get_ptr(gpe, addr);
439 val = 0;
440 if (cur != NULL) {
441 val = *cur;
442 }
443
444 return val;
445 }