File: | dev/acpi/acpi.c |
Warning: | line 2766, column 2 Value stored to 's' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: acpi.c,v 1.404 2022/01/04 13:40:58 patrick Exp $ */ |
2 | /* |
3 | * Copyright (c) 2005 Thorsten Lockert <tholo@sigmasoft.com> |
4 | * Copyright (c) 2005 Jordan Hargrave <jordan@openbsd.org> |
5 | * |
6 | * Permission to use, copy, modify, and distribute this software for any |
7 | * purpose with or without fee is hereby granted, provided that the above |
8 | * copyright notice and this permission notice appear in all copies. |
9 | * |
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
17 | */ |
18 | |
19 | #include <sys/param.h> |
20 | #include <sys/systm.h> |
21 | #include <sys/buf.h> |
22 | #include <sys/device.h> |
23 | #include <sys/malloc.h> |
24 | #include <sys/fcntl.h> |
25 | #include <sys/ioccom.h> |
26 | #include <sys/event.h> |
27 | #include <sys/signalvar.h> |
28 | #include <sys/proc.h> |
29 | #include <sys/kthread.h> |
30 | #include <sys/sched.h> |
31 | #include <sys/reboot.h> |
32 | #include <sys/sysctl.h> |
33 | #include <sys/mount.h> |
34 | #include <sys/syscallargs.h> |
35 | #include <sys/sensors.h> |
36 | #include <sys/timetc.h> |
37 | |
38 | #ifdef HIBERNATE1 |
39 | #include <sys/hibernate.h> |
40 | #endif |
41 | |
42 | #include <machine/conf.h> |
43 | #include <machine/cpufunc.h> |
44 | #include <machine/bus.h> |
45 | |
46 | #include <dev/pci/pcivar.h> |
47 | #include <dev/acpi/acpireg.h> |
48 | #include <dev/acpi/acpivar.h> |
49 | #include <dev/acpi/amltypes.h> |
50 | #include <dev/acpi/acpidev.h> |
51 | #include <dev/acpi/dsdt.h> |
52 | #include <dev/wscons/wsdisplayvar.h> |
53 | |
54 | #include <dev/pci/pcidevs.h> |
55 | #include <dev/pci/ppbreg.h> |
56 | |
57 | #include <dev/pci/pciidevar.h> |
58 | |
59 | #include <machine/apmvar.h> |
60 | #define APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) (minor(dev)((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) |
61 | #define APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0x0f) (minor(dev)((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0x0f) |
62 | #define APMDEV_NORMAL0 0 |
63 | #define APMDEV_CTL8 8 |
64 | |
65 | #include "wd.h" |
66 | #include "wsdisplay.h" |
67 | #include "softraid.h" |
68 | |
69 | #ifdef ACPI_DEBUG |
70 | int acpi_debug = 16; |
71 | #endif |
72 | |
73 | int acpi_poll_enabled; |
74 | int acpi_hasprocfvs; |
75 | int acpi_haspci; |
76 | |
77 | #define ACPIEN_RETRIES15 15 |
78 | |
79 | struct aml_node *acpi_pci_match(struct device *, struct pci_attach_args *); |
80 | pcireg_t acpi_pci_min_powerstate(pci_chipset_tag_t, pcitag_t); |
81 | void acpi_pci_set_powerstate(pci_chipset_tag_t, pcitag_t, int, int); |
82 | int acpi_pci_notify(struct aml_node *, int, void *); |
83 | |
84 | int acpi_submatch(struct device *, void *, void *); |
85 | int acpi_print(void *, const char *); |
86 | |
87 | void acpi_map_pmregs(struct acpi_softc *); |
88 | void acpi_unmap_pmregs(struct acpi_softc *); |
89 | |
90 | int acpi_loadtables(struct acpi_softc *, struct acpi_rsdp *); |
91 | |
92 | int _acpi_matchhids(const char *, const char *[]); |
93 | |
94 | int acpi_inidev(struct aml_node *, void *); |
95 | int acpi_foundprt(struct aml_node *, void *); |
96 | |
97 | int acpi_enable(struct acpi_softc *); |
98 | void acpi_init_states(struct acpi_softc *); |
99 | |
100 | void acpi_gpe_task(void *, int); |
101 | void acpi_sbtn_task(void *, int); |
102 | void acpi_pbtn_task(void *, int); |
103 | |
104 | int acpi_enabled; |
105 | |
106 | void acpi_init_gpes(struct acpi_softc *); |
107 | void acpi_disable_allgpes(struct acpi_softc *); |
108 | struct gpe_block *acpi_find_gpe(struct acpi_softc *, int); |
109 | void acpi_enable_onegpe(struct acpi_softc *, int); |
110 | int acpi_gpe(struct acpi_softc *, int, void *); |
111 | |
112 | void acpi_enable_rungpes(struct acpi_softc *); |
113 | void acpi_enable_wakegpes(struct acpi_softc *, int); |
114 | |
115 | |
116 | int acpi_foundec(struct aml_node *, void *); |
117 | int acpi_foundsony(struct aml_node *node, void *arg); |
118 | int acpi_foundhid(struct aml_node *, void *); |
119 | int acpi_add_device(struct aml_node *node, void *arg); |
120 | |
121 | void acpi_thread(void *); |
122 | void acpi_create_thread(void *); |
123 | |
124 | #ifndef SMALL_KERNEL |
125 | |
126 | void acpi_indicator(struct acpi_softc *, int); |
127 | |
128 | void acpi_init_pm(struct acpi_softc *); |
129 | |
130 | int acpi_founddock(struct aml_node *, void *); |
131 | int acpi_foundpss(struct aml_node *, void *); |
132 | int acpi_foundtmp(struct aml_node *, void *); |
133 | int acpi_foundprw(struct aml_node *, void *); |
134 | int acpi_foundvideo(struct aml_node *, void *); |
135 | int acpi_foundsbs(struct aml_node *node, void *); |
136 | |
137 | int acpi_foundide(struct aml_node *node, void *arg); |
138 | int acpiide_notify(struct aml_node *, int, void *); |
139 | void wdcattach(struct channel_softc *); |
140 | int wdcdetach(struct channel_softc *, int); |
141 | int is_ejectable_bay(struct aml_node *node); |
142 | int is_ata(struct aml_node *node); |
143 | int is_ejectable(struct aml_node *node); |
144 | |
145 | struct idechnl { |
146 | struct acpi_softc *sc; |
147 | int64_t addr; |
148 | int64_t chnl; |
149 | int64_t sta; |
150 | }; |
151 | |
152 | /* |
153 | * This is a list of Synaptics devices with a 'top button area' |
154 | * based on the list in Linux supplied by Synaptics |
155 | * Synaptics clickpads with the following pnp ids will get a unique |
156 | * wscons mouse type that is used to define trackpad regions that will |
157 | * emulate mouse buttons |
158 | */ |
159 | static const char *sbtn_pnp[] = { |
160 | "LEN0017", |
161 | "LEN0018", |
162 | "LEN0019", |
163 | "LEN0023", |
164 | "LEN002A", |
165 | "LEN002B", |
166 | "LEN002C", |
167 | "LEN002D", |
168 | "LEN002E", |
169 | "LEN0033", |
170 | "LEN0034", |
171 | "LEN0035", |
172 | "LEN0036", |
173 | "LEN0037", |
174 | "LEN0038", |
175 | "LEN0039", |
176 | "LEN0041", |
177 | "LEN0042", |
178 | "LEN0045", |
179 | "LEN0047", |
180 | "LEN0049", |
181 | "LEN2000", |
182 | "LEN2001", |
183 | "LEN2002", |
184 | "LEN2003", |
185 | "LEN2004", |
186 | "LEN2005", |
187 | "LEN2006", |
188 | "LEN2007", |
189 | "LEN2008", |
190 | "LEN2009", |
191 | "LEN200A", |
192 | "LEN200B", |
193 | }; |
194 | |
195 | int mouse_has_softbtn; |
196 | #endif /* SMALL_KERNEL */ |
197 | |
198 | struct acpi_softc *acpi_softc; |
199 | |
200 | /* XXX move this into dsdt softc at some point */ |
201 | extern struct aml_node aml_root; |
202 | |
203 | struct cfdriver acpi_cd = { |
204 | NULL((void *)0), "acpi", DV_DULL |
205 | }; |
206 | |
207 | uint8_t |
208 | acpi_pci_conf_read_1(pci_chipset_tag_t pc, pcitag_t tag, int reg) |
209 | { |
210 | uint32_t val = pci_conf_read(pc, tag, reg & ~0x3); |
211 | return (val >> ((reg & 0x3) << 3)); |
212 | } |
213 | |
214 | uint16_t |
215 | acpi_pci_conf_read_2(pci_chipset_tag_t pc, pcitag_t tag, int reg) |
216 | { |
217 | uint32_t val = pci_conf_read(pc, tag, reg & ~0x2); |
218 | return (val >> ((reg & 0x2) << 3)); |
219 | } |
220 | |
221 | uint32_t |
222 | acpi_pci_conf_read_4(pci_chipset_tag_t pc, pcitag_t tag, int reg) |
223 | { |
224 | return pci_conf_read(pc, tag, reg); |
225 | } |
226 | |
227 | void |
228 | acpi_pci_conf_write_1(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint8_t val) |
229 | { |
230 | uint32_t tmp = pci_conf_read(pc, tag, reg & ~0x3); |
231 | tmp &= ~(0xff << ((reg & 0x3) << 3)); |
232 | tmp |= (val << ((reg & 0x3) << 3)); |
233 | pci_conf_write(pc, tag, reg & ~0x3, tmp); |
234 | } |
235 | |
236 | void |
237 | acpi_pci_conf_write_2(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint16_t val) |
238 | { |
239 | uint32_t tmp = pci_conf_read(pc, tag, reg & ~0x2); |
240 | tmp &= ~(0xffff << ((reg & 0x2) << 3)); |
241 | tmp |= (val << ((reg & 0x2) << 3)); |
242 | pci_conf_write(pc, tag, reg & ~0x2, tmp); |
243 | } |
244 | |
245 | void |
246 | acpi_pci_conf_write_4(pci_chipset_tag_t pc, pcitag_t tag, int reg, uint32_t val) |
247 | { |
248 | pci_conf_write(pc, tag, reg, val); |
249 | } |
250 | |
251 | int |
252 | acpi_gasio(struct acpi_softc *sc, int iodir, int iospace, uint64_t address, |
253 | int access_size, int len, void *buffer) |
254 | { |
255 | uint8_t *pb; |
256 | bus_space_tag_t iot; |
257 | bus_space_handle_t ioh; |
258 | pci_chipset_tag_t pc; |
259 | pcitag_t tag; |
260 | int reg, idx; |
261 | |
262 | dnprintf(50, "gasio: %.2x 0x%.8llx %s\n", |
263 | iospace, address, (iodir == ACPI_IOWRITE) ? "write" : "read"); |
264 | |
265 | KASSERT((len % access_size) == 0)(((len % access_size) == 0) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/acpi/acpi.c", 265, "(len % access_size) == 0" )); |
266 | |
267 | pb = (uint8_t *)buffer; |
268 | switch (iospace) { |
269 | case GAS_SYSTEM_MEMORY0: |
270 | case GAS_SYSTEM_IOSPACE1: |
271 | if (iospace == GAS_SYSTEM_MEMORY0) |
272 | iot = sc->sc_memt; |
273 | else |
274 | iot = sc->sc_iot; |
275 | |
276 | if (acpi_bus_space_map(iot, address, len, 0, &ioh) != 0) { |
277 | printf("%s: unable to map iospace\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
278 | return (-1); |
279 | } |
280 | for (reg = 0; reg < len; reg += access_size) { |
281 | if (iodir == ACPI_IOREAD0) { |
282 | switch (access_size) { |
283 | case 1: |
284 | *(uint8_t *)(pb + reg) = |
285 | bus_space_read_1(iot, ioh, reg)((iot)->read_1((ioh), (reg))); |
286 | dnprintf(80, "os_in8(%llx) = %x\n", |
287 | reg+address, *(uint8_t *)(pb+reg)); |
288 | break; |
289 | case 2: |
290 | *(uint16_t *)(pb + reg) = |
291 | bus_space_read_2(iot, ioh, reg)((iot)->read_2((ioh), (reg))); |
292 | dnprintf(80, "os_in16(%llx) = %x\n", |
293 | reg+address, *(uint16_t *)(pb+reg)); |
294 | break; |
295 | case 4: |
296 | *(uint32_t *)(pb + reg) = |
297 | bus_space_read_4(iot, ioh, reg)((iot)->read_4((ioh), (reg))); |
298 | break; |
299 | default: |
300 | printf("%s: rdio: invalid size %d\n", |
301 | DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size); |
302 | return (-1); |
303 | } |
304 | } else { |
305 | switch (access_size) { |
306 | case 1: |
307 | bus_space_write_1(iot, ioh, reg,((iot)->write_1((ioh), (reg), (*(uint8_t *)(pb + reg)))) |
308 | *(uint8_t *)(pb + reg))((iot)->write_1((ioh), (reg), (*(uint8_t *)(pb + reg)))); |
309 | dnprintf(80, "os_out8(%llx,%x)\n", |
310 | reg+address, *(uint8_t *)(pb+reg)); |
311 | break; |
312 | case 2: |
313 | bus_space_write_2(iot, ioh, reg,((iot)->write_2((ioh), (reg), (*(uint16_t *)(pb + reg)))) |
314 | *(uint16_t *)(pb + reg))((iot)->write_2((ioh), (reg), (*(uint16_t *)(pb + reg)))); |
315 | dnprintf(80, "os_out16(%llx,%x)\n", |
316 | reg+address, *(uint16_t *)(pb+reg)); |
317 | break; |
318 | case 4: |
319 | bus_space_write_4(iot, ioh, reg,((iot)->write_4((ioh), (reg), (*(uint32_t *)(pb + reg)))) |
320 | *(uint32_t *)(pb + reg))((iot)->write_4((ioh), (reg), (*(uint32_t *)(pb + reg)))); |
321 | break; |
322 | default: |
323 | printf("%s: wrio: invalid size %d\n", |
324 | DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size); |
325 | return (-1); |
326 | } |
327 | } |
328 | } |
329 | acpi_bus_space_unmap(iot, ioh, len); |
330 | break; |
331 | |
332 | case GAS_PCI_CFG_SPACE2: |
333 | /* |
334 | * The ACPI standard says that a function number of |
335 | * FFFF can be used to refer to all functions on a |
336 | * device. This makes no sense though in the context |
337 | * of accessing PCI config space. Yet there is AML |
338 | * out there that does this. We simulate a read from |
339 | * a nonexistent device here. Writes will panic when |
340 | * we try to construct the tag below. |
341 | */ |
342 | if (ACPI_PCI_FN(address)(uint16_t)((address) >> 16) == 0xffff && iodir == ACPI_IOREAD0) { |
343 | memset(buffer, 0xff, len)__builtin_memset((buffer), (0xff), (len)); |
344 | return (0); |
345 | } |
346 | |
347 | pc = pci_lookup_segment(ACPI_PCI_SEG(address)(uint16_t)((address) >> 48)); |
348 | tag = pci_make_tag(pc, |
349 | ACPI_PCI_BUS(address)(uint8_t)((address) >> 40), ACPI_PCI_DEV(address)(uint8_t)((address) >> 32), |
350 | ACPI_PCI_FN(address)(uint16_t)((address) >> 16)); |
351 | |
352 | reg = ACPI_PCI_REG(address)(uint16_t)(address); |
353 | for (idx = 0; idx < len; idx += access_size) { |
354 | if (iodir == ACPI_IOREAD0) { |
355 | switch (access_size) { |
356 | case 1: |
357 | *(uint8_t *)(pb + idx) = |
358 | acpi_pci_conf_read_1(pc, tag, reg + idx); |
359 | break; |
360 | case 2: |
361 | *(uint16_t *)(pb + idx) = |
362 | acpi_pci_conf_read_2(pc, tag, reg + idx); |
363 | break; |
364 | case 4: |
365 | *(uint32_t *)(pb + idx) = |
366 | acpi_pci_conf_read_4(pc, tag, reg + idx); |
367 | break; |
368 | default: |
369 | printf("%s: rdcfg: invalid size %d\n", |
370 | DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size); |
371 | return (-1); |
372 | } |
373 | } else { |
374 | switch (access_size) { |
375 | case 1: |
376 | acpi_pci_conf_write_1(pc, tag, reg + idx, |
377 | *(uint8_t *)(pb + idx)); |
378 | break; |
379 | case 2: |
380 | acpi_pci_conf_write_2(pc, tag, reg + idx, |
381 | *(uint16_t *)(pb + idx)); |
382 | break; |
383 | case 4: |
384 | acpi_pci_conf_write_4(pc, tag, reg + idx, |
385 | *(uint32_t *)(pb + idx)); |
386 | break; |
387 | default: |
388 | printf("%s: wrcfg: invalid size %d\n", |
389 | DEVNAME(sc)((sc)->sc_dev.dv_xname), access_size); |
390 | return (-1); |
391 | } |
392 | } |
393 | } |
394 | break; |
395 | |
396 | case GAS_EMBEDDED3: |
397 | if (sc->sc_ec == NULL((void *)0)) { |
398 | printf("%s: WARNING EC not initialized\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
399 | return (-1); |
400 | } |
401 | if (iodir == ACPI_IOREAD0) |
402 | acpiec_read(sc->sc_ec, (uint8_t)address, len, buffer); |
403 | else |
404 | acpiec_write(sc->sc_ec, (uint8_t)address, len, buffer); |
405 | break; |
406 | } |
407 | return (0); |
408 | } |
409 | |
410 | int |
411 | acpi_inidev(struct aml_node *node, void *arg) |
412 | { |
413 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
414 | int64_t sta; |
415 | |
416 | /* |
417 | * Per the ACPI spec 6.5.1, only run _INI when device is there or |
418 | * when there is no _STA. We terminate the tree walk (with return 1) |
419 | * early if necessary. |
420 | */ |
421 | |
422 | /* Evaluate _STA to decide _INI fate and walk fate */ |
423 | sta = acpi_getsta(sc, node->parent); |
424 | |
425 | /* Evaluate _INI if we are present */ |
426 | if (sta & STA_PRESENT(1L << 0)) |
427 | aml_evalnode(sc, node, 0, NULL((void *)0), NULL((void *)0)); |
428 | |
429 | /* If we are functioning, we walk/search our children */ |
430 | if (sta & STA_DEV_OK(1L << 3)) |
431 | return 0; |
432 | |
433 | /* If we are not enabled, or not present, terminate search */ |
434 | if (!(sta & (STA_PRESENT(1L << 0)|STA_ENABLED(1L << 1)))) |
435 | return 1; |
436 | |
437 | /* Default just continue search */ |
438 | return 0; |
439 | } |
440 | |
441 | int |
442 | acpi_foundprt(struct aml_node *node, void *arg) |
443 | { |
444 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
445 | struct device *self = (struct device *)arg; |
446 | struct acpi_attach_args aaa; |
447 | int64_t sta; |
448 | |
449 | dnprintf(10, "found prt entry: %s\n", node->parent->name); |
450 | |
451 | /* Evaluate _STA to decide _PRT fate and walk fate */ |
452 | sta = acpi_getsta(sc, node->parent); |
453 | if (sta & STA_PRESENT(1L << 0)) { |
454 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
455 | aaa.aaa_iot = sc->sc_iot; |
456 | aaa.aaa_memt = sc->sc_memt; |
457 | aaa.aaa_node = node; |
458 | aaa.aaa_name = "acpiprt"; |
459 | |
460 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
461 | } |
462 | |
463 | /* If we are functioning, we walk/search our children */ |
464 | if (sta & STA_DEV_OK(1L << 3)) |
465 | return 0; |
466 | |
467 | /* If we are not enabled, or not present, terminate search */ |
468 | if (!(sta & (STA_PRESENT(1L << 0)|STA_ENABLED(1L << 1)))) |
469 | return 1; |
470 | |
471 | /* Default just continue search */ |
472 | return 0; |
473 | } |
474 | |
475 | TAILQ_HEAD(, acpi_pci)struct { struct acpi_pci *tqh_first; struct acpi_pci **tqh_last ; } acpi_pcidevs = |
476 | TAILQ_HEAD_INITIALIZER(acpi_pcidevs){ ((void *)0), &(acpi_pcidevs).tqh_first }; |
477 | TAILQ_HEAD(, acpi_pci)struct { struct acpi_pci *tqh_first; struct acpi_pci **tqh_last ; } acpi_pcirootdevs = |
478 | TAILQ_HEAD_INITIALIZER(acpi_pcirootdevs){ ((void *)0), &(acpi_pcirootdevs).tqh_first }; |
479 | |
480 | int acpi_getpci(struct aml_node *node, void *arg); |
481 | int acpi_getminbus(int crsidx, union acpi_resource *crs, void *arg); |
482 | |
483 | int |
484 | acpi_getminbus(int crsidx, union acpi_resource *crs, void *arg) |
485 | { |
486 | int *bbn = arg; |
487 | int typ = AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode : (crs)->hdr.typecode >> 3); |
488 | |
489 | /* Check for embedded bus number */ |
490 | if (typ == LR_WORD0x88 && crs->lr_word.type == 2) { |
491 | /* If _MIN > _MAX, the resource is considered to be invalid. */ |
492 | if (crs->lr_word._min > crs->lr_word._max) |
493 | return -1; |
494 | *bbn = crs->lr_word._min; |
495 | } |
496 | return 0; |
497 | } |
498 | |
499 | int |
500 | acpi_matchcls(struct acpi_attach_args *aaa, int class, int subclass, |
501 | int interface) |
502 | { |
503 | struct acpi_softc *sc = acpi_softc; |
504 | struct aml_value res; |
505 | |
506 | if (aaa->aaa_dev == NULL((void *)0) || aaa->aaa_node == NULL((void *)0)) |
507 | return (0); |
508 | |
509 | if (aml_evalname(sc, aaa->aaa_node, "_CLS", 0, NULL((void *)0), &res)) |
510 | return (0); |
511 | |
512 | if (res.type != AML_OBJTYPE_PACKAGE || res.length != 3 || |
513 | res.v_package_.vpackage[0]->type != AML_OBJTYPE_INTEGER || |
514 | res.v_package_.vpackage[1]->type != AML_OBJTYPE_INTEGER || |
515 | res.v_package_.vpackage[2]->type != AML_OBJTYPE_INTEGER) |
516 | return (0); |
517 | |
518 | if (res.v_package_.vpackage[0]->v_integer_.vinteger == class && |
519 | res.v_package_.vpackage[1]->v_integer_.vinteger == subclass && |
520 | res.v_package_.vpackage[2]->v_integer_.vinteger == interface) |
521 | return (1); |
522 | |
523 | return (0); |
524 | } |
525 | |
526 | int |
527 | _acpi_matchhids(const char *hid, const char *hids[]) |
528 | { |
529 | int i; |
530 | |
531 | for (i = 0; hids[i]; i++) |
532 | if (!strcmp(hid, hids[i])) |
533 | return (1); |
534 | return (0); |
535 | } |
536 | |
537 | int |
538 | acpi_matchhids(struct acpi_attach_args *aa, const char *hids[], |
539 | const char *driver) |
540 | { |
541 | if (aa->aaa_dev == NULL((void *)0) || aa->aaa_node == NULL((void *)0)) |
542 | return (0); |
543 | |
544 | if (_acpi_matchhids(aa->aaa_dev, hids)) { |
545 | dnprintf(5, "driver %s matches at least one hid\n", driver); |
546 | return (2); |
547 | } |
548 | if (aa->aaa_cdev && _acpi_matchhids(aa->aaa_cdev, hids)) { |
549 | dnprintf(5, "driver %s matches at least one cid\n", driver); |
550 | return (1); |
551 | } |
552 | |
553 | return (0); |
554 | } |
555 | |
556 | int64_t |
557 | acpi_getsta(struct acpi_softc *sc, struct aml_node *node) |
558 | { |
559 | int64_t sta; |
560 | |
561 | if (aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &sta)) |
562 | sta = STA_PRESENT(1L << 0) | STA_ENABLED(1L << 1) | STA_SHOW_UI(1L << 2) | |
563 | STA_DEV_OK(1L << 3) | STA_BATTERY(1L << 4); |
564 | |
565 | return sta; |
566 | } |
567 | |
568 | /* Map ACPI device node to PCI */ |
569 | int |
570 | acpi_getpci(struct aml_node *node, void *arg) |
571 | { |
572 | const char *pcihid[] = { ACPI_DEV_PCIB"PNP0A03", ACPI_DEV_PCIEB"PNP0A08", "HWP0002", 0 }; |
573 | struct acpi_pci *pci, *ppci; |
574 | struct aml_value res; |
575 | struct acpi_softc *sc = arg; |
576 | pci_chipset_tag_t pc; |
577 | pcitag_t tag; |
578 | uint64_t val; |
579 | int64_t sta; |
580 | uint32_t reg; |
581 | |
582 | sta = acpi_getsta(sc, node); |
583 | if ((sta & STA_PRESENT(1L << 0)) == 0) |
584 | return 0; |
585 | |
586 | if (!node->value || node->value->type != AML_OBJTYPE_DEVICE) |
587 | return 0; |
588 | if (!aml_evalhid(node, &res)) { |
589 | /* Check if this is a PCI Root node */ |
590 | if (_acpi_matchhids(res.v_string_.vstring, pcihid)) { |
591 | aml_freevalue(&res); |
592 | |
593 | pci = malloc(sizeof(*pci), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008); |
594 | |
595 | pci->bus = -1; |
596 | if (!aml_evalinteger(sc, node, "_SEG", 0, NULL((void *)0), &val)) |
597 | pci->seg = val; |
598 | if (!aml_evalname(sc, node, "_CRS", 0, NULL((void *)0), &res)) { |
599 | aml_parse_resource(&res, acpi_getminbus, |
600 | &pci->bus); |
601 | dnprintf(10, "%s post-crs: %d\n", |
602 | aml_nodename(node), pci->bus); |
603 | } |
604 | if (!aml_evalinteger(sc, node, "_BBN", 0, NULL((void *)0), &val)) { |
605 | dnprintf(10, "%s post-bbn: %d, %lld\n", |
606 | aml_nodename(node), pci->bus, val); |
607 | if (pci->bus == -1) |
608 | pci->bus = val; |
609 | } |
610 | pci->sub = pci->bus; |
611 | node->pci = pci; |
612 | dnprintf(10, "found PCI root: %s %d\n", |
613 | aml_nodename(node), pci->bus); |
614 | TAILQ_INSERT_TAIL(&acpi_pcirootdevs, pci, next)do { (pci)->next.tqe_next = ((void *)0); (pci)->next.tqe_prev = (&acpi_pcirootdevs)->tqh_last; *(&acpi_pcirootdevs )->tqh_last = (pci); (&acpi_pcirootdevs)->tqh_last = &(pci)->next.tqe_next; } while (0); |
615 | } |
616 | aml_freevalue(&res); |
617 | return 0; |
618 | } |
619 | |
620 | /* If parent is not PCI, or device does not have _ADR, return */ |
621 | if (!node->parent || (ppci = node->parent->pci) == NULL((void *)0)) |
622 | return 0; |
623 | if (aml_evalinteger(sc, node, "_ADR", 0, NULL((void *)0), &val)) |
624 | return 0; |
625 | |
626 | pci = malloc(sizeof(*pci), M_DEVBUF2, M_WAITOK0x0001|M_ZERO0x0008); |
627 | pci->seg = ppci->seg; |
628 | pci->bus = ppci->sub; |
629 | pci->dev = ACPI_ADR_PCIDEV(val)(uint16_t)(val >> 16); |
630 | pci->fun = ACPI_ADR_PCIFUN(val)(uint16_t)(val & 0xFFFF); |
631 | pci->node = node; |
632 | pci->sub = -1; |
633 | |
634 | dnprintf(10, "%.2x:%.2x.%x -> %s\n", |
635 | pci->bus, pci->dev, pci->fun, |
636 | aml_nodename(node)); |
637 | |
638 | /* Collect device power state information. */ |
639 | if (aml_evalinteger(sc, node, "_S3D", 0, NULL((void *)0), &val) == 0) |
640 | pci->_s3d = val; |
641 | else |
642 | pci->_s3d = -1; |
643 | if (aml_evalinteger(sc, node, "_S3W", 0, NULL((void *)0), &val) == 0) |
644 | pci->_s3w = val; |
645 | else |
646 | pci->_s3w = -1; |
647 | if (aml_evalinteger(sc, node, "_S4D", 0, NULL((void *)0), &val) == 0) |
648 | pci->_s4d = val; |
649 | else |
650 | pci->_s4d = -1; |
651 | if (aml_evalinteger(sc, node, "_S4W", 0, NULL((void *)0), &val) == 0) |
652 | pci->_s4w = val; |
653 | else |
654 | pci->_s4w = -1; |
655 | |
656 | /* Check if PCI device exists */ |
657 | if (pci->dev > 0x1F || pci->fun > 7) { |
658 | free(pci, M_DEVBUF2, sizeof(*pci)); |
659 | return (1); |
660 | } |
661 | pc = pci_lookup_segment(pci->seg); |
662 | tag = pci_make_tag(pc, pci->bus, pci->dev, pci->fun); |
663 | reg = pci_conf_read(pc, tag, PCI_ID_REG0x00); |
664 | if (PCI_VENDOR(reg)(((reg) >> 0) & 0xffff) == PCI_VENDOR_INVALID0xffff) { |
665 | free(pci, M_DEVBUF2, sizeof(*pci)); |
666 | return (1); |
667 | } |
668 | node->pci = pci; |
669 | |
670 | TAILQ_INSERT_TAIL(&acpi_pcidevs, pci, next)do { (pci)->next.tqe_next = ((void *)0); (pci)->next.tqe_prev = (&acpi_pcidevs)->tqh_last; *(&acpi_pcidevs)-> tqh_last = (pci); (&acpi_pcidevs)->tqh_last = &(pci )->next.tqe_next; } while (0); |
671 | |
672 | /* Check if this is a PCI bridge */ |
673 | reg = pci_conf_read(pc, tag, PCI_CLASS_REG0x08); |
674 | if (PCI_CLASS(reg)(((reg) >> 24) & 0xff) == PCI_CLASS_BRIDGE0x06 && |
675 | PCI_SUBCLASS(reg)(((reg) >> 16) & 0xff) == PCI_SUBCLASS_BRIDGE_PCI0x04) { |
676 | reg = pci_conf_read(pc, tag, PPB_REG_BUSINFO0x18); |
677 | pci->sub = PPB_BUSINFO_SECONDARY(reg)((reg >> 8) & 0xff); |
678 | |
679 | dnprintf(10, "found PCI bridge: %s %d\n", |
680 | aml_nodename(node), pci->sub); |
681 | |
682 | /* Continue scanning */ |
683 | return (0); |
684 | } |
685 | |
686 | /* Device does not have children, stop scanning */ |
687 | return (1); |
688 | } |
689 | |
690 | struct aml_node * |
691 | acpi_find_pci(pci_chipset_tag_t pc, pcitag_t tag) |
692 | { |
693 | struct acpi_pci *pdev; |
694 | int bus, dev, fun; |
695 | |
696 | pci_decompose_tag(pc, tag, &bus, &dev, &fun); |
697 | TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != ( (void *)0); (pdev) = ((pdev)->next.tqe_next)) { |
698 | if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun) |
699 | return pdev->node; |
700 | } |
701 | |
702 | return NULL((void *)0); |
703 | } |
704 | |
705 | struct aml_node * |
706 | acpi_pci_match(struct device *dev, struct pci_attach_args *pa) |
707 | { |
708 | struct acpi_pci *pdev; |
709 | int state; |
710 | |
711 | TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != ( (void *)0); (pdev) = ((pdev)->next.tqe_next)) { |
712 | if (pdev->bus != pa->pa_bus || |
713 | pdev->dev != pa->pa_device || |
714 | pdev->fun != pa->pa_function) |
715 | continue; |
716 | |
717 | dnprintf(10,"%s at acpi0 %s\n", dev->dv_xname, |
718 | aml_nodename(pdev->node)); |
719 | |
720 | pdev->device = dev; |
721 | |
722 | /* |
723 | * If some Power Resources are dependent on this device |
724 | * initialize them. |
725 | */ |
726 | state = pci_get_powerstate(pa->pa_pc, pa->pa_tag); |
727 | acpi_pci_set_powerstate(pa->pa_pc, pa->pa_tag, state, 1); |
728 | acpi_pci_set_powerstate(pa->pa_pc, pa->pa_tag, state, 0); |
729 | |
730 | aml_register_notify(pdev->node, NULL((void *)0), acpi_pci_notify, pdev, 0); |
731 | |
732 | return pdev->node; |
733 | } |
734 | |
735 | return NULL((void *)0); |
736 | } |
737 | |
738 | pcireg_t |
739 | acpi_pci_min_powerstate(pci_chipset_tag_t pc, pcitag_t tag) |
740 | { |
741 | struct acpi_pci *pdev; |
742 | int bus, dev, fun; |
743 | int state = -1, defaultstate = pci_get_powerstate(pc, tag); |
744 | |
745 | pci_decompose_tag(pc, tag, &bus, &dev, &fun); |
746 | TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != ( (void *)0); (pdev) = ((pdev)->next.tqe_next)) { |
747 | if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun) { |
748 | switch (acpi_softc->sc_state) { |
749 | case ACPI_STATE_S33: |
750 | defaultstate = PCI_PMCSR_STATE_D30x0003; |
751 | state = MAX(pdev->_s3d, pdev->_s3w)(((pdev->_s3d)>(pdev->_s3w))?(pdev->_s3d):(pdev-> _s3w)); |
752 | break; |
753 | case ACPI_STATE_S44: |
754 | state = MAX(pdev->_s4d, pdev->_s4w)(((pdev->_s4d)>(pdev->_s4w))?(pdev->_s4d):(pdev-> _s4w)); |
755 | break; |
756 | case ACPI_STATE_S55: |
757 | default: |
758 | break; |
759 | } |
760 | |
761 | if (state >= PCI_PMCSR_STATE_D00x0000 && |
762 | state <= PCI_PMCSR_STATE_D30x0003) |
763 | return state; |
764 | } |
765 | } |
766 | |
767 | return defaultstate; |
768 | } |
769 | |
770 | void |
771 | acpi_pci_set_powerstate(pci_chipset_tag_t pc, pcitag_t tag, int state, int pre) |
772 | { |
773 | #if NACPIPWRRES1 > 0 |
774 | struct acpi_softc *sc = acpi_softc; |
775 | struct acpi_pwrres *pr; |
776 | struct acpi_pci *pdev; |
777 | int bus, dev, fun; |
778 | char name[5]; |
779 | |
780 | pci_decompose_tag(pc, tag, &bus, &dev, &fun); |
781 | TAILQ_FOREACH(pdev, &acpi_pcidevs, next)for((pdev) = ((&acpi_pcidevs)->tqh_first); (pdev) != ( (void *)0); (pdev) = ((pdev)->next.tqe_next)) { |
782 | if (pdev->bus == bus && pdev->dev == dev && pdev->fun == fun) |
783 | break; |
784 | } |
785 | |
786 | /* XXX Add a check to discard nodes without Power Resources? */ |
787 | if (pdev == NULL((void *)0)) |
788 | return; |
789 | |
790 | SIMPLEQ_FOREACH(pr, &sc->sc_pwrresdevs, p_next)for((pr) = ((&sc->sc_pwrresdevs)->sqh_first); (pr) != ((void *)0); (pr) = ((pr)->p_next.sqe_next)) { |
791 | if (pr->p_node != pdev->node) |
792 | continue; |
793 | |
794 | /* |
795 | * If the firmware is already aware that the device |
796 | * is in the given state, there's nothing to do. |
797 | */ |
798 | if (pr->p_state == state) |
799 | continue; |
800 | |
801 | if (pre) { |
802 | /* |
803 | * If a Resource is dependent on this device for |
804 | * the given state, make sure it is turned "_ON". |
805 | */ |
806 | if (pr->p_res_state == state) |
807 | acpipwrres_ref_incr(pr->p_res_sc, pr->p_node); |
808 | } else { |
809 | /* |
810 | * If a Resource was referenced for the state we |
811 | * left, drop a reference and turn it "_OFF" if |
812 | * it was the last one. |
813 | */ |
814 | if (pr->p_res_state == pr->p_state) |
815 | acpipwrres_ref_decr(pr->p_res_sc, pr->p_node); |
816 | |
817 | if (pr->p_res_state == state) { |
818 | snprintf(name, sizeof(name), "_PS%d", state); |
819 | aml_evalname(sc, pr->p_node, name, 0, |
820 | NULL((void *)0), NULL((void *)0)); |
821 | } |
822 | |
823 | pr->p_state = state; |
824 | } |
825 | |
826 | } |
827 | #endif /* NACPIPWRRES > 0 */ |
828 | } |
829 | |
830 | int |
831 | acpi_pci_notify(struct aml_node *node, int ntype, void *arg) |
832 | { |
833 | struct acpi_pci *pdev = arg; |
834 | pci_chipset_tag_t pc; |
835 | pcitag_t tag; |
836 | pcireg_t reg; |
837 | int offset; |
838 | |
839 | /* We're only interested in Device Wake notifications. */ |
840 | if (ntype != 2) |
841 | return (0); |
842 | |
843 | pc = pci_lookup_segment(pdev->seg); |
844 | tag = pci_make_tag(pc, pdev->bus, pdev->dev, pdev->fun); |
845 | if (pci_get_capability(pc, tag, PCI_CAP_PWRMGMT0x01, &offset, 0)) { |
846 | /* Clear the PME Status bit if it is set. */ |
847 | reg = pci_conf_read(pc, tag, offset + PCI_PMCSR0x04); |
848 | pci_conf_write(pc, tag, offset + PCI_PMCSR0x04, reg); |
849 | } |
850 | |
851 | return (0); |
852 | } |
853 | |
854 | void |
855 | acpi_pciroots_attach(struct device *dev, void *aux, cfprint_t pr) |
856 | { |
857 | struct acpi_pci *pdev; |
858 | struct pcibus_attach_args *pba = aux; |
859 | |
860 | KASSERT(pba->pba_busex != NULL)((pba->pba_busex != ((void *)0)) ? (void)0 : __assert("diagnostic " , "/usr/src/sys/dev/acpi/acpi.c", 860, "pba->pba_busex != NULL" )); |
861 | |
862 | TAILQ_FOREACH(pdev, &acpi_pcirootdevs, next)for((pdev) = ((&acpi_pcirootdevs)->tqh_first); (pdev) != ((void *)0); (pdev) = ((pdev)->next.tqe_next)) { |
863 | if (extent_alloc_region(pba->pba_busex, pdev->bus, |
864 | 1, EX_NOWAIT0x0000) != 0) |
865 | continue; |
866 | pba->pba_bus = pdev->bus; |
867 | config_found(dev, pba, pr)config_found_sm((dev), (pba), (pr), ((void *)0)); |
868 | } |
869 | } |
870 | |
871 | /* GPIO support */ |
872 | |
873 | struct acpi_gpio_event { |
874 | struct aml_node *node; |
875 | uint16_t pin; |
876 | }; |
877 | |
878 | void |
879 | acpi_gpio_event_task(void *arg0, int arg1) |
880 | { |
881 | struct aml_node *node = arg0; |
882 | struct aml_value evt; |
883 | uint16_t pin = arg1; |
884 | char name[5]; |
885 | |
886 | if (pin < 256) { |
887 | snprintf(name, sizeof(name), "_E%.2X", pin); |
888 | if (aml_evalname(acpi_softc, node, name, 0, NULL((void *)0), NULL((void *)0)) == 0) |
889 | return; |
890 | } |
891 | |
892 | memset(&evt, 0, sizeof(evt))__builtin_memset((&evt), (0), (sizeof(evt))); |
893 | evt.v_integer_.vinteger = pin; |
894 | evt.type = AML_OBJTYPE_INTEGER; |
895 | aml_evalname(acpi_softc, node, "_EVT", 1, &evt, NULL((void *)0)); |
896 | } |
897 | |
898 | int |
899 | acpi_gpio_event(void *arg) |
900 | { |
901 | struct acpi_gpio_event *ev = arg; |
902 | |
903 | acpi_addtask(acpi_softc, acpi_gpio_event_task, ev->node, ev->pin); |
904 | acpi_wakeup(acpi_softc); |
905 | return 1; |
906 | } |
907 | |
908 | int |
909 | acpi_gpio_parse_events(int crsidx, union acpi_resource *crs, void *arg) |
910 | { |
911 | struct aml_node *devnode = arg; |
912 | struct aml_node *node; |
913 | uint16_t pin; |
914 | |
915 | switch (AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode : (crs)->hdr.typecode >> 3)) { |
916 | case LR_GPIO0x8C: |
917 | node = aml_searchname(devnode, |
918 | (char *)&crs->pad[crs->lr_gpio.res_off]); |
919 | pin = *(uint16_t *)&crs->pad[crs->lr_gpio.pin_off]; |
920 | if (crs->lr_gpio.type == LR_GPIO_INT0x00 && pin < 256 && |
921 | node && node->gpio && node->gpio->intr_establish) { |
922 | struct acpi_gpio *gpio = node->gpio; |
923 | struct acpi_gpio_event *ev; |
924 | |
925 | ev = malloc(sizeof(*ev), M_DEVBUF2, M_WAITOK0x0001); |
926 | ev->node = devnode; |
927 | ev->pin = pin; |
928 | gpio->intr_establish(gpio->cookie, pin, |
929 | crs->lr_gpio.tflags, acpi_gpio_event, ev); |
930 | } |
931 | break; |
932 | default: |
933 | printf("%s: unknown resource type %d\n", __func__, |
934 | AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode : (crs)->hdr.typecode >> 3)); |
935 | } |
936 | |
937 | return 0; |
938 | } |
939 | |
940 | void |
941 | acpi_register_gpio(struct acpi_softc *sc, struct aml_node *devnode) |
942 | { |
943 | struct aml_value arg[2]; |
944 | struct aml_node *node; |
945 | struct aml_value res; |
946 | |
947 | /* Register GeneralPurposeIO address space. */ |
948 | memset(&arg, 0, sizeof(arg))__builtin_memset((&arg), (0), (sizeof(arg))); |
949 | arg[0].type = AML_OBJTYPE_INTEGER; |
950 | arg[0].v_integer_.vinteger = ACPI_OPREG_GPIO8; |
951 | arg[1].type = AML_OBJTYPE_INTEGER; |
952 | arg[1].v_integer_.vinteger = 1; |
953 | node = aml_searchname(devnode, "_REG"); |
954 | if (node && aml_evalnode(sc, node, 2, arg, NULL((void *)0))) |
955 | printf("%s: _REG failed\n", node->name); |
956 | |
957 | /* Register GPIO signaled ACPI events. */ |
958 | if (aml_evalname(sc, devnode, "_AEI", 0, NULL((void *)0), &res)) |
959 | return; |
960 | aml_parse_resource(&res, acpi_gpio_parse_events, devnode); |
961 | } |
962 | |
963 | #ifndef SMALL_KERNEL |
964 | |
965 | void |
966 | acpi_register_gsb(struct acpi_softc *sc, struct aml_node *devnode) |
967 | { |
968 | struct aml_value arg[2]; |
969 | struct aml_node *node; |
970 | |
971 | /* Register GenericSerialBus address space. */ |
972 | memset(&arg, 0, sizeof(arg))__builtin_memset((&arg), (0), (sizeof(arg))); |
973 | arg[0].type = AML_OBJTYPE_INTEGER; |
974 | arg[0].v_integer_.vinteger = ACPI_OPREG_GSB9; |
975 | arg[1].type = AML_OBJTYPE_INTEGER; |
976 | arg[1].v_integer_.vinteger = 1; |
977 | node = aml_searchname(devnode, "_REG"); |
978 | if (node && aml_evalnode(sc, node, 2, arg, NULL((void *)0))) |
979 | printf("%s: _REG failed\n", node->name); |
980 | } |
981 | |
982 | #endif |
983 | |
984 | void |
985 | acpi_attach_common(struct acpi_softc *sc, paddr_t base) |
986 | { |
987 | struct acpi_mem_map handle; |
988 | struct acpi_rsdp *rsdp; |
989 | struct acpi_q *entry; |
990 | struct acpi_dsdt *p_dsdt; |
991 | #ifndef SMALL_KERNEL |
992 | int wakeup_dev_ct; |
993 | struct acpi_wakeq *wentry; |
994 | struct device *dev; |
995 | #endif /* SMALL_KERNEL */ |
996 | paddr_t facspa; |
997 | uint16_t pm1; |
998 | int s; |
999 | |
1000 | rw_init(&sc->sc_lck, "acpilk")_rw_init_flags(&sc->sc_lck, "acpilk", 0, ((void *)0)); |
1001 | |
1002 | acpi_softc = sc; |
1003 | |
1004 | if (acpi_map(base, sizeof(struct acpi_rsdp), &handle)) { |
1005 | printf(": can't map memory\n"); |
1006 | return; |
1007 | } |
1008 | rsdp = (struct acpi_rsdp *)handle.va; |
1009 | |
1010 | SIMPLEQ_INIT(&sc->sc_tables)do { (&sc->sc_tables)->sqh_first = ((void *)0); (& sc->sc_tables)->sqh_last = &(&sc->sc_tables) ->sqh_first; } while (0); |
1011 | SIMPLEQ_INIT(&sc->sc_wakedevs)do { (&sc->sc_wakedevs)->sqh_first = ((void *)0); ( &sc->sc_wakedevs)->sqh_last = &(&sc->sc_wakedevs )->sqh_first; } while (0); |
1012 | #if NACPIPWRRES1 > 0 |
1013 | SIMPLEQ_INIT(&sc->sc_pwrresdevs)do { (&sc->sc_pwrresdevs)->sqh_first = ((void *)0); (&sc->sc_pwrresdevs)->sqh_last = &(&sc-> sc_pwrresdevs)->sqh_first; } while (0); |
1014 | #endif /* NACPIPWRRES > 0 */ |
1015 | |
1016 | |
1017 | #ifndef SMALL_KERNEL |
1018 | sc->sc_note = malloc(sizeof(struct klist), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008); |
1019 | if (sc->sc_note == NULL((void *)0)) { |
1020 | printf(": can't allocate memory\n"); |
1021 | acpi_unmap(&handle); |
1022 | return; |
1023 | } |
1024 | #endif /* SMALL_KERNEL */ |
1025 | |
1026 | if (acpi_loadtables(sc, rsdp)) { |
1027 | printf(": can't load tables\n"); |
1028 | acpi_unmap(&handle); |
1029 | return; |
1030 | } |
1031 | |
1032 | acpi_unmap(&handle); |
1033 | |
1034 | /* |
1035 | * Find the FADT |
1036 | */ |
1037 | SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry ) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) { |
1038 | if (memcmp(entry->q_table, FADT_SIG,__builtin_memcmp((entry->q_table), ("FACP"), (sizeof("FACP" ) - 1)) |
1039 | sizeof(FADT_SIG) - 1)__builtin_memcmp((entry->q_table), ("FACP"), (sizeof("FACP" ) - 1)) == 0) { |
1040 | sc->sc_fadt = entry->q_table; |
1041 | break; |
1042 | } |
1043 | } |
1044 | if (sc->sc_fadt == NULL((void *)0)) { |
1045 | printf(": no FADT\n"); |
1046 | return; |
1047 | } |
1048 | |
1049 | sc->sc_major = sc->sc_fadt->hdr.revision; |
1050 | if (sc->sc_major > 4) |
1051 | sc->sc_minor = sc->sc_fadt->fadt_minor; |
1052 | printf(": ACPI %d.%d", sc->sc_major, sc->sc_minor); |
1053 | |
1054 | /* |
1055 | * A bunch of things need to be done differently for |
1056 | * Hardware-reduced ACPI. |
1057 | */ |
1058 | if (sc->sc_fadt->hdr_revisionhdr.revision >= 5 && |
1059 | sc->sc_fadt->flags & FADT_HW_REDUCED_ACPI0x00100000) |
1060 | sc->sc_hw_reduced = 1; |
1061 | |
1062 | /* Map Power Management registers */ |
1063 | acpi_map_pmregs(sc); |
1064 | |
1065 | /* |
1066 | * Check if we can and need to enable ACPI control. |
1067 | */ |
1068 | pm1 = acpi_read_pmreg(sc, ACPIREG_PM1_CNT0x10, 0); |
1069 | if ((pm1 & ACPI_PM1_SCI_EN0x0001) == 0 && sc->sc_fadt->smi_cmd && |
1070 | (!sc->sc_fadt->acpi_enable && !sc->sc_fadt->acpi_disable)) { |
1071 | printf(", ACPI control unavailable\n"); |
1072 | acpi_unmap_pmregs(sc); |
1073 | return; |
1074 | } |
1075 | |
1076 | /* |
1077 | * Set up a pointer to the firmware control structure |
1078 | */ |
1079 | if (sc->sc_fadt->hdr_revisionhdr.revision < 3 || sc->sc_fadt->x_firmware_ctl == 0) |
1080 | facspa = sc->sc_fadt->firmware_ctl; |
1081 | else |
1082 | facspa = sc->sc_fadt->x_firmware_ctl; |
1083 | |
1084 | if (acpi_map(facspa, sizeof(struct acpi_facs), &handle)) |
1085 | printf(" !FACS"); |
1086 | else |
1087 | sc->sc_facs = (struct acpi_facs *)handle.va; |
1088 | |
1089 | /* Create opcode hashtable */ |
1090 | aml_hashopcodes(); |
1091 | |
1092 | /* Create Default AML objects */ |
1093 | aml_create_defaultobjects(); |
1094 | |
1095 | /* |
1096 | * Load the DSDT from the FADT pointer -- use the |
1097 | * extended (64-bit) pointer if it exists |
1098 | */ |
1099 | if (sc->sc_fadt->hdr_revisionhdr.revision < 3 || sc->sc_fadt->x_dsdt == 0) |
1100 | entry = acpi_maptable(sc, sc->sc_fadt->dsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), |
1101 | -1); |
1102 | else |
1103 | entry = acpi_maptable(sc, sc->sc_fadt->x_dsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), |
1104 | -1); |
1105 | |
1106 | if (entry == NULL((void *)0)) |
1107 | printf(" !DSDT"); |
1108 | |
1109 | p_dsdt = entry->q_table; |
1110 | acpi_parse_aml(sc, p_dsdt->aml, p_dsdt->hdr_lengthhdr.length - |
1111 | sizeof(p_dsdt->hdr)); |
1112 | |
1113 | /* Load SSDT's */ |
1114 | SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry ) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) { |
1115 | if (memcmp(entry->q_table, SSDT_SIG,__builtin_memcmp((entry->q_table), ("SSDT"), (sizeof("SSDT" ) - 1)) |
1116 | sizeof(SSDT_SIG) - 1)__builtin_memcmp((entry->q_table), ("SSDT"), (sizeof("SSDT" ) - 1)) == 0) { |
1117 | p_dsdt = entry->q_table; |
1118 | acpi_parse_aml(sc, p_dsdt->aml, p_dsdt->hdr_lengthhdr.length - |
1119 | sizeof(p_dsdt->hdr)); |
1120 | } |
1121 | } |
1122 | |
1123 | /* Perform post-parsing fixups */ |
1124 | aml_postparse(); |
1125 | |
1126 | |
1127 | #ifndef SMALL_KERNEL |
1128 | /* Find available sleeping states */ |
1129 | acpi_init_states(sc); |
1130 | |
1131 | /* Find available sleep/resume related methods. */ |
1132 | acpi_init_pm(sc); |
1133 | #endif /* SMALL_KERNEL */ |
1134 | |
1135 | /* Initialize GPE handlers */ |
1136 | s = splbio()splraise(0x6); |
1137 | acpi_init_gpes(sc); |
1138 | splx(s)spllower(s); |
1139 | |
1140 | /* some devices require periodic polling */ |
1141 | timeout_set(&sc->sc_dev_timeout, acpi_poll, sc); |
1142 | |
1143 | acpi_enabled = 1; |
1144 | |
1145 | /* |
1146 | * Take over ACPI control. Note that once we do this, we |
1147 | * effectively tell the system that we have ownership of |
1148 | * the ACPI hardware registers, and that SMI should leave |
1149 | * them alone |
1150 | * |
1151 | * This may prevent thermal control on some systems where |
1152 | * that actually does work |
1153 | */ |
1154 | if ((pm1 & ACPI_PM1_SCI_EN0x0001) == 0 && sc->sc_fadt->smi_cmd) { |
1155 | if (acpi_enable(sc)) { |
1156 | printf(", can't enable ACPI\n"); |
1157 | return; |
1158 | } |
1159 | } |
1160 | |
1161 | printf("\n%s: tables", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1162 | SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry ) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) { |
1163 | printf(" %.4s", (char *)entry->q_table); |
1164 | } |
1165 | printf("\n"); |
1166 | |
1167 | #ifndef SMALL_KERNEL |
1168 | /* Display wakeup devices and lowest S-state */ |
1169 | wakeup_dev_ct = 0; |
1170 | printf("%s: wakeup devices", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1171 | SIMPLEQ_FOREACH(wentry, &sc->sc_wakedevs, q_next)for((wentry) = ((&sc->sc_wakedevs)->sqh_first); (wentry ) != ((void *)0); (wentry) = ((wentry)->q_next.sqe_next)) { |
1172 | if (wakeup_dev_ct < 16) |
1173 | printf(" %.4s(S%d)", wentry->q_node->name, |
1174 | wentry->q_state); |
1175 | else if (wakeup_dev_ct == 16) |
1176 | printf(" [...]"); |
1177 | wakeup_dev_ct++; |
1178 | } |
1179 | printf("\n"); |
1180 | |
1181 | /* |
1182 | * ACPI is enabled now -- attach timer |
1183 | */ |
1184 | if (!sc->sc_hw_reduced && |
1185 | (sc->sc_fadt->pm_tmr_blk || sc->sc_fadt->x_pm_tmr_blk.address)) { |
1186 | struct acpi_attach_args aaa; |
1187 | |
1188 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
1189 | aaa.aaa_name = "acpitimer"; |
1190 | aaa.aaa_iot = sc->sc_iot; |
1191 | aaa.aaa_memt = sc->sc_memt; |
1192 | config_found(&sc->sc_dev, &aaa, acpi_print)config_found_sm((&sc->sc_dev), (&aaa), (acpi_print ), ((void *)0)); |
1193 | } |
1194 | #endif /* SMALL_KERNEL */ |
1195 | |
1196 | /* |
1197 | * Attach table-defined devices |
1198 | */ |
1199 | SIMPLEQ_FOREACH(entry, &sc->sc_tables, q_next)for((entry) = ((&sc->sc_tables)->sqh_first); (entry ) != ((void *)0); (entry) = ((entry)->q_next.sqe_next)) { |
1200 | struct acpi_attach_args aaa; |
1201 | |
1202 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
1203 | aaa.aaa_iot = sc->sc_iot; |
1204 | aaa.aaa_memt = sc->sc_memt; |
1205 | aaa.aaa_dmat = sc->sc_ci_dmat; |
1206 | aaa.aaa_table = entry->q_table; |
1207 | config_found_sm(&sc->sc_dev, &aaa, acpi_print, acpi_submatch); |
1208 | } |
1209 | |
1210 | /* initialize runtime environment */ |
1211 | aml_find_node(&aml_root, "_INI", acpi_inidev, sc); |
1212 | |
1213 | /* Get PCI mapping */ |
1214 | aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_getpci, sc); |
1215 | |
1216 | #if defined (__amd64__1) || defined(__i386__) |
1217 | /* attach pci interrupt routing tables */ |
1218 | aml_find_node(&aml_root, "_PRT", acpi_foundprt, sc); |
1219 | #endif |
1220 | |
1221 | aml_find_node(&aml_root, "_HID", acpi_foundec, sc); |
1222 | |
1223 | /* check if we're running on a sony */ |
1224 | aml_find_node(&aml_root, "GBRT", acpi_foundsony, sc); |
1225 | |
1226 | #ifndef SMALL_KERNEL |
1227 | /* try to find smart battery first */ |
1228 | aml_find_node(&aml_root, "_HID", acpi_foundsbs, sc); |
1229 | #endif /* SMALL_KERNEL */ |
1230 | |
1231 | /* attach battery, power supply and button devices */ |
1232 | aml_find_node(&aml_root, "_HID", acpi_foundhid, sc); |
1233 | |
1234 | aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_add_device, sc); |
1235 | |
1236 | #ifndef SMALL_KERNEL |
1237 | #if NWD1 > 0 |
1238 | /* Attach IDE bay */ |
1239 | aml_walknodes(&aml_root, AML_WALK_PRE0x00, acpi_foundide, sc); |
1240 | #endif |
1241 | |
1242 | /* attach docks */ |
1243 | aml_find_node(&aml_root, "_DCK", acpi_founddock, sc); |
1244 | |
1245 | /* attach video */ |
1246 | aml_find_node(&aml_root, "_DOS", acpi_foundvideo, sc); |
1247 | |
1248 | /* create list of devices we want to query when APM comes in */ |
1249 | SLIST_INIT(&sc->sc_ac){ ((&sc->sc_ac)->slh_first) = ((void *)0); }; |
1250 | SLIST_INIT(&sc->sc_bat){ ((&sc->sc_bat)->slh_first) = ((void *)0); }; |
1251 | TAILQ_FOREACH(dev, &alldevs, dv_list)for((dev) = ((&alldevs)->tqh_first); (dev) != ((void * )0); (dev) = ((dev)->dv_list.tqe_next)) { |
1252 | if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpiac")) { |
1253 | struct acpi_ac *ac; |
1254 | |
1255 | ac = malloc(sizeof(*ac), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); |
1256 | ac->aac_softc = (struct acpiac_softc *)dev; |
1257 | SLIST_INSERT_HEAD(&sc->sc_ac, ac, aac_link)do { (ac)->aac_link.sle_next = (&sc->sc_ac)->slh_first ; (&sc->sc_ac)->slh_first = (ac); } while (0); |
1258 | } else if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpibat")) { |
1259 | struct acpi_bat *bat; |
1260 | |
1261 | bat = malloc(sizeof(*bat), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); |
1262 | bat->aba_softc = (struct acpibat_softc *)dev; |
1263 | SLIST_INSERT_HEAD(&sc->sc_bat, bat, aba_link)do { (bat)->aba_link.sle_next = (&sc->sc_bat)->slh_first ; (&sc->sc_bat)->slh_first = (bat); } while (0); |
1264 | } else if (!strcmp(dev->dv_cfdata->cf_driver->cd_name, "acpisbs")) { |
1265 | struct acpi_sbs *sbs; |
1266 | |
1267 | sbs = malloc(sizeof(*sbs), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); |
1268 | sbs->asbs_softc = (struct acpisbs_softc *)dev; |
1269 | SLIST_INSERT_HEAD(&sc->sc_sbs, sbs, asbs_link)do { (sbs)->asbs_link.sle_next = (&sc->sc_sbs)-> slh_first; (&sc->sc_sbs)->slh_first = (sbs); } while (0); |
1270 | } |
1271 | } |
1272 | |
1273 | #endif /* SMALL_KERNEL */ |
1274 | |
1275 | /* Setup threads */ |
1276 | sc->sc_thread = malloc(sizeof(struct acpi_thread), M_DEVBUF2, M_WAITOK0x0001); |
1277 | sc->sc_thread->sc = sc; |
1278 | sc->sc_thread->running = 1; |
1279 | |
1280 | /* Enable PCI Power Management. */ |
1281 | pci_dopm = 1; |
1282 | |
1283 | acpi_attach_machdep(sc); |
1284 | |
1285 | kthread_create_deferred(acpi_create_thread, sc); |
1286 | } |
1287 | |
1288 | int |
1289 | acpi_submatch(struct device *parent, void *match, void *aux) |
1290 | { |
1291 | struct acpi_attach_args *aaa = (struct acpi_attach_args *)aux; |
1292 | struct cfdata *cf = match; |
1293 | |
1294 | if (aaa->aaa_table == NULL((void *)0)) |
1295 | return (0); |
1296 | return ((*cf->cf_attach->ca_match)(parent, match, aux)); |
1297 | } |
1298 | |
1299 | int |
1300 | acpi_print(void *aux, const char *pnp) |
1301 | { |
1302 | struct acpi_attach_args *aa = aux; |
1303 | |
1304 | if (pnp) { |
1305 | if (aa->aaa_name) |
1306 | printf("%s at %s", aa->aaa_name, pnp); |
1307 | else if (aa->aaa_dev) |
1308 | printf("\"%s\" at %s", aa->aaa_dev, pnp); |
1309 | else |
1310 | return (QUIET0); |
1311 | } |
1312 | |
1313 | return (UNCONF1); |
1314 | } |
1315 | |
1316 | struct acpi_q * |
1317 | acpi_maptable(struct acpi_softc *sc, paddr_t addr, const char *sig, |
1318 | const char *oem, const char *tbl, int flag) |
1319 | { |
1320 | static int tblid; |
1321 | struct acpi_mem_map handle; |
1322 | struct acpi_table_header *hdr; |
1323 | struct acpi_q *entry; |
1324 | size_t len; |
1325 | |
1326 | /* Check if we can map address */ |
1327 | if (addr == 0) |
1328 | return NULL((void *)0); |
1329 | if (acpi_map(addr, sizeof(*hdr), &handle)) |
1330 | return NULL((void *)0); |
1331 | hdr = (struct acpi_table_header *)handle.va; |
1332 | len = hdr->length; |
1333 | acpi_unmap(&handle); |
1334 | |
1335 | /* Validate length/checksum */ |
1336 | if (acpi_map(addr, len, &handle)) |
1337 | return NULL((void *)0); |
1338 | hdr = (struct acpi_table_header *)handle.va; |
1339 | if (acpi_checksum(hdr, len)) |
1340 | printf("\n%s: %.4s checksum error", |
1341 | DEVNAME(sc)((sc)->sc_dev.dv_xname), hdr->signature); |
1342 | |
1343 | if ((sig && memcmp(sig, hdr->signature, 4)__builtin_memcmp((sig), (hdr->signature), (4))) || |
1344 | (oem && memcmp(oem, hdr->oemid, 6)__builtin_memcmp((oem), (hdr->oemid), (6))) || |
1345 | (tbl && memcmp(tbl, hdr->oemtableid, 8)__builtin_memcmp((tbl), (hdr->oemtableid), (8)))) { |
1346 | acpi_unmap(&handle); |
1347 | return NULL((void *)0); |
1348 | } |
1349 | |
1350 | /* Allocate copy */ |
1351 | entry = malloc(sizeof(*entry) + len, M_DEVBUF2, M_NOWAIT0x0002); |
1352 | if (entry != NULL((void *)0)) { |
1353 | memcpy(entry->q_data, handle.va, len)__builtin_memcpy((entry->q_data), (handle.va), (len)); |
1354 | entry->q_table = entry->q_data; |
1355 | entry->q_id = ++tblid; |
1356 | |
1357 | if (flag < 0) |
1358 | SIMPLEQ_INSERT_HEAD(&sc->sc_tables, entry,do { if (((entry)->q_next.sqe_next = (&sc->sc_tables )->sqh_first) == ((void *)0)) (&sc->sc_tables)-> sqh_last = &(entry)->q_next.sqe_next; (&sc->sc_tables )->sqh_first = (entry); } while (0) |
1359 | q_next)do { if (((entry)->q_next.sqe_next = (&sc->sc_tables )->sqh_first) == ((void *)0)) (&sc->sc_tables)-> sqh_last = &(entry)->q_next.sqe_next; (&sc->sc_tables )->sqh_first = (entry); } while (0); |
1360 | else if (flag > 0) |
1361 | SIMPLEQ_INSERT_TAIL(&sc->sc_tables, entry,do { (entry)->q_next.sqe_next = ((void *)0); *(&sc-> sc_tables)->sqh_last = (entry); (&sc->sc_tables)-> sqh_last = &(entry)->q_next.sqe_next; } while (0) |
1362 | q_next)do { (entry)->q_next.sqe_next = ((void *)0); *(&sc-> sc_tables)->sqh_last = (entry); (&sc->sc_tables)-> sqh_last = &(entry)->q_next.sqe_next; } while (0); |
1363 | } |
1364 | acpi_unmap(&handle); |
1365 | return entry; |
1366 | } |
1367 | |
1368 | int |
1369 | acpi_loadtables(struct acpi_softc *sc, struct acpi_rsdp *rsdp) |
1370 | { |
1371 | struct acpi_q *sdt; |
1372 | int i, ntables; |
1373 | size_t len; |
1374 | |
1375 | if (rsdp->rsdp_revisionrsdp1.revision == 2 && rsdp->rsdp_xsdt) { |
1376 | struct acpi_xsdt *xsdt; |
1377 | |
1378 | sdt = acpi_maptable(sc, rsdp->rsdp_xsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), 0); |
1379 | if (sdt == NULL((void *)0)) { |
1380 | printf("couldn't map xsdt\n"); |
1381 | return (ENOMEM12); |
1382 | } |
1383 | |
1384 | xsdt = (struct acpi_xsdt *)sdt->q_data; |
1385 | len = xsdt->hdr.length; |
1386 | ntables = (len - sizeof(struct acpi_table_header)) / |
1387 | sizeof(xsdt->table_offsets[0]); |
1388 | |
1389 | for (i = 0; i < ntables; i++) |
1390 | acpi_maptable(sc, xsdt->table_offsets[i], NULL((void *)0), NULL((void *)0), |
1391 | NULL((void *)0), 1); |
1392 | |
1393 | free(sdt, M_DEVBUF2, sizeof(*sdt) + len); |
1394 | } else { |
1395 | struct acpi_rsdt *rsdt; |
1396 | |
1397 | sdt = acpi_maptable(sc, rsdp->rsdp_rsdtrsdp1.rsdt, NULL((void *)0), NULL((void *)0), NULL((void *)0), 0); |
1398 | if (sdt == NULL((void *)0)) { |
1399 | printf("couldn't map rsdt\n"); |
1400 | return (ENOMEM12); |
1401 | } |
1402 | |
1403 | rsdt = (struct acpi_rsdt *)sdt->q_data; |
1404 | len = rsdt->hdr.length; |
1405 | ntables = (len - sizeof(struct acpi_table_header)) / |
1406 | sizeof(rsdt->table_offsets[0]); |
1407 | |
1408 | for (i = 0; i < ntables; i++) |
1409 | acpi_maptable(sc, rsdt->table_offsets[i], NULL((void *)0), NULL((void *)0), |
1410 | NULL((void *)0), 1); |
1411 | |
1412 | free(sdt, M_DEVBUF2, sizeof(*sdt) + len); |
1413 | } |
1414 | |
1415 | return (0); |
1416 | } |
1417 | |
1418 | /* Read from power management register */ |
1419 | int |
1420 | acpi_read_pmreg(struct acpi_softc *sc, int reg, int offset) |
1421 | { |
1422 | bus_space_handle_t ioh; |
1423 | bus_size_t size; |
1424 | int regval; |
1425 | |
1426 | /* |
1427 | * For Hardware-reduced ACPI we emulate PM1B_CNT to reflect |
1428 | * that the system is always in ACPI mode. |
1429 | */ |
1430 | if (sc->sc_hw_reduced && reg == ACPIREG_PM1B_CNT0x05) { |
1431 | KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c" , 1431, "offset == 0")); |
1432 | return ACPI_PM1_SCI_EN0x0001; |
1433 | } |
1434 | |
1435 | /* |
1436 | * For Hardware-reduced ACPI we also emulate PM1A_STS using |
1437 | * SLEEP_STATUS_REG. |
1438 | */ |
1439 | if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_STS0x00 && |
1440 | sc->sc_fadt->sleep_status_reg.register_bit_width > 0) { |
1441 | uint8_t value; |
1442 | |
1443 | KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c" , 1443, "offset == 0")); |
1444 | acpi_gasio(sc, ACPI_IOREAD0, |
1445 | sc->sc_fadt->sleep_status_reg.address_space_id, |
1446 | sc->sc_fadt->sleep_status_reg.address, |
1447 | sc->sc_fadt->sleep_status_reg.register_bit_width / 8, |
1448 | sc->sc_fadt->sleep_status_reg.access_size, &value); |
1449 | return ((int)value << 8); |
1450 | } |
1451 | |
1452 | /* Special cases: 1A/1B blocks can be OR'ed together */ |
1453 | switch (reg) { |
1454 | case ACPIREG_PM1_EN0x0F: |
1455 | return (acpi_read_pmreg(sc, ACPIREG_PM1A_EN0x01, offset) | |
1456 | acpi_read_pmreg(sc, ACPIREG_PM1B_EN0x04, offset)); |
1457 | case ACPIREG_PM1_STS0x0E: |
1458 | return (acpi_read_pmreg(sc, ACPIREG_PM1A_STS0x00, offset) | |
1459 | acpi_read_pmreg(sc, ACPIREG_PM1B_STS0x03, offset)); |
1460 | case ACPIREG_PM1_CNT0x10: |
1461 | return (acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, offset) | |
1462 | acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, offset)); |
1463 | case ACPIREG_GPE_STS0x11: |
1464 | dnprintf(50, "read GPE_STS offset: %.2x %.2x %.2x\n", offset, |
1465 | sc->sc_fadt->gpe0_blk_len>>1, sc->sc_fadt->gpe1_blk_len>>1); |
1466 | if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) { |
1467 | reg = ACPIREG_GPE0_STS0x08; |
1468 | } |
1469 | break; |
1470 | case ACPIREG_GPE_EN0x12: |
1471 | dnprintf(50, "read GPE_EN offset: %.2x %.2x %.2x\n", |
1472 | offset, sc->sc_fadt->gpe0_blk_len>>1, |
1473 | sc->sc_fadt->gpe1_blk_len>>1); |
1474 | if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) { |
1475 | reg = ACPIREG_GPE0_EN0x09; |
1476 | } |
1477 | break; |
1478 | } |
1479 | |
1480 | if (reg >= ACPIREG_MAXREG0x0D || sc->sc_pmregs[reg].size == 0) |
1481 | return (0); |
1482 | |
1483 | regval = 0; |
1484 | ioh = sc->sc_pmregs[reg].ioh; |
1485 | size = sc->sc_pmregs[reg].size; |
1486 | if (size > sc->sc_pmregs[reg].access) |
1487 | size = sc->sc_pmregs[reg].access; |
1488 | |
1489 | switch (size) { |
1490 | case 1: |
1491 | regval = bus_space_read_1(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_1((ioh), (offset))); |
1492 | break; |
1493 | case 2: |
1494 | regval = bus_space_read_2(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_2((ioh), (offset))); |
1495 | break; |
1496 | case 4: |
1497 | regval = bus_space_read_4(sc->sc_iot, ioh, offset)((sc->sc_iot)->read_4((ioh), (offset))); |
1498 | break; |
1499 | } |
1500 | |
1501 | dnprintf(30, "acpi_readpm: %s = %.4x:%.4x %x\n", |
1502 | sc->sc_pmregs[reg].name, |
1503 | sc->sc_pmregs[reg].addr, offset, regval); |
1504 | return (regval); |
1505 | } |
1506 | |
1507 | /* Write to power management register */ |
1508 | void |
1509 | acpi_write_pmreg(struct acpi_softc *sc, int reg, int offset, int regval) |
1510 | { |
1511 | bus_space_handle_t ioh; |
1512 | bus_size_t size; |
1513 | |
1514 | /* |
1515 | * For Hardware-reduced ACPI we also emulate PM1A_STS using |
1516 | * SLEEP_STATUS_REG. |
1517 | */ |
1518 | if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_STS0x00 && |
1519 | sc->sc_fadt->sleep_status_reg.register_bit_width > 0) { |
1520 | uint8_t value = (regval >> 8); |
1521 | |
1522 | KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c" , 1522, "offset == 0")); |
1523 | acpi_gasio(sc, ACPI_IOWRITE1, |
1524 | sc->sc_fadt->sleep_status_reg.address_space_id, |
1525 | sc->sc_fadt->sleep_status_reg.address, |
1526 | sc->sc_fadt->sleep_status_reg.register_bit_width / 8, |
1527 | sc->sc_fadt->sleep_status_reg.access_size, &value); |
1528 | return; |
1529 | } |
1530 | |
1531 | /* |
1532 | * For Hardware-reduced ACPI we also emulate PM1A_CNT using |
1533 | * SLEEP_CONTROL_REG. |
1534 | */ |
1535 | if (sc->sc_hw_reduced && reg == ACPIREG_PM1A_CNT0x02 && |
1536 | sc->sc_fadt->sleep_control_reg.register_bit_width > 0) { |
1537 | uint8_t value = (regval >> 8); |
1538 | |
1539 | KASSERT(offset == 0)((offset == 0) ? (void)0 : __assert("diagnostic ", "/usr/src/sys/dev/acpi/acpi.c" , 1539, "offset == 0")); |
1540 | acpi_gasio(sc, ACPI_IOWRITE1, |
1541 | sc->sc_fadt->sleep_control_reg.address_space_id, |
1542 | sc->sc_fadt->sleep_control_reg.address, |
1543 | sc->sc_fadt->sleep_control_reg.register_bit_width / 8, |
1544 | sc->sc_fadt->sleep_control_reg.access_size, &value); |
1545 | return; |
1546 | } |
1547 | |
1548 | /* Special cases: 1A/1B blocks can be written with same value */ |
1549 | switch (reg) { |
1550 | case ACPIREG_PM1_EN0x0F: |
1551 | acpi_write_pmreg(sc, ACPIREG_PM1A_EN0x01, offset, regval); |
1552 | acpi_write_pmreg(sc, ACPIREG_PM1B_EN0x04, offset, regval); |
1553 | break; |
1554 | case ACPIREG_PM1_STS0x0E: |
1555 | acpi_write_pmreg(sc, ACPIREG_PM1A_STS0x00, offset, regval); |
1556 | acpi_write_pmreg(sc, ACPIREG_PM1B_STS0x03, offset, regval); |
1557 | break; |
1558 | case ACPIREG_PM1_CNT0x10: |
1559 | acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, offset, regval); |
1560 | acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, offset, regval); |
1561 | break; |
1562 | case ACPIREG_GPE_STS0x11: |
1563 | dnprintf(50, "write GPE_STS offset: %.2x %.2x %.2x %.2x\n", |
1564 | offset, sc->sc_fadt->gpe0_blk_len>>1, |
1565 | sc->sc_fadt->gpe1_blk_len>>1, regval); |
1566 | if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) { |
1567 | reg = ACPIREG_GPE0_STS0x08; |
1568 | } |
1569 | break; |
1570 | case ACPIREG_GPE_EN0x12: |
1571 | dnprintf(50, "write GPE_EN offset: %.2x %.2x %.2x %.2x\n", |
1572 | offset, sc->sc_fadt->gpe0_blk_len>>1, |
1573 | sc->sc_fadt->gpe1_blk_len>>1, regval); |
1574 | if (offset < (sc->sc_fadt->gpe0_blk_len >> 1)) { |
1575 | reg = ACPIREG_GPE0_EN0x09; |
1576 | } |
1577 | break; |
1578 | } |
1579 | |
1580 | /* All special case return here */ |
1581 | if (reg >= ACPIREG_MAXREG0x0D) |
1582 | return; |
1583 | |
1584 | ioh = sc->sc_pmregs[reg].ioh; |
1585 | size = sc->sc_pmregs[reg].size; |
1586 | if (size > sc->sc_pmregs[reg].access) |
1587 | size = sc->sc_pmregs[reg].access; |
1588 | |
1589 | switch (size) { |
1590 | case 1: |
1591 | bus_space_write_1(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_1((ioh), (offset), (regval))); |
1592 | break; |
1593 | case 2: |
1594 | bus_space_write_2(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_2((ioh), (offset), (regval))); |
1595 | break; |
1596 | case 4: |
1597 | bus_space_write_4(sc->sc_iot, ioh, offset, regval)((sc->sc_iot)->write_4((ioh), (offset), (regval))); |
1598 | break; |
1599 | } |
1600 | |
1601 | dnprintf(30, "acpi_writepm: %s = %.4x:%.4x %x\n", |
1602 | sc->sc_pmregs[reg].name, sc->sc_pmregs[reg].addr, offset, regval); |
1603 | } |
1604 | |
1605 | /* Map Power Management registers */ |
1606 | void |
1607 | acpi_map_pmregs(struct acpi_softc *sc) |
1608 | { |
1609 | struct acpi_fadt *fadt = sc->sc_fadt; |
1610 | bus_addr_t addr; |
1611 | bus_size_t size, access; |
1612 | const char *name; |
1613 | int reg; |
1614 | |
1615 | for (reg = 0; reg < ACPIREG_MAXREG0x0D; reg++) { |
1616 | size = 0; |
1617 | access = 0; |
1618 | switch (reg) { |
1619 | case ACPIREG_SMICMD0x0C: |
1620 | name = "smi"; |
1621 | size = access = 1; |
1622 | addr = fadt->smi_cmd; |
1623 | break; |
1624 | case ACPIREG_PM1A_STS0x00: |
1625 | case ACPIREG_PM1A_EN0x01: |
1626 | name = "pm1a_sts"; |
1627 | size = fadt->pm1_evt_len >> 1; |
1628 | if (fadt->pm1a_evt_blk) { |
1629 | addr = fadt->pm1a_evt_blk; |
1630 | access = 2; |
1631 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1632 | addr = fadt->x_pm1a_evt_blk.address; |
1633 | access = 1 << fadt->x_pm1a_evt_blk.access_size; |
1634 | } |
1635 | if (reg == ACPIREG_PM1A_EN0x01 && addr) { |
1636 | addr += size; |
1637 | name = "pm1a_en"; |
1638 | } |
1639 | break; |
1640 | case ACPIREG_PM1A_CNT0x02: |
1641 | name = "pm1a_cnt"; |
1642 | size = fadt->pm1_cnt_len; |
1643 | if (fadt->pm1a_cnt_blk) { |
1644 | addr = fadt->pm1a_cnt_blk; |
1645 | access = 2; |
1646 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1647 | addr = fadt->x_pm1a_cnt_blk.address; |
1648 | access = 1 << fadt->x_pm1a_cnt_blk.access_size; |
1649 | } |
1650 | break; |
1651 | case ACPIREG_PM1B_STS0x03: |
1652 | case ACPIREG_PM1B_EN0x04: |
1653 | name = "pm1b_sts"; |
1654 | size = fadt->pm1_evt_len >> 1; |
1655 | if (fadt->pm1b_evt_blk) { |
1656 | addr = fadt->pm1b_evt_blk; |
1657 | access = 2; |
1658 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1659 | addr = fadt->x_pm1b_evt_blk.address; |
1660 | access = 1 << fadt->x_pm1b_evt_blk.access_size; |
1661 | } |
1662 | if (reg == ACPIREG_PM1B_EN0x04 && addr) { |
1663 | addr += size; |
1664 | name = "pm1b_en"; |
1665 | } |
1666 | break; |
1667 | case ACPIREG_PM1B_CNT0x05: |
1668 | name = "pm1b_cnt"; |
1669 | size = fadt->pm1_cnt_len; |
1670 | if (fadt->pm1b_cnt_blk) { |
1671 | addr = fadt->pm1b_cnt_blk; |
1672 | access = 2; |
1673 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1674 | addr = fadt->x_pm1b_cnt_blk.address; |
1675 | access = 1 << fadt->x_pm1b_cnt_blk.access_size; |
1676 | } |
1677 | break; |
1678 | case ACPIREG_PM2_CNT0x06: |
1679 | name = "pm2_cnt"; |
1680 | size = fadt->pm2_cnt_len; |
1681 | if (fadt->pm2_cnt_blk) { |
1682 | addr = fadt->pm2_cnt_blk; |
1683 | access = size; |
1684 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1685 | addr = fadt->x_pm2_cnt_blk.address; |
1686 | access = 1 << fadt->x_pm2_cnt_blk.access_size; |
1687 | } |
1688 | break; |
1689 | #if 0 |
1690 | case ACPIREG_PM_TMR0x07: |
1691 | /* Allocated in acpitimer */ |
1692 | name = "pm_tmr"; |
1693 | size = fadt->pm_tmr_len; |
1694 | if (fadt->pm_tmr_blk) { |
1695 | addr = fadt->pm_tmr_blk; |
1696 | access = 4; |
1697 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1698 | addr = fadt->x_pm_tmr_blk.address; |
1699 | access = 1 << fadt->x_pm_tmr_blk.access_size; |
1700 | } |
1701 | break; |
1702 | #endif |
1703 | case ACPIREG_GPE0_STS0x08: |
1704 | case ACPIREG_GPE0_EN0x09: |
1705 | name = "gpe0_sts"; |
1706 | size = fadt->gpe0_blk_len >> 1; |
1707 | if (fadt->gpe0_blk) { |
1708 | addr = fadt->gpe0_blk; |
1709 | access = 1; |
1710 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1711 | addr = fadt->x_gpe0_blk.address; |
1712 | access = 1 << fadt->x_gpe0_blk.access_size; |
1713 | } |
1714 | |
1715 | dnprintf(20, "gpe0 block len : %x\n", |
1716 | fadt->gpe0_blk_len >> 1); |
1717 | dnprintf(20, "gpe0 block addr: %x\n", |
1718 | fadt->gpe0_blk); |
1719 | if (reg == ACPIREG_GPE0_EN0x09 && addr) { |
1720 | addr += size; |
1721 | name = "gpe0_en"; |
1722 | } |
1723 | break; |
1724 | case ACPIREG_GPE1_STS0x0A: |
1725 | case ACPIREG_GPE1_EN0x0B: |
1726 | name = "gpe1_sts"; |
1727 | size = fadt->gpe1_blk_len >> 1; |
1728 | if (fadt->gpe1_blk) { |
1729 | addr = fadt->gpe1_blk; |
1730 | access = 1; |
1731 | } else if (fadt->hdr_revisionhdr.revision >= 3) { |
1732 | addr = fadt->x_gpe1_blk.address; |
1733 | access = 1 << fadt->x_gpe1_blk.access_size; |
1734 | } |
1735 | |
1736 | dnprintf(20, "gpe1 block len : %x\n", |
1737 | fadt->gpe1_blk_len >> 1); |
1738 | dnprintf(20, "gpe1 block addr: %x\n", |
1739 | fadt->gpe1_blk); |
1740 | if (reg == ACPIREG_GPE1_EN0x0B && addr) { |
1741 | addr += size; |
1742 | name = "gpe1_en"; |
1743 | } |
1744 | break; |
1745 | } |
1746 | if (size && addr) { |
1747 | dnprintf(50, "mapping: %.4lx %.4lx %s\n", |
1748 | addr, size, name); |
1749 | |
1750 | /* Size and address exist; map register space */ |
1751 | bus_space_map(sc->sc_iot, addr, size, 0, |
1752 | &sc->sc_pmregs[reg].ioh); |
1753 | |
1754 | sc->sc_pmregs[reg].name = name; |
1755 | sc->sc_pmregs[reg].size = size; |
1756 | sc->sc_pmregs[reg].addr = addr; |
1757 | sc->sc_pmregs[reg].access = min(access, 4); |
1758 | } |
1759 | } |
1760 | } |
1761 | |
1762 | void |
1763 | acpi_unmap_pmregs(struct acpi_softc *sc) |
1764 | { |
1765 | int reg; |
1766 | |
1767 | for (reg = 0; reg < ACPIREG_MAXREG0x0D; reg++) { |
1768 | if (sc->sc_pmregs[reg].size && sc->sc_pmregs[reg].addr) |
1769 | bus_space_unmap(sc->sc_iot, sc->sc_pmregs[reg].ioh, |
1770 | sc->sc_pmregs[reg].size); |
1771 | } |
1772 | } |
1773 | |
1774 | int |
1775 | acpi_enable(struct acpi_softc *sc) |
1776 | { |
1777 | int idx; |
1778 | |
1779 | acpi_write_pmreg(sc, ACPIREG_SMICMD0x0C, 0, sc->sc_fadt->acpi_enable); |
1780 | idx = 0; |
1781 | do { |
1782 | if (idx++ > ACPIEN_RETRIES15) { |
1783 | return ETIMEDOUT60; |
1784 | } |
1785 | } while (!(acpi_read_pmreg(sc, ACPIREG_PM1_CNT0x10, 0) & ACPI_PM1_SCI_EN0x0001)); |
1786 | |
1787 | return 0; |
1788 | } |
1789 | |
1790 | /* ACPI Workqueue support */ |
1791 | SIMPLEQ_HEAD(,acpi_taskq)struct { struct acpi_taskq *sqh_first; struct acpi_taskq **sqh_last ; } acpi_taskq = |
1792 | SIMPLEQ_HEAD_INITIALIZER(acpi_taskq){ ((void *)0), &(acpi_taskq).sqh_first }; |
1793 | |
1794 | void |
1795 | acpi_addtask(struct acpi_softc *sc, void (*handler)(void *, int), |
1796 | void *arg0, int arg1) |
1797 | { |
1798 | struct acpi_taskq *wq; |
1799 | int s; |
1800 | |
1801 | wq = malloc(sizeof(*wq), M_DEVBUF2, M_ZERO0x0008 | M_NOWAIT0x0002); |
1802 | if (wq == NULL((void *)0)) |
1803 | return; |
1804 | wq->handler = handler; |
1805 | wq->arg0 = arg0; |
1806 | wq->arg1 = arg1; |
1807 | |
1808 | s = splbio()splraise(0x6); |
1809 | SIMPLEQ_INSERT_TAIL(&acpi_taskq, wq, next)do { (wq)->next.sqe_next = ((void *)0); *(&acpi_taskq) ->sqh_last = (wq); (&acpi_taskq)->sqh_last = &( wq)->next.sqe_next; } while (0); |
1810 | splx(s)spllower(s); |
1811 | } |
1812 | |
1813 | int |
1814 | acpi_dotask(struct acpi_softc *sc) |
1815 | { |
1816 | struct acpi_taskq *wq; |
1817 | int s; |
1818 | |
1819 | s = splbio()splraise(0x6); |
1820 | if (SIMPLEQ_EMPTY(&acpi_taskq)(((&acpi_taskq)->sqh_first) == ((void *)0))) { |
1821 | splx(s)spllower(s); |
1822 | |
1823 | /* we don't have anything to do */ |
1824 | return (0); |
1825 | } |
1826 | wq = SIMPLEQ_FIRST(&acpi_taskq)((&acpi_taskq)->sqh_first); |
1827 | SIMPLEQ_REMOVE_HEAD(&acpi_taskq, next)do { if (((&acpi_taskq)->sqh_first = (&acpi_taskq) ->sqh_first->next.sqe_next) == ((void *)0)) (&acpi_taskq )->sqh_last = &(&acpi_taskq)->sqh_first; } while (0); |
1828 | splx(s)spllower(s); |
1829 | |
1830 | wq->handler(wq->arg0, wq->arg1); |
1831 | |
1832 | free(wq, M_DEVBUF2, sizeof(*wq)); |
1833 | |
1834 | /* We did something */ |
1835 | return (1); |
1836 | } |
1837 | |
1838 | #ifndef SMALL_KERNEL |
1839 | |
1840 | int |
1841 | is_ata(struct aml_node *node) |
1842 | { |
1843 | return (aml_searchname(node, "_GTM") != NULL((void *)0) || |
1844 | aml_searchname(node, "_GTF") != NULL((void *)0) || |
1845 | aml_searchname(node, "_STM") != NULL((void *)0) || |
1846 | aml_searchname(node, "_SDD") != NULL((void *)0)); |
1847 | } |
1848 | |
1849 | int |
1850 | is_ejectable(struct aml_node *node) |
1851 | { |
1852 | return (aml_searchname(node, "_EJ0") != NULL((void *)0)); |
1853 | } |
1854 | |
1855 | int |
1856 | is_ejectable_bay(struct aml_node *node) |
1857 | { |
1858 | return ((is_ata(node) || is_ata(node->parent)) && is_ejectable(node)); |
1859 | } |
1860 | |
1861 | #if NWD1 > 0 |
1862 | int |
1863 | acpiide_notify(struct aml_node *node, int ntype, void *arg) |
1864 | { |
1865 | struct idechnl *ide = arg; |
1866 | struct acpi_softc *sc = ide->sc; |
1867 | struct pciide_softc *wsc; |
1868 | struct device *dev; |
1869 | int b,d,f; |
1870 | int64_t sta; |
1871 | |
1872 | if (aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &sta) != 0) |
1873 | return (0); |
1874 | |
1875 | dnprintf(10, "IDE notify! %s %d status:%llx\n", aml_nodename(node), |
1876 | ntype, sta); |
1877 | |
1878 | /* Walk device list looking for IDE device match */ |
1879 | TAILQ_FOREACH(dev, &alldevs, dv_list)for((dev) = ((&alldevs)->tqh_first); (dev) != ((void * )0); (dev) = ((dev)->dv_list.tqe_next)) { |
1880 | if (strcmp(dev->dv_cfdata->cf_driver->cd_name, "pciide")) |
1881 | continue; |
1882 | |
1883 | wsc = (struct pciide_softc *)dev; |
1884 | pci_decompose_tag(NULL((void *)0), wsc->sc_tag, &b, &d, &f); |
1885 | if (b != ACPI_PCI_BUS(ide->addr)(uint8_t)((ide->addr) >> 40) || |
1886 | d != ACPI_PCI_DEV(ide->addr)(uint8_t)((ide->addr) >> 32) || |
1887 | f != ACPI_PCI_FN(ide->addr)(uint16_t)((ide->addr) >> 16)) |
1888 | continue; |
1889 | dnprintf(10, "Found pciide: %s %x.%x.%x channel:%llx\n", |
1890 | dev->dv_xname, b,d,f, ide->chnl); |
1891 | |
1892 | if (sta == 0 && ide->sta) |
1893 | wdcdetach( |
1894 | &wsc->pciide_channels[ide->chnl].wdc_channel, 0); |
1895 | else if (sta && !ide->sta) |
1896 | wdcattach( |
1897 | &wsc->pciide_channels[ide->chnl].wdc_channel); |
1898 | ide->sta = sta; |
1899 | } |
1900 | return (0); |
1901 | } |
1902 | |
1903 | int |
1904 | acpi_foundide(struct aml_node *node, void *arg) |
1905 | { |
1906 | struct acpi_softc *sc = arg; |
1907 | struct aml_node *pp; |
1908 | struct idechnl *ide; |
1909 | union amlpci_t pi; |
1910 | int lvl; |
1911 | |
1912 | /* Check if this is an ejectable bay */ |
1913 | if (!is_ejectable_bay(node)) |
1914 | return (0); |
1915 | |
1916 | ide = malloc(sizeof(struct idechnl), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008); |
1917 | ide->sc = sc; |
1918 | |
1919 | /* GTM/GTF can be at 2/3 levels: pciX.ideX.channelX[.driveX] */ |
1920 | lvl = 0; |
1921 | for (pp=node->parent; pp; pp=pp->parent) { |
1922 | lvl++; |
1923 | if (aml_searchname(pp, "_HID")) |
1924 | break; |
1925 | } |
1926 | |
1927 | /* Get PCI address and channel */ |
1928 | if (lvl == 3) { |
1929 | aml_evalinteger(sc, node->parent, "_ADR", 0, NULL((void *)0), |
1930 | &ide->chnl); |
1931 | aml_rdpciaddr(node->parent->parent, &pi); |
1932 | ide->addr = pi.addr; |
1933 | } else if (lvl == 4) { |
1934 | aml_evalinteger(sc, node->parent->parent, "_ADR", 0, NULL((void *)0), |
1935 | &ide->chnl); |
1936 | aml_rdpciaddr(node->parent->parent->parent, &pi); |
1937 | ide->addr = pi.addr; |
1938 | } |
1939 | dnprintf(10, "%s %llx channel:%llx\n", |
1940 | aml_nodename(node), ide->addr, ide->chnl); |
1941 | |
1942 | aml_evalinteger(sc, node, "_STA", 0, NULL((void *)0), &ide->sta); |
1943 | dnprintf(10, "Got Initial STA: %llx\n", ide->sta); |
1944 | |
1945 | aml_register_notify(node, "acpiide", acpiide_notify, ide, 0); |
1946 | return (0); |
1947 | } |
1948 | #endif /* NWD > 0 */ |
1949 | |
1950 | void |
1951 | acpi_sleep_task(void *arg0, int sleepmode) |
1952 | { |
1953 | struct acpi_softc *sc = arg0; |
1954 | |
1955 | /* System goes to sleep here.. */ |
1956 | acpi_sleep_state(sc, sleepmode); |
1957 | /* Tell userland to recheck A/C and battery status */ |
1958 | acpi_record_event(sc, APM_POWER_CHANGE0x0006); |
1959 | } |
1960 | |
1961 | #endif /* SMALL_KERNEL */ |
1962 | |
1963 | void |
1964 | acpi_reset(void) |
1965 | { |
1966 | uint32_t reset_as, reset_len; |
1967 | uint32_t value; |
1968 | struct acpi_softc *sc = acpi_softc; |
1969 | struct acpi_fadt *fadt = sc->sc_fadt; |
1970 | |
1971 | if (acpi_enabled == 0) |
1972 | return; |
1973 | |
1974 | /* |
1975 | * RESET_REG_SUP is not properly set in some implementations, |
1976 | * but not testing against it breaks more machines than it fixes |
1977 | */ |
1978 | if (fadt->hdr_revisionhdr.revision <= 1 || |
1979 | !(fadt->flags & FADT_RESET_REG_SUP0x00000400) || fadt->reset_reg.address == 0) |
1980 | return; |
1981 | |
1982 | value = fadt->reset_value; |
1983 | |
1984 | reset_as = fadt->reset_reg.register_bit_width / 8; |
1985 | if (reset_as == 0) |
1986 | reset_as = 1; |
1987 | |
1988 | reset_len = fadt->reset_reg.access_size; |
1989 | if (reset_len == 0) |
1990 | reset_len = reset_as; |
1991 | |
1992 | acpi_gasio(sc, ACPI_IOWRITE1, |
1993 | fadt->reset_reg.address_space_id, |
1994 | fadt->reset_reg.address, reset_as, reset_len, &value); |
1995 | |
1996 | delay(100000)(*delay_func)(100000); |
1997 | } |
1998 | |
1999 | void |
2000 | acpi_gpe_task(void *arg0, int gpe) |
2001 | { |
2002 | struct acpi_softc *sc = acpi_softc; |
2003 | struct gpe_block *pgpe = &sc->gpe_table[gpe]; |
2004 | |
2005 | dnprintf(10, "handle gpe: %x\n", gpe); |
2006 | if (pgpe->handler && pgpe->active) { |
2007 | pgpe->active = 0; |
2008 | pgpe->handler(sc, gpe, pgpe->arg); |
2009 | } |
2010 | } |
2011 | |
2012 | void |
2013 | acpi_pbtn_task(void *arg0, int dummy) |
2014 | { |
2015 | struct acpi_softc *sc = arg0; |
2016 | extern int pwr_action; |
2017 | uint16_t en; |
2018 | int s; |
2019 | |
2020 | dnprintf(1,"power button pressed\n"); |
2021 | |
2022 | /* Reset the latch and re-enable the GPE */ |
2023 | s = splbio()splraise(0x6); |
2024 | en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0); |
2025 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, |
2026 | en | ACPI_PM1_PWRBTN_EN0x0100); |
2027 | splx(s)spllower(s); |
2028 | |
2029 | switch (pwr_action) { |
2030 | case 0: |
2031 | break; |
2032 | case 1: |
2033 | acpi_addtask(sc, acpi_powerdown_task, sc, 0); |
2034 | break; |
2035 | #ifndef SMALL_KERNEL |
2036 | case 2: |
2037 | acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_SUSPEND0x01); |
2038 | break; |
2039 | #endif |
2040 | } |
2041 | } |
2042 | |
2043 | void |
2044 | acpi_sbtn_task(void *arg0, int dummy) |
2045 | { |
2046 | struct acpi_softc *sc = arg0; |
2047 | uint16_t en; |
2048 | int s; |
2049 | |
2050 | dnprintf(1,"sleep button pressed\n"); |
2051 | aml_notify_dev(ACPI_DEV_SBD"PNP0C0E", 0x80); |
2052 | |
2053 | /* Reset the latch and re-enable the GPE */ |
2054 | s = splbio()splraise(0x6); |
2055 | en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0); |
2056 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, |
2057 | en | ACPI_PM1_SLPBTN_EN0x0200); |
2058 | splx(s)spllower(s); |
2059 | } |
2060 | |
2061 | void |
2062 | acpi_powerdown_task(void *arg0, int dummy) |
2063 | { |
2064 | extern int allowpowerdown; |
2065 | |
2066 | if (allowpowerdown == 1) { |
2067 | allowpowerdown = 0; |
2068 | prsignal(initprocess, SIGUSR2)ptsignal((initprocess)->ps_mainproc, (31), SPROCESS); |
2069 | } |
2070 | } |
2071 | |
2072 | int |
2073 | acpi_interrupt(void *arg) |
2074 | { |
2075 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
2076 | uint32_t processed = 0, idx, jdx; |
2077 | uint16_t sts, en; |
2078 | int gpe; |
2079 | |
2080 | dnprintf(40, "ACPI Interrupt\n"); |
2081 | for (idx = 0; idx < sc->sc_lastgpe; idx += 8) { |
2082 | sts = acpi_read_pmreg(sc, ACPIREG_GPE_STS0x11, idx>>3); |
2083 | en = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12, idx>>3); |
2084 | if (en & sts) { |
2085 | dnprintf(10, "GPE block: %.2x %.2x %.2x\n", idx, sts, |
2086 | en); |
2087 | /* Mask the GPE until it is serviced */ |
2088 | acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, idx>>3, en & ~sts); |
2089 | for (jdx = 0; jdx < 8; jdx++) { |
2090 | if (!(en & sts & (1L << jdx))) |
2091 | continue; |
2092 | |
2093 | /* Signal this GPE */ |
2094 | gpe = idx + jdx; |
2095 | if (sc->gpe_table[gpe].flags & GPE_DIRECT0x04) { |
2096 | dnprintf(10, "directly handle gpe: %x\n", |
2097 | gpe); |
2098 | sc->gpe_table[gpe].handler(sc, gpe, |
2099 | sc->gpe_table[gpe].arg); |
2100 | if (sc->gpe_table[gpe].flags & |
2101 | GPE_LEVEL0x01) |
2102 | acpi_gpe(sc, gpe, |
2103 | sc->gpe_table[gpe].arg); |
2104 | } else { |
2105 | sc->gpe_table[gpe].active = 1; |
2106 | dnprintf(10, "queue gpe: %x\n", gpe); |
2107 | acpi_addtask(sc, acpi_gpe_task, NULL((void *)0), |
2108 | gpe); |
2109 | } |
2110 | |
2111 | /* |
2112 | * Edge interrupts need their STS bits cleared |
2113 | * now. Level interrupts will have their STS |
2114 | * bits cleared just before they are |
2115 | * re-enabled. |
2116 | */ |
2117 | if (sc->gpe_table[gpe].flags & GPE_EDGE0x02) |
2118 | acpi_write_pmreg(sc, |
2119 | ACPIREG_GPE_STS0x11, idx>>3, 1L << jdx); |
2120 | |
2121 | processed = 1; |
2122 | } |
2123 | } |
2124 | } |
2125 | |
2126 | sts = acpi_read_pmreg(sc, ACPIREG_PM1_STS0x0E, 0); |
2127 | en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0); |
2128 | if (sts & en) { |
2129 | dnprintf(10,"GEN interrupt: %.4x\n", sts & en); |
2130 | sts &= en; |
2131 | if (sts & ACPI_PM1_PWRBTN_STS0x0100) { |
2132 | /* Mask and acknowledge */ |
2133 | en &= ~ACPI_PM1_PWRBTN_EN0x0100; |
2134 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en); |
2135 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, |
2136 | ACPI_PM1_PWRBTN_STS0x0100); |
2137 | sts &= ~ACPI_PM1_PWRBTN_STS0x0100; |
2138 | |
2139 | acpi_addtask(sc, acpi_pbtn_task, sc, 0); |
2140 | } |
2141 | if (sts & ACPI_PM1_SLPBTN_STS0x0200) { |
2142 | /* Mask and acknowledge */ |
2143 | en &= ~ACPI_PM1_SLPBTN_EN0x0200; |
2144 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en); |
2145 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, |
2146 | ACPI_PM1_SLPBTN_STS0x0200); |
2147 | sts &= ~ACPI_PM1_SLPBTN_STS0x0200; |
2148 | |
2149 | acpi_addtask(sc, acpi_sbtn_task, sc, 0); |
2150 | } |
2151 | if (sts) { |
2152 | printf("%s: PM1 stuck (en 0x%x st 0x%x), clearing\n", |
2153 | sc->sc_dev.dv_xname, en, sts); |
2154 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en & ~sts); |
2155 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, sts); |
2156 | } |
2157 | processed = 1; |
2158 | } |
2159 | |
2160 | if (processed) { |
2161 | acpi_wakeup(sc); |
2162 | } |
2163 | |
2164 | return (processed); |
2165 | } |
2166 | |
2167 | int |
2168 | acpi_add_device(struct aml_node *node, void *arg) |
2169 | { |
2170 | static int nacpicpus = 0; |
2171 | struct device *self = arg; |
2172 | struct acpi_softc *sc = arg; |
2173 | struct acpi_attach_args aaa; |
2174 | struct aml_value res; |
2175 | CPU_INFO_ITERATORint cii; |
2176 | struct cpu_info *ci; |
2177 | int proc_id = -1; |
2178 | |
2179 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
2180 | aaa.aaa_node = node; |
2181 | aaa.aaa_iot = sc->sc_iot; |
2182 | aaa.aaa_memt = sc->sc_memt; |
2183 | if (node == NULL((void *)0) || node->value == NULL((void *)0)) |
2184 | return 0; |
2185 | |
2186 | switch (node->value->type) { |
2187 | case AML_OBJTYPE_PROCESSOR: |
2188 | if (sc->sc_skip_processor != 0) |
2189 | return 0; |
2190 | if (nacpicpus >= ncpus) |
2191 | return 0; |
2192 | if (aml_evalnode(sc, aaa.aaa_node, 0, NULL((void *)0), &res) == 0) { |
2193 | if (res.type == AML_OBJTYPE_PROCESSOR) |
2194 | proc_id = res.v_processor_.vprocessor.proc_id; |
2195 | aml_freevalue(&res); |
2196 | } |
2197 | CPU_INFO_FOREACH(cii, ci)for (cii = 0, ci = cpu_info_list; ci != ((void *)0); ci = ci-> ci_next) { |
2198 | if (ci->ci_acpi_proc_id == proc_id) |
2199 | break; |
2200 | } |
2201 | if (ci == NULL((void *)0)) |
2202 | return 0; |
2203 | nacpicpus++; |
2204 | |
2205 | aaa.aaa_name = "acpicpu"; |
2206 | break; |
2207 | case AML_OBJTYPE_THERMZONE: |
2208 | aaa.aaa_name = "acpitz"; |
2209 | break; |
2210 | case AML_OBJTYPE_POWERRSRC: |
2211 | aaa.aaa_name = "acpipwrres"; |
2212 | break; |
2213 | default: |
2214 | return 0; |
2215 | } |
2216 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
2217 | return 0; |
2218 | } |
2219 | |
2220 | void |
2221 | acpi_enable_onegpe(struct acpi_softc *sc, int gpe) |
2222 | { |
2223 | uint8_t mask, en; |
2224 | |
2225 | /* Read enabled register */ |
2226 | mask = (1L << (gpe & 7)); |
2227 | en = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3); |
2228 | dnprintf(50, "enabling GPE %.2x (current: %sabled) %.2x\n", |
2229 | gpe, (en & mask) ? "en" : "dis", en); |
2230 | acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3, en | mask); |
2231 | } |
2232 | |
2233 | /* Clear all GPEs */ |
2234 | void |
2235 | acpi_disable_allgpes(struct acpi_softc *sc) |
2236 | { |
2237 | int idx; |
2238 | |
2239 | for (idx = 0; idx < sc->sc_lastgpe; idx += 8) { |
2240 | acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, idx >> 3, 0); |
2241 | acpi_write_pmreg(sc, ACPIREG_GPE_STS0x11, idx >> 3, -1); |
2242 | } |
2243 | } |
2244 | |
2245 | /* Enable runtime GPEs */ |
2246 | void |
2247 | acpi_enable_rungpes(struct acpi_softc *sc) |
2248 | { |
2249 | int idx; |
2250 | |
2251 | for (idx = 0; idx < sc->sc_lastgpe; idx++) |
2252 | if (sc->gpe_table[idx].handler) |
2253 | acpi_enable_onegpe(sc, idx); |
2254 | } |
2255 | |
2256 | /* Enable wakeup GPEs */ |
2257 | void |
2258 | acpi_enable_wakegpes(struct acpi_softc *sc, int state) |
2259 | { |
2260 | struct acpi_wakeq *wentry; |
2261 | |
2262 | SIMPLEQ_FOREACH(wentry, &sc->sc_wakedevs, q_next)for((wentry) = ((&sc->sc_wakedevs)->sqh_first); (wentry ) != ((void *)0); (wentry) = ((wentry)->q_next.sqe_next)) { |
2263 | dnprintf(10, "%.4s(S%d) gpe %.2x\n", wentry->q_node->name, |
2264 | wentry->q_state, |
2265 | wentry->q_gpe); |
2266 | if (state <= wentry->q_state) |
2267 | acpi_enable_onegpe(sc, wentry->q_gpe); |
2268 | } |
2269 | } |
2270 | |
2271 | int |
2272 | acpi_set_gpehandler(struct acpi_softc *sc, int gpe, int (*handler) |
2273 | (struct acpi_softc *, int, void *), void *arg, int flags) |
2274 | { |
2275 | struct gpe_block *ptbl; |
2276 | |
2277 | ptbl = acpi_find_gpe(sc, gpe); |
2278 | if (ptbl == NULL((void *)0) || handler == NULL((void *)0)) |
2279 | return -EINVAL22; |
2280 | if ((flags & GPE_LEVEL0x01) && (flags & GPE_EDGE0x02)) |
2281 | return -EINVAL22; |
2282 | if (!(flags & (GPE_LEVEL0x01 | GPE_EDGE0x02))) |
2283 | return -EINVAL22; |
2284 | if (ptbl->handler != NULL((void *)0) && !(flags & GPE_DIRECT0x04)) |
2285 | printf("%s: GPE 0x%.2x already enabled\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), gpe); |
2286 | |
2287 | dnprintf(50, "Adding GPE handler 0x%.2x (%s)\n", gpe, |
2288 | (flags & GPE_EDGE ? "edge" : "level")); |
2289 | ptbl->handler = handler; |
2290 | ptbl->arg = arg; |
2291 | ptbl->flags = flags; |
2292 | |
2293 | return (0); |
2294 | } |
2295 | |
2296 | int |
2297 | acpi_gpe(struct acpi_softc *sc, int gpe, void *arg) |
2298 | { |
2299 | struct aml_node *node = arg; |
2300 | uint8_t mask, en; |
2301 | |
2302 | dnprintf(10, "handling GPE %.2x\n", gpe); |
2303 | aml_evalnode(sc, node, 0, NULL((void *)0), NULL((void *)0)); |
2304 | |
2305 | mask = (1L << (gpe & 7)); |
2306 | if (sc->gpe_table[gpe].flags & GPE_LEVEL0x01) |
2307 | acpi_write_pmreg(sc, ACPIREG_GPE_STS0x11, gpe>>3, mask); |
2308 | en = acpi_read_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3); |
2309 | acpi_write_pmreg(sc, ACPIREG_GPE_EN0x12, gpe>>3, en | mask); |
2310 | return (0); |
2311 | } |
2312 | |
2313 | /* Discover Devices that can wakeup the system |
2314 | * _PRW returns a package |
2315 | * pkg[0] = integer (FADT gpe bit) or package (gpe block,gpe bit) |
2316 | * pkg[1] = lowest sleep state |
2317 | * pkg[2+] = power resource devices (optional) |
2318 | * |
2319 | * To enable wakeup devices: |
2320 | * Evaluate _ON method in each power resource device |
2321 | * Evaluate _PSW method |
2322 | */ |
2323 | int |
2324 | acpi_foundprw(struct aml_node *node, void *arg) |
2325 | { |
2326 | struct acpi_softc *sc = arg; |
2327 | struct acpi_wakeq *wq; |
2328 | int64_t sta; |
2329 | |
2330 | sta = acpi_getsta(sc, node->parent); |
2331 | if ((sta & STA_PRESENT(1L << 0)) == 0) |
2332 | return 0; |
2333 | |
2334 | wq = malloc(sizeof(struct acpi_wakeq), M_DEVBUF2, M_NOWAIT0x0002 | M_ZERO0x0008); |
2335 | if (wq == NULL((void *)0)) |
2336 | return 0; |
2337 | |
2338 | wq->q_wakepkg = malloc(sizeof(struct aml_value), M_DEVBUF2, |
2339 | M_NOWAIT0x0002 | M_ZERO0x0008); |
2340 | if (wq->q_wakepkg == NULL((void *)0)) { |
2341 | free(wq, M_DEVBUF2, sizeof(*wq)); |
2342 | return 0; |
2343 | } |
2344 | dnprintf(10, "Found _PRW (%s)\n", node->parent->name); |
2345 | aml_evalnode(sc, node, 0, NULL((void *)0), wq->q_wakepkg); |
2346 | wq->q_node = node->parent; |
2347 | wq->q_gpe = -1; |
2348 | |
2349 | /* Get GPE of wakeup device, and lowest sleep level */ |
2350 | if (wq->q_wakepkg->type == AML_OBJTYPE_PACKAGE && |
2351 | wq->q_wakepkg->length >= 2) { |
2352 | if (wq->q_wakepkg->v_package_.vpackage[0]->type == AML_OBJTYPE_INTEGER) |
2353 | wq->q_gpe = wq->q_wakepkg->v_package_.vpackage[0]->v_integer_.vinteger; |
2354 | if (wq->q_wakepkg->v_package_.vpackage[1]->type == AML_OBJTYPE_INTEGER) |
2355 | wq->q_state = wq->q_wakepkg->v_package_.vpackage[1]->v_integer_.vinteger; |
2356 | } |
2357 | SIMPLEQ_INSERT_TAIL(&sc->sc_wakedevs, wq, q_next)do { (wq)->q_next.sqe_next = ((void *)0); *(&sc->sc_wakedevs )->sqh_last = (wq); (&sc->sc_wakedevs)->sqh_last = &(wq)->q_next.sqe_next; } while (0); |
2358 | return 0; |
2359 | } |
2360 | |
2361 | struct gpe_block * |
2362 | acpi_find_gpe(struct acpi_softc *sc, int gpe) |
2363 | { |
2364 | if (gpe >= sc->sc_lastgpe) |
2365 | return NULL((void *)0); |
2366 | return &sc->gpe_table[gpe]; |
2367 | } |
2368 | |
2369 | void |
2370 | acpi_init_gpes(struct acpi_softc *sc) |
2371 | { |
2372 | struct aml_node *gpe; |
2373 | char name[12]; |
2374 | int idx; |
2375 | |
2376 | sc->sc_lastgpe = sc->sc_fadt->gpe0_blk_len << 2; |
2377 | dnprintf(50, "Last GPE: %.2x\n", sc->sc_lastgpe); |
2378 | |
2379 | /* Allocate GPE table */ |
2380 | sc->gpe_table = mallocarray(sc->sc_lastgpe, sizeof(struct gpe_block), |
2381 | M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); |
2382 | |
2383 | /* Clear GPE status */ |
2384 | acpi_disable_allgpes(sc); |
2385 | for (idx = 0; idx < sc->sc_lastgpe; idx++) { |
2386 | /* Search Level-sensitive GPES */ |
2387 | snprintf(name, sizeof(name), "\\_GPE._L%.2X", idx); |
2388 | gpe = aml_searchname(&aml_root, name); |
2389 | if (gpe != NULL((void *)0)) |
2390 | acpi_set_gpehandler(sc, idx, acpi_gpe, gpe, GPE_LEVEL0x01); |
2391 | if (gpe == NULL((void *)0)) { |
2392 | /* Search Edge-sensitive GPES */ |
2393 | snprintf(name, sizeof(name), "\\_GPE._E%.2X", idx); |
2394 | gpe = aml_searchname(&aml_root, name); |
2395 | if (gpe != NULL((void *)0)) |
2396 | acpi_set_gpehandler(sc, idx, acpi_gpe, gpe, |
2397 | GPE_EDGE0x02); |
2398 | } |
2399 | } |
2400 | aml_find_node(&aml_root, "_PRW", acpi_foundprw, sc); |
2401 | } |
2402 | |
2403 | void |
2404 | acpi_init_pm(struct acpi_softc *sc) |
2405 | { |
2406 | sc->sc_tts = aml_searchname(&aml_root, "_TTS"); |
2407 | sc->sc_pts = aml_searchname(&aml_root, "_PTS"); |
2408 | sc->sc_wak = aml_searchname(&aml_root, "_WAK"); |
2409 | sc->sc_bfs = aml_searchname(&aml_root, "_BFS"); |
2410 | sc->sc_gts = aml_searchname(&aml_root, "_GTS"); |
2411 | sc->sc_sst = aml_searchname(&aml_root, "_SI_._SST"); |
2412 | } |
2413 | |
2414 | #ifndef SMALL_KERNEL |
2415 | |
2416 | void |
2417 | acpi_init_states(struct acpi_softc *sc) |
2418 | { |
2419 | struct aml_value res; |
2420 | char name[8]; |
2421 | int i; |
2422 | |
2423 | printf("\n%s: sleep states", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
2424 | for (i = ACPI_STATE_S00; i <= ACPI_STATE_S55; i++) { |
2425 | snprintf(name, sizeof(name), "_S%d_", i); |
2426 | sc->sc_sleeptype[i].slp_typa = -1; |
2427 | sc->sc_sleeptype[i].slp_typb = -1; |
2428 | if (aml_evalname(sc, &aml_root, name, 0, NULL((void *)0), &res) == 0) { |
2429 | if (res.type == AML_OBJTYPE_PACKAGE) { |
2430 | sc->sc_sleeptype[i].slp_typa = |
2431 | aml_val2int(res.v_package_.vpackage[0]); |
2432 | sc->sc_sleeptype[i].slp_typb = |
2433 | aml_val2int(res.v_package_.vpackage[1]); |
2434 | printf(" S%d", i); |
2435 | } |
2436 | aml_freevalue(&res); |
2437 | } |
2438 | } |
2439 | } |
2440 | |
2441 | void |
2442 | acpi_sleep_pm(struct acpi_softc *sc, int state) |
2443 | { |
2444 | uint16_t rega, regb, regra, regrb; |
2445 | int retry = 0; |
2446 | |
2447 | intr_disable(); |
2448 | |
2449 | /* Clear WAK_STS bit */ |
2450 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_WAK_STS0x8000); |
2451 | |
2452 | /* Disable BM arbitration at deep sleep and beyond */ |
2453 | if (state >= ACPI_STATE_S33 && |
2454 | sc->sc_fadt->pm2_cnt_blk && sc->sc_fadt->pm2_cnt_len) |
2455 | acpi_write_pmreg(sc, ACPIREG_PM2_CNT0x06, 0, ACPI_PM2_ARB_DIS0x0001); |
2456 | |
2457 | /* Write SLP_TYPx values */ |
2458 | rega = acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0); |
2459 | regb = acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0); |
2460 | rega &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000); |
2461 | regb &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000); |
2462 | rega |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[state].slp_typa)((sc->sc_sleeptype[state].slp_typa) << 10); |
2463 | regb |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[state].slp_typb)((sc->sc_sleeptype[state].slp_typb) << 10); |
2464 | acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega); |
2465 | acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb); |
2466 | |
2467 | /* Loop on WAK_STS, setting the SLP_EN bits once in a while */ |
2468 | rega |= ACPI_PM1_SLP_EN0x2000; |
2469 | regb |= ACPI_PM1_SLP_EN0x2000; |
2470 | while (1) { |
2471 | if (retry == 0) { |
2472 | acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega); |
2473 | acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb); |
2474 | } |
2475 | retry = (retry + 1) % 100000; |
2476 | |
2477 | regra = acpi_read_pmreg(sc, ACPIREG_PM1A_STS0x00, 0); |
2478 | regrb = acpi_read_pmreg(sc, ACPIREG_PM1B_STS0x03, 0); |
2479 | if ((regra & ACPI_PM1_WAK_STS0x8000) || |
2480 | (regrb & ACPI_PM1_WAK_STS0x8000)) |
2481 | break; |
2482 | } |
2483 | } |
2484 | |
2485 | uint32_t acpi_force_bm; |
2486 | |
2487 | void |
2488 | acpi_resume_pm(struct acpi_softc *sc, int fromstate) |
2489 | { |
2490 | uint16_t rega, regb, en; |
2491 | |
2492 | /* Write SLP_TYPx values */ |
2493 | rega = acpi_read_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0); |
2494 | regb = acpi_read_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0); |
2495 | rega &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000); |
2496 | regb &= ~(ACPI_PM1_SLP_TYPX_MASK0x1c00 | ACPI_PM1_SLP_EN0x2000); |
2497 | rega |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[ACPI_STATE_S0].slp_typa)((sc->sc_sleeptype[0].slp_typa) << 10); |
2498 | regb |= ACPI_PM1_SLP_TYPX(sc->sc_sleeptype[ACPI_STATE_S0].slp_typb)((sc->sc_sleeptype[0].slp_typb) << 10); |
2499 | acpi_write_pmreg(sc, ACPIREG_PM1A_CNT0x02, 0, rega); |
2500 | acpi_write_pmreg(sc, ACPIREG_PM1B_CNT0x05, 0, regb); |
2501 | |
2502 | /* Force SCI_EN on resume to fix horribly broken machines */ |
2503 | acpi_write_pmreg(sc, ACPIREG_PM1_CNT0x10, 0, |
2504 | ACPI_PM1_SCI_EN0x0001 | acpi_force_bm); |
2505 | |
2506 | /* Clear fixed event status */ |
2507 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_ALL_STS(0x0001 | 0x0010 | 0x0020 | 0x0100 | 0x0200 | 0x0400 | 0x4000 | 0x8000 )); |
2508 | |
2509 | /* acpica-reference.pdf page 148 says do not call _BFS */ |
2510 | /* 1st resume AML step: _BFS(fromstate) */ |
2511 | aml_node_setval(sc, sc->sc_bfs, fromstate); |
2512 | |
2513 | /* Enable runtime GPEs */ |
2514 | acpi_disable_allgpes(sc); |
2515 | acpi_enable_rungpes(sc); |
2516 | |
2517 | acpi_indicator(sc, ACPI_SST_WAKING2); |
2518 | |
2519 | /* 2nd resume AML step: _WAK(fromstate) */ |
2520 | aml_node_setval(sc, sc->sc_wak, fromstate); |
2521 | |
2522 | /* Clear WAK_STS bit */ |
2523 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_WAK_STS0x8000); |
2524 | |
2525 | en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0); |
2526 | if (!(sc->sc_fadt->flags & FADT_PWR_BUTTON0x00000010)) |
2527 | en |= ACPI_PM1_PWRBTN_EN0x0100; |
2528 | if (!(sc->sc_fadt->flags & FADT_SLP_BUTTON0x00000020)) |
2529 | en |= ACPI_PM1_SLPBTN_EN0x0200; |
2530 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en); |
2531 | |
2532 | /* |
2533 | * If PM2 exists, re-enable BM arbitration (reportedly some |
2534 | * BIOS forget to) |
2535 | */ |
2536 | if (sc->sc_fadt->pm2_cnt_blk && sc->sc_fadt->pm2_cnt_len) { |
2537 | rega = acpi_read_pmreg(sc, ACPIREG_PM2_CNT0x06, 0); |
2538 | rega &= ~ACPI_PM2_ARB_DIS0x0001; |
2539 | acpi_write_pmreg(sc, ACPIREG_PM2_CNT0x06, 0, rega); |
2540 | } |
2541 | } |
2542 | |
2543 | /* Set the indicator light to some state */ |
2544 | void |
2545 | acpi_indicator(struct acpi_softc *sc, int led_state) |
2546 | { |
2547 | static int save_led_state = -1; |
2548 | |
2549 | if (save_led_state != led_state) { |
2550 | aml_node_setval(sc, sc->sc_sst, led_state); |
2551 | save_led_state = led_state; |
2552 | } |
2553 | } |
2554 | |
2555 | |
2556 | int |
2557 | acpi_sleep_state(struct acpi_softc *sc, int sleepmode) |
2558 | { |
2559 | extern int perflevel; |
2560 | extern int lid_action; |
2561 | int error = ENXIO6; |
2562 | size_t rndbuflen = 0; |
2563 | char *rndbuf = NULL((void *)0); |
2564 | int state, s; |
2565 | #if NSOFTRAID1 > 0 |
2566 | extern void sr_quiesce(void); |
2567 | #endif |
2568 | |
2569 | switch (sleepmode) { |
2570 | case ACPI_SLEEP_SUSPEND0x01: |
2571 | state = ACPI_STATE_S33; |
2572 | break; |
2573 | case ACPI_SLEEP_HIBERNATE0x02: |
2574 | state = ACPI_STATE_S44; |
2575 | break; |
2576 | default: |
2577 | return (EOPNOTSUPP45); |
2578 | } |
2579 | |
2580 | if (sc->sc_sleeptype[state].slp_typa == -1 || |
2581 | sc->sc_sleeptype[state].slp_typb == -1) { |
2582 | printf("%s: state S%d unavailable\n", |
2583 | sc->sc_dev.dv_xname, state); |
2584 | return (EOPNOTSUPP45); |
2585 | } |
2586 | |
2587 | /* 1st suspend AML step: _TTS(tostate) */ |
2588 | if (aml_node_setval(sc, sc->sc_tts, state) != 0) |
2589 | goto fail_tts; |
2590 | acpi_indicator(sc, ACPI_SST_WAKING2); /* blink */ |
2591 | |
2592 | #if NWSDISPLAY1 > 0 |
2593 | /* |
2594 | * Temporarily release the lock to prevent the X server from |
2595 | * blocking on setting the display brightness. |
2596 | */ |
2597 | rw_exit_write(&sc->sc_lck); |
2598 | wsdisplay_suspend(); |
2599 | rw_enter_write(&sc->sc_lck); |
2600 | #endif /* NWSDISPLAY > 0 */ |
2601 | |
2602 | stop_periodic_resettodr(); |
2603 | |
2604 | #ifdef HIBERNATE1 |
2605 | if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) { |
2606 | /* |
2607 | * Discard useless memory to reduce fragmentation, |
2608 | * and attempt to create a hibernate work area |
2609 | */ |
2610 | hibernate_suspend_bufcache(); |
2611 | uvmpd_hibernate(); |
2612 | if (hibernate_alloc()) { |
2613 | printf("%s: failed to allocate hibernate memory\n", |
2614 | sc->sc_dev.dv_xname); |
2615 | goto fail_alloc; |
2616 | } |
2617 | } |
2618 | #endif /* HIBERNATE */ |
2619 | |
2620 | sensor_quiesce(); |
2621 | if (config_suspend_all(DVACT_QUIESCE2)) |
2622 | goto fail_quiesce; |
2623 | |
2624 | vfs_stall(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc, 1); |
2625 | #if NSOFTRAID1 > 0 |
2626 | sr_quiesce(); |
2627 | #endif |
2628 | bufq_quiesce(); |
2629 | |
2630 | #ifdef MULTIPROCESSOR1 |
2631 | acpi_sleep_mp(); |
2632 | #endif |
2633 | |
2634 | #ifdef HIBERNATE1 |
2635 | if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) { |
2636 | /* |
2637 | * We've just done various forms of syncing to disk |
2638 | * churned lots of memory dirty. We don't need to |
2639 | * save that dirty memory to hibernate, so release it. |
2640 | */ |
2641 | hibernate_suspend_bufcache(); |
2642 | uvmpd_hibernate(); |
2643 | } |
2644 | #endif /* HIBERNATE */ |
2645 | |
2646 | resettodr(); |
2647 | |
2648 | s = splhigh()splraise(0xd); |
2649 | intr_disable(); /* PSL_I for resume; PIC/APIC broken until repair */ |
2650 | cold = 2; /* Force other code to delay() instead of tsleep() */ |
2651 | |
2652 | if (config_suspend_all(DVACT_SUSPEND3) != 0) |
2653 | goto fail_suspend; |
2654 | acpi_sleep_clocks(sc, state); |
2655 | |
2656 | suspend_randomness(); |
2657 | |
2658 | /* 2nd suspend AML step: _PTS(tostate) */ |
2659 | if (aml_node_setval(sc, sc->sc_pts, state) != 0) |
2660 | goto fail_pts; |
2661 | |
2662 | acpibtn_enable_psw(); /* enable _LID for wakeup */ |
2663 | acpi_indicator(sc, ACPI_SST_SLEEPING3); |
2664 | |
2665 | /* 3rd suspend AML step: _GTS(tostate) */ |
2666 | aml_node_setval(sc, sc->sc_gts, state); |
2667 | |
2668 | /* Clear fixed event status */ |
2669 | acpi_write_pmreg(sc, ACPIREG_PM1_STS0x0E, 0, ACPI_PM1_ALL_STS(0x0001 | 0x0010 | 0x0020 | 0x0100 | 0x0200 | 0x0400 | 0x4000 | 0x8000 )); |
2670 | |
2671 | /* Enable wake GPEs */ |
2672 | acpi_disable_allgpes(sc); |
2673 | acpi_enable_wakegpes(sc, state); |
2674 | |
2675 | /* Sleep */ |
2676 | sc->sc_state = state; |
2677 | error = acpi_sleep_cpu(sc, state); |
2678 | sc->sc_state = ACPI_STATE_S00; |
2679 | /* Resume */ |
2680 | |
2681 | #ifdef HIBERNATE1 |
2682 | if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) { |
2683 | uvm_pmr_dirty_everything(); |
2684 | hib_getentropy(&rndbuf, &rndbuflen); |
2685 | } |
2686 | #endif /* HIBERNATE */ |
2687 | |
2688 | acpi_resume_cpu(sc, state); |
2689 | |
2690 | fail_pts: |
2691 | config_suspend_all(DVACT_RESUME4); |
2692 | |
2693 | fail_suspend: |
2694 | cold = 0; |
2695 | intr_enable(); |
2696 | splx(s)spllower(s); |
2697 | |
2698 | acpibtn_disable_psw(); /* disable _LID for wakeup */ |
2699 | |
2700 | inittodr(gettime()); |
2701 | |
2702 | /* 3rd resume AML step: _TTS(runstate) */ |
2703 | aml_node_setval(sc, sc->sc_tts, sc->sc_state); |
2704 | |
2705 | /* force RNG upper level reseed */ |
2706 | resume_randomness(rndbuf, rndbuflen); |
2707 | |
2708 | #ifdef MULTIPROCESSOR1 |
2709 | acpi_resume_mp(); |
2710 | #endif |
2711 | |
2712 | vfs_stall(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc, 0); |
2713 | bufq_restart(); |
2714 | |
2715 | fail_quiesce: |
2716 | config_suspend_all(DVACT_WAKEUP5); |
2717 | sensor_restart(); |
2718 | |
2719 | #ifdef HIBERNATE1 |
2720 | if (sleepmode == ACPI_SLEEP_HIBERNATE0x02) { |
2721 | hibernate_free(); |
2722 | fail_alloc: |
2723 | hibernate_resume_bufcache(); |
2724 | } |
2725 | #endif /* HIBERNATE */ |
2726 | |
2727 | start_periodic_resettodr(); |
2728 | |
2729 | #if NWSDISPLAY1 > 0 |
2730 | rw_exit_write(&sc->sc_lck); |
2731 | wsdisplay_resume(); |
2732 | rw_enter_write(&sc->sc_lck); |
2733 | #endif /* NWSDISPLAY > 0 */ |
2734 | |
2735 | sys_sync(curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc, NULL((void *)0), NULL((void *)0)); |
2736 | |
2737 | /* Restore hw.setperf */ |
2738 | if (cpu_setperf != NULL((void *)0)) |
2739 | cpu_setperf(perflevel); |
2740 | |
2741 | acpi_record_event(sc, APM_NORMAL_RESUME0x0003); |
2742 | acpi_indicator(sc, ACPI_SST_WORKING1); |
2743 | |
2744 | /* If we woke up but all the lids are closed, go back to sleep */ |
2745 | if (acpibtn_numopenlids() == 0 && lid_action != 0) |
2746 | acpi_addtask(sc, acpi_sleep_task, sc, sleepmode); |
2747 | |
2748 | fail_tts: |
2749 | return (error); |
2750 | } |
2751 | |
2752 | /* XXX |
2753 | * We are going to do AML execution but are not in the acpi thread. |
2754 | * We do not know if the acpi thread is sleeping on acpiec in some |
2755 | * intermediate context. Wish us luck. |
2756 | */ |
2757 | void |
2758 | acpi_powerdown(void) |
2759 | { |
2760 | int state = ACPI_STATE_S55, s; |
2761 | struct acpi_softc *sc = acpi_softc; |
2762 | |
2763 | if (acpi_enabled == 0) |
2764 | return; |
2765 | |
2766 | s = splhigh()splraise(0xd); |
Value stored to 's' is never read | |
2767 | intr_disable(); |
2768 | cold = 1; |
2769 | |
2770 | /* 1st powerdown AML step: _PTS(tostate) */ |
2771 | aml_node_setval(sc, sc->sc_pts, state); |
2772 | |
2773 | acpi_disable_allgpes(sc); |
2774 | acpi_enable_wakegpes(sc, state); |
2775 | |
2776 | /* 2nd powerdown AML step: _GTS(tostate) */ |
2777 | aml_node_setval(sc, sc->sc_gts, state); |
2778 | |
2779 | acpi_sleep_pm(sc, state); |
2780 | panic("acpi S5 transition did not happen"); |
2781 | while (1) |
2782 | ; |
2783 | } |
2784 | |
2785 | #endif /* SMALL_KERNEL */ |
2786 | |
2787 | int |
2788 | acpi_map_address(struct acpi_softc *sc, struct acpi_gas *gas, bus_addr_t base, |
2789 | bus_size_t size, bus_space_handle_t *pioh, bus_space_tag_t *piot) |
2790 | { |
2791 | int iospace = GAS_SYSTEM_IOSPACE1; |
2792 | |
2793 | /* No GAS structure, default to I/O space */ |
2794 | if (gas != NULL((void *)0)) { |
2795 | base += gas->address; |
2796 | iospace = gas->address_space_id; |
2797 | } |
2798 | switch (iospace) { |
2799 | case GAS_SYSTEM_MEMORY0: |
2800 | *piot = sc->sc_memt; |
2801 | break; |
2802 | case GAS_SYSTEM_IOSPACE1: |
2803 | *piot = sc->sc_iot; |
2804 | break; |
2805 | default: |
2806 | return -1; |
2807 | } |
2808 | if (bus_space_map(*piot, base, size, 0, pioh)) |
2809 | return -1; |
2810 | |
2811 | return 0; |
2812 | } |
2813 | |
2814 | void |
2815 | acpi_wakeup(void *arg) |
2816 | { |
2817 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
2818 | |
2819 | sc->sc_threadwaiting = 0; |
2820 | wakeup(sc); |
2821 | } |
2822 | |
2823 | |
2824 | void |
2825 | acpi_thread(void *arg) |
2826 | { |
2827 | struct acpi_thread *thread = arg; |
2828 | struct acpi_softc *sc = thread->sc; |
2829 | extern int aml_busy; |
2830 | int s; |
2831 | |
2832 | /* AML/SMI cannot be trusted -- only run on the BSP */ |
2833 | sched_peg_curproc(&cpu_info_primary(*(struct cpu_info *)((char *)&cpu_info_full_primary + 4096 *2 - __builtin_offsetof(struct cpu_info, ci_dev)))); |
2834 | |
2835 | rw_enter_write(&sc->sc_lck); |
2836 | |
2837 | /* |
2838 | * If we have an interrupt handler, we can get notification |
2839 | * when certain status bits changes in the ACPI registers, |
2840 | * so let us enable some events we can forward to userland |
2841 | */ |
2842 | if (sc->sc_interrupt) { |
2843 | int16_t en; |
2844 | |
2845 | dnprintf(1,"slpbtn:%c pwrbtn:%c\n", |
2846 | sc->sc_fadt->flags & FADT_SLP_BUTTON ? 'n' : 'y', |
2847 | sc->sc_fadt->flags & FADT_PWR_BUTTON ? 'n' : 'y'); |
2848 | dnprintf(10, "Enabling acpi interrupts...\n"); |
2849 | sc->sc_threadwaiting = 1; |
2850 | |
2851 | /* Enable Sleep/Power buttons if they exist */ |
2852 | s = splbio()splraise(0x6); |
2853 | en = acpi_read_pmreg(sc, ACPIREG_PM1_EN0x0F, 0); |
2854 | if (!(sc->sc_fadt->flags & FADT_PWR_BUTTON0x00000010)) |
2855 | en |= ACPI_PM1_PWRBTN_EN0x0100; |
2856 | if (!(sc->sc_fadt->flags & FADT_SLP_BUTTON0x00000020)) |
2857 | en |= ACPI_PM1_SLPBTN_EN0x0200; |
2858 | acpi_write_pmreg(sc, ACPIREG_PM1_EN0x0F, 0, en); |
2859 | |
2860 | /* Enable handled GPEs here */ |
2861 | acpi_enable_rungpes(sc); |
2862 | splx(s)spllower(s); |
2863 | } |
2864 | |
2865 | while (thread->running) { |
2866 | s = splbio()splraise(0x6); |
2867 | while (sc->sc_threadwaiting) { |
2868 | dnprintf(10, "acpi thread going to sleep...\n"); |
2869 | rw_exit_write(&sc->sc_lck); |
2870 | tsleep_nsec(sc, PWAIT32, "acpi0", INFSLP0xffffffffffffffffULL); |
2871 | rw_enter_write(&sc->sc_lck); |
2872 | } |
2873 | sc->sc_threadwaiting = 1; |
2874 | splx(s)spllower(s); |
2875 | if (aml_busy) { |
2876 | panic("thread woke up to find aml was busy"); |
2877 | continue; |
2878 | } |
2879 | |
2880 | /* Run ACPI taskqueue */ |
2881 | while(acpi_dotask(acpi_softc)) |
2882 | ; |
2883 | } |
2884 | free(thread, M_DEVBUF2, sizeof(*thread)); |
2885 | |
2886 | kthread_exit(0); |
2887 | } |
2888 | |
2889 | void |
2890 | acpi_create_thread(void *arg) |
2891 | { |
2892 | struct acpi_softc *sc = arg; |
2893 | |
2894 | if (kthread_create(acpi_thread, sc->sc_thread, NULL((void *)0), DEVNAME(sc)((sc)->sc_dev.dv_xname)) |
2895 | != 0) |
2896 | printf("%s: unable to create isr thread, GPEs disabled\n", |
2897 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
2898 | } |
2899 | |
2900 | int |
2901 | acpi_foundec(struct aml_node *node, void *arg) |
2902 | { |
2903 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
2904 | struct device *self = (struct device *)arg; |
2905 | const char *dev; |
2906 | struct aml_value res; |
2907 | struct acpi_attach_args aaa; |
2908 | |
2909 | if (aml_evalnode(sc, node, 0, NULL((void *)0), &res) != 0) |
2910 | return 0; |
2911 | |
2912 | switch (res.type) { |
2913 | case AML_OBJTYPE_STRING: |
2914 | dev = res.v_string_.vstring; |
2915 | break; |
2916 | case AML_OBJTYPE_INTEGER: |
2917 | dev = aml_eisaid(aml_val2int(&res)); |
2918 | break; |
2919 | default: |
2920 | dev = "unknown"; |
2921 | break; |
2922 | } |
2923 | |
2924 | if (strcmp(dev, ACPI_DEV_ECD"PNP0C09")) |
2925 | return 0; |
2926 | |
2927 | /* Check if we're already attached */ |
2928 | if (sc->sc_ec && sc->sc_ec->sc_devnode == node->parent) |
2929 | return 0; |
2930 | |
2931 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
2932 | aaa.aaa_iot = sc->sc_iot; |
2933 | aaa.aaa_memt = sc->sc_memt; |
2934 | aaa.aaa_node = node->parent; |
2935 | aaa.aaa_dev = dev; |
2936 | aaa.aaa_name = "acpiec"; |
2937 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
2938 | aml_freevalue(&res); |
2939 | |
2940 | return 0; |
2941 | } |
2942 | |
2943 | int |
2944 | acpi_foundsony(struct aml_node *node, void *arg) |
2945 | { |
2946 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
2947 | struct device *self = (struct device *)arg; |
2948 | struct acpi_attach_args aaa; |
2949 | |
2950 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
2951 | aaa.aaa_iot = sc->sc_iot; |
2952 | aaa.aaa_memt = sc->sc_memt; |
2953 | aaa.aaa_node = node->parent; |
2954 | aaa.aaa_name = "acpisony"; |
2955 | |
2956 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
2957 | |
2958 | return 0; |
2959 | } |
2960 | |
2961 | /* Support for _DSD Device Properties. */ |
2962 | |
2963 | int |
2964 | acpi_getprop(struct aml_node *node, const char *prop, void *buf, int buflen) |
2965 | { |
2966 | struct aml_value dsd; |
2967 | int i; |
2968 | |
2969 | /* daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */ |
2970 | static uint8_t prop_guid[] = { |
2971 | 0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d, |
2972 | 0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01, |
2973 | }; |
2974 | |
2975 | if (aml_evalname(acpi_softc, node, "_DSD", 0, NULL((void *)0), &dsd)) |
2976 | return -1; |
2977 | |
2978 | if (dsd.type != AML_OBJTYPE_PACKAGE || dsd.length != 2 || |
2979 | dsd.v_package_.vpackage[0]->type != AML_OBJTYPE_BUFFER || |
2980 | dsd.v_package_.vpackage[1]->type != AML_OBJTYPE_PACKAGE) |
2981 | return -1; |
2982 | |
2983 | /* Check UUID. */ |
2984 | if (dsd.v_package_.vpackage[0]->length != sizeof(prop_guid) || |
2985 | memcmp(dsd.v_package[0]->v_buffer, prop_guid,__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid ), (sizeof(prop_guid))) |
2986 | sizeof(prop_guid))__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid ), (sizeof(prop_guid))) != 0) |
2987 | return -1; |
2988 | |
2989 | /* Check properties. */ |
2990 | for (i = 0; i < dsd.v_package_.vpackage[1]->length; i++) { |
2991 | struct aml_value *res = dsd.v_package_.vpackage[1]->v_package_.vpackage[i]; |
2992 | struct aml_value *val; |
2993 | int len; |
2994 | |
2995 | if (res->type != AML_OBJTYPE_PACKAGE || res->length != 2 || |
2996 | res->v_package_.vpackage[0]->type != AML_OBJTYPE_STRING || |
2997 | strcmp(res->v_package_.vpackage[0]->v_string_.vstring, prop) != 0) |
2998 | continue; |
2999 | |
3000 | val = res->v_package_.vpackage[1]; |
3001 | if (val->type == AML_OBJTYPE_OBJREF) |
3002 | val = val->v_objref_.vobjref.ref; |
3003 | |
3004 | len = val->length; |
3005 | switch (val->type) { |
3006 | case AML_OBJTYPE_BUFFER: |
3007 | memcpy(buf, val->v_buffer, min(len, buflen))__builtin_memcpy((buf), (val->_.vbuffer), (min(len, buflen ))); |
3008 | return len; |
3009 | case AML_OBJTYPE_STRING: |
3010 | memcpy(buf, val->v_string, min(len, buflen))__builtin_memcpy((buf), (val->_.vstring), (min(len, buflen ))); |
3011 | return len; |
3012 | } |
3013 | } |
3014 | |
3015 | return -1; |
3016 | } |
3017 | |
3018 | uint32_t |
3019 | acpi_getpropint(struct aml_node *node, const char *prop, uint32_t defval) |
3020 | { |
3021 | struct aml_value dsd; |
3022 | int i; |
3023 | |
3024 | /* daffd814-6eba-4d8c-8a91-bc9bbf4aa301 */ |
3025 | static uint8_t prop_guid[] = { |
3026 | 0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d, |
3027 | 0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01, |
3028 | }; |
3029 | |
3030 | if (aml_evalname(acpi_softc, node, "_DSD", 0, NULL((void *)0), &dsd)) |
3031 | return defval; |
3032 | |
3033 | if (dsd.type != AML_OBJTYPE_PACKAGE || dsd.length != 2 || |
3034 | dsd.v_package_.vpackage[0]->type != AML_OBJTYPE_BUFFER || |
3035 | dsd.v_package_.vpackage[1]->type != AML_OBJTYPE_PACKAGE) |
3036 | return defval; |
3037 | |
3038 | /* Check UUID. */ |
3039 | if (dsd.v_package_.vpackage[0]->length != sizeof(prop_guid) || |
3040 | memcmp(dsd.v_package[0]->v_buffer, prop_guid,__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid ), (sizeof(prop_guid))) |
3041 | sizeof(prop_guid))__builtin_memcmp((dsd._.vpackage[0]->_.vbuffer), (prop_guid ), (sizeof(prop_guid))) != 0) |
3042 | return defval; |
3043 | |
3044 | /* Check properties. */ |
3045 | for (i = 0; i < dsd.v_package_.vpackage[1]->length; i++) { |
3046 | struct aml_value *res = dsd.v_package_.vpackage[1]->v_package_.vpackage[i]; |
3047 | struct aml_value *val; |
3048 | |
3049 | if (res->type != AML_OBJTYPE_PACKAGE || res->length != 2 || |
3050 | res->v_package_.vpackage[0]->type != AML_OBJTYPE_STRING || |
3051 | strcmp(res->v_package_.vpackage[0]->v_string_.vstring, prop) != 0) |
3052 | continue; |
3053 | |
3054 | val = res->v_package_.vpackage[1]; |
3055 | if (val->type == AML_OBJTYPE_OBJREF) |
3056 | val = val->v_objref_.vobjref.ref; |
3057 | |
3058 | if (val->type == AML_OBJTYPE_INTEGER) |
3059 | return val->v_integer_.vinteger; |
3060 | } |
3061 | |
3062 | return defval; |
3063 | } |
3064 | |
3065 | int |
3066 | acpi_parsehid(struct aml_node *node, void *arg, char *outcdev, char *outdev, |
3067 | size_t devlen) |
3068 | { |
3069 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
3070 | struct aml_value res; |
3071 | const char *dev; |
3072 | |
3073 | /* NB aml_eisaid returns a static buffer, this must come first */ |
3074 | if (aml_evalname(acpi_softc, node->parent, "_CID", 0, NULL((void *)0), &res) == 0) { |
3075 | switch (res.type) { |
3076 | case AML_OBJTYPE_STRING: |
3077 | dev = res.v_string_.vstring; |
3078 | break; |
3079 | case AML_OBJTYPE_INTEGER: |
3080 | dev = aml_eisaid(aml_val2int(&res)); |
3081 | break; |
3082 | default: |
3083 | dev = "unknown"; |
3084 | break; |
3085 | } |
3086 | strlcpy(outcdev, dev, devlen); |
3087 | aml_freevalue(&res); |
3088 | |
3089 | dnprintf(10, "compatible with device: %s\n", outcdev); |
3090 | } else { |
3091 | outcdev[0] = '\0'; |
3092 | } |
3093 | |
3094 | dnprintf(10, "found hid device: %s ", node->parent->name); |
3095 | if (aml_evalnode(sc, node, 0, NULL((void *)0), &res) != 0) |
3096 | return (1); |
3097 | |
3098 | switch (res.type) { |
3099 | case AML_OBJTYPE_STRING: |
3100 | dev = res.v_string_.vstring; |
3101 | break; |
3102 | case AML_OBJTYPE_INTEGER: |
3103 | dev = aml_eisaid(aml_val2int(&res)); |
3104 | break; |
3105 | default: |
3106 | dev = "unknown"; |
3107 | break; |
3108 | } |
3109 | dnprintf(10, " device: %s\n", dev); |
3110 | |
3111 | strlcpy(outdev, dev, devlen); |
3112 | |
3113 | aml_freevalue(&res); |
3114 | |
3115 | return (0); |
3116 | } |
3117 | |
3118 | /* Devices for which we don't want to attach a driver */ |
3119 | const char *acpi_skip_hids[] = { |
3120 | "INT0800", /* Intel 82802Firmware Hub Device */ |
3121 | "PNP0000", /* 8259-compatible Programmable Interrupt Controller */ |
3122 | "PNP0001", /* EISA Interrupt Controller */ |
3123 | "PNP0100", /* PC-class System Timer */ |
3124 | "PNP0103", /* HPET System Timer */ |
3125 | "PNP0200", /* PC-class DMA Controller */ |
3126 | "PNP0201", /* EISA DMA Controller */ |
3127 | "PNP0800", /* Microsoft Sound System Compatible Device */ |
3128 | "PNP0C01", /* System Board */ |
3129 | "PNP0C02", /* PNP Motherboard Resources */ |
3130 | "PNP0C04", /* x87-compatible Floating Point Processing Unit */ |
3131 | "PNP0C09", /* Embedded Controller Device */ |
3132 | "PNP0C0F", /* PCI Interrupt Link Device */ |
3133 | NULL((void *)0) |
3134 | }; |
3135 | |
3136 | /* ISA devices for which we attach a driver later */ |
3137 | const char *acpi_isa_hids[] = { |
3138 | "PNP0303", /* IBM Enhanced Keyboard (101/102-key, PS/2 Mouse) */ |
3139 | "PNP0400", /* Standard LPT Parallel Port */ |
3140 | "PNP0401", /* ECP Parallel Port */ |
3141 | "PNP0700", /* PC-class Floppy Disk Controller */ |
3142 | "PNP0F03", /* Microsoft PS/2-style Mouse */ |
3143 | "PNP0F13", /* PS/2 Mouse */ |
3144 | NULL((void *)0) |
3145 | }; |
3146 | |
3147 | void |
3148 | acpi_attach_deps(struct acpi_softc *sc, struct aml_node *node) |
3149 | { |
3150 | struct aml_value res, *val; |
3151 | struct aml_node *dep; |
3152 | int i; |
3153 | |
3154 | if (aml_evalname(sc, node, "_DEP", 0, NULL((void *)0), &res)) |
3155 | return; |
3156 | |
3157 | if (res.type != AML_OBJTYPE_PACKAGE) |
3158 | return; |
3159 | |
3160 | for (i = 0; i < res.length; i++) { |
3161 | val = res.v_package_.vpackage[i]; |
3162 | if (val->type == AML_OBJTYPE_OBJREF) |
3163 | val = val->v_objref_.vobjref.ref; |
3164 | if (val->type != AML_OBJTYPE_DEVICE) |
3165 | continue; |
3166 | dep = val->node; |
3167 | if (dep == NULL((void *)0) || dep->attached) |
3168 | continue; |
3169 | dep = aml_searchname(dep, "_HID"); |
3170 | if (dep) |
3171 | acpi_foundhid(dep, sc); |
3172 | } |
3173 | |
3174 | aml_freevalue(&res); |
3175 | } |
3176 | |
3177 | int |
3178 | acpi_parse_resources(int crsidx, union acpi_resource *crs, void *arg) |
3179 | { |
3180 | struct acpi_attach_args *aaa = arg; |
3181 | int type = AML_CRSTYPE(crs)((crs)->hdr.typecode & 0x80 ? (crs)->hdr.typecode : (crs)->hdr.typecode >> 3); |
3182 | uint8_t flags; |
3183 | |
3184 | switch (type) { |
3185 | case SR_IOPORT0x08: |
3186 | case SR_FIXEDPORT0x09: |
3187 | case LR_MEM240x81: |
3188 | case LR_MEM320x85: |
3189 | case LR_MEM32FIXED0x86: |
3190 | case LR_WORD0x88: |
3191 | case LR_DWORD0x87: |
3192 | case LR_QWORD0x8A: |
3193 | if (aaa->aaa_naddr >= nitems(aaa->aaa_addr)(sizeof((aaa->aaa_addr)) / sizeof((aaa->aaa_addr)[0]))) |
3194 | return 0; |
3195 | break; |
3196 | case SR_IRQ0x04: |
3197 | case LR_EXTIRQ0x89: |
3198 | if (aaa->aaa_nirq >= nitems(aaa->aaa_irq)(sizeof((aaa->aaa_irq)) / sizeof((aaa->aaa_irq)[0]))) |
3199 | return 0; |
3200 | } |
3201 | |
3202 | switch (type) { |
3203 | case SR_IOPORT0x08: |
3204 | case SR_FIXEDPORT0x09: |
3205 | aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_iot; |
3206 | break; |
3207 | case LR_MEM240x81: |
3208 | case LR_MEM320x85: |
3209 | case LR_MEM32FIXED0x86: |
3210 | aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_memt; |
3211 | break; |
3212 | case LR_WORD0x88: |
3213 | case LR_DWORD0x87: |
3214 | case LR_QWORD0x8A: |
3215 | switch (crs->lr_word.type) { |
3216 | case LR_TYPE_MEMORY0: |
3217 | aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_memt; |
3218 | break; |
3219 | case LR_TYPE_IO1: |
3220 | aaa->aaa_bst[aaa->aaa_naddr] = aaa->aaa_iot; |
3221 | break; |
3222 | default: |
3223 | /* Bus number range or something else; skip. */ |
3224 | return 0; |
3225 | } |
3226 | } |
3227 | |
3228 | switch (type) { |
3229 | case SR_IOPORT0x08: |
3230 | aaa->aaa_addr[aaa->aaa_naddr] = crs->sr_ioport._min; |
3231 | aaa->aaa_size[aaa->aaa_naddr] = crs->sr_ioport._len; |
3232 | aaa->aaa_naddr++; |
3233 | break; |
3234 | case SR_FIXEDPORT0x09: |
3235 | aaa->aaa_addr[aaa->aaa_naddr] = crs->sr_fioport._bas; |
3236 | aaa->aaa_size[aaa->aaa_naddr] = crs->sr_fioport._len; |
3237 | aaa->aaa_naddr++; |
3238 | break; |
3239 | case LR_MEM240x81: |
3240 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m24._min; |
3241 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m24._len; |
3242 | aaa->aaa_naddr++; |
3243 | break; |
3244 | case LR_MEM320x85: |
3245 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m32._min; |
3246 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m32._len; |
3247 | aaa->aaa_naddr++; |
3248 | break; |
3249 | case LR_MEM32FIXED0x86: |
3250 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_m32fixed._bas; |
3251 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_m32fixed._len; |
3252 | aaa->aaa_naddr++; |
3253 | break; |
3254 | case LR_WORD0x88: |
3255 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_word._min; |
3256 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_word._len; |
3257 | aaa->aaa_naddr++; |
3258 | break; |
3259 | case LR_DWORD0x87: |
3260 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_dword._min; |
3261 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_dword._len; |
3262 | aaa->aaa_naddr++; |
3263 | break; |
3264 | case LR_QWORD0x8A: |
3265 | aaa->aaa_addr[aaa->aaa_naddr] = crs->lr_qword._min; |
3266 | aaa->aaa_size[aaa->aaa_naddr] = crs->lr_qword._len; |
3267 | aaa->aaa_naddr++; |
3268 | break; |
3269 | case SR_IRQ0x04: |
3270 | aaa->aaa_irq[aaa->aaa_nirq] = ffs(crs->sr_irq.irq_mask) - 1; |
3271 | /* Default is exclusive, active-high, edge triggered. */ |
3272 | if (AML_CRSLEN(crs)((crs)->hdr.typecode & 0x80 ? 3+(crs)->hdr.length : 1+((crs)->hdr.typecode & 0x7)) < 4) |
3273 | flags = SR_IRQ_MODE(1L << 0); |
3274 | else |
3275 | flags = crs->sr_irq.irq_flags; |
3276 | /* Map flags to those of the extended interrupt descriptor. */ |
3277 | if (flags & SR_IRQ_SHR(1L << 4)) |
3278 | aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_SHR(1L << 3); |
3279 | if (flags & SR_IRQ_POLARITY(1L << 3)) |
3280 | aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_POLARITY(1L << 2); |
3281 | if (flags & SR_IRQ_MODE(1L << 0)) |
3282 | aaa->aaa_irq_flags[aaa->aaa_nirq] |= LR_EXTIRQ_MODE(1L << 1); |
3283 | aaa->aaa_nirq++; |
3284 | break; |
3285 | case LR_EXTIRQ0x89: |
3286 | aaa->aaa_irq[aaa->aaa_nirq] = crs->lr_extirq.irq[0]; |
3287 | aaa->aaa_irq_flags[aaa->aaa_nirq] = crs->lr_extirq.flags; |
3288 | aaa->aaa_nirq++; |
3289 | break; |
3290 | } |
3291 | |
3292 | return 0; |
3293 | } |
3294 | |
3295 | void |
3296 | acpi_parse_crs(struct acpi_softc *sc, struct acpi_attach_args *aaa) |
3297 | { |
3298 | struct aml_value res; |
3299 | |
3300 | if (aml_evalname(sc, aaa->aaa_node, "_CRS", 0, NULL((void *)0), &res)) |
3301 | return; |
3302 | |
3303 | aml_parse_resource(&res, acpi_parse_resources, aaa); |
3304 | } |
3305 | |
3306 | int |
3307 | acpi_foundhid(struct aml_node *node, void *arg) |
3308 | { |
3309 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
3310 | struct device *self = (struct device *)arg; |
3311 | char cdev[32]; |
3312 | char dev[32]; |
3313 | struct acpi_attach_args aaa; |
3314 | int64_t sta; |
3315 | int64_t cca; |
3316 | #ifndef SMALL_KERNEL |
3317 | int i; |
3318 | #endif |
3319 | |
3320 | if (acpi_parsehid(node, arg, cdev, dev, sizeof(dev)) != 0) |
3321 | return (0); |
3322 | |
3323 | sta = acpi_getsta(sc, node->parent); |
3324 | if ((sta & STA_PRESENT(1L << 0)) == 0) |
3325 | return (0); |
3326 | |
3327 | if (aml_evalinteger(sc, node->parent, "_CCA", 0, NULL((void *)0), &cca)) |
3328 | cca = 1; |
3329 | |
3330 | acpi_attach_deps(sc, node->parent); |
3331 | |
3332 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
3333 | aaa.aaa_iot = sc->sc_iot; |
3334 | aaa.aaa_memt = sc->sc_memt; |
3335 | aaa.aaa_dmat = cca ? sc->sc_cc_dmat : sc->sc_ci_dmat; |
3336 | aaa.aaa_node = node->parent; |
3337 | aaa.aaa_dev = dev; |
3338 | aaa.aaa_cdev = cdev; |
3339 | acpi_parse_crs(sc, &aaa); |
3340 | |
3341 | #ifndef SMALL_KERNEL |
3342 | if (!strcmp(cdev, ACPI_DEV_MOUSE"PNP0F13")) { |
3343 | for (i = 0; i < nitems(sbtn_pnp)(sizeof((sbtn_pnp)) / sizeof((sbtn_pnp)[0])); i++) { |
3344 | if (!strcmp(dev, sbtn_pnp[i])) { |
3345 | mouse_has_softbtn = 1; |
3346 | break; |
3347 | } |
3348 | } |
3349 | } |
3350 | #endif |
3351 | |
3352 | if (acpi_matchhids(&aaa, acpi_skip_hids, "none") || |
3353 | acpi_matchhids(&aaa, acpi_isa_hids, "none")) |
3354 | return (0); |
3355 | |
3356 | aaa.aaa_dmat = acpi_iommu_device_map(node->parent, aaa.aaa_dmat); |
3357 | |
3358 | if (!node->parent->attached) { |
3359 | node->parent->attached = 1; |
3360 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
3361 | } |
3362 | |
3363 | return (0); |
3364 | } |
3365 | |
3366 | #ifndef SMALL_KERNEL |
3367 | int |
3368 | acpi_founddock(struct aml_node *node, void *arg) |
3369 | { |
3370 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
3371 | struct device *self = (struct device *)arg; |
3372 | struct acpi_attach_args aaa; |
3373 | |
3374 | dnprintf(10, "found dock entry: %s\n", node->parent->name); |
3375 | |
3376 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
3377 | aaa.aaa_iot = sc->sc_iot; |
3378 | aaa.aaa_memt = sc->sc_memt; |
3379 | aaa.aaa_node = node->parent; |
3380 | aaa.aaa_name = "acpidock"; |
3381 | |
3382 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
3383 | |
3384 | return 0; |
3385 | } |
3386 | |
3387 | int |
3388 | acpi_foundvideo(struct aml_node *node, void *arg) |
3389 | { |
3390 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
3391 | struct device *self = (struct device *)arg; |
3392 | struct acpi_attach_args aaa; |
3393 | |
3394 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
3395 | aaa.aaa_iot = sc->sc_iot; |
3396 | aaa.aaa_memt = sc->sc_memt; |
3397 | aaa.aaa_node = node->parent; |
3398 | aaa.aaa_name = "acpivideo"; |
3399 | |
3400 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
3401 | |
3402 | return (0); |
3403 | } |
3404 | |
3405 | int |
3406 | acpi_foundsbs(struct aml_node *node, void *arg) |
3407 | { |
3408 | struct acpi_softc *sc = (struct acpi_softc *)arg; |
3409 | struct device *self = (struct device *)arg; |
3410 | char cdev[32], dev[32]; |
3411 | struct acpi_attach_args aaa; |
3412 | int64_t sta; |
3413 | |
3414 | if (acpi_parsehid(node, arg, cdev, dev, sizeof(dev)) != 0) |
3415 | return (0); |
3416 | |
3417 | sta = acpi_getsta(sc, node->parent); |
3418 | if ((sta & STA_PRESENT(1L << 0)) == 0) |
3419 | return (0); |
3420 | |
3421 | acpi_attach_deps(sc, node->parent); |
3422 | |
3423 | if (strcmp(dev, ACPI_DEV_SBS"ACPI0002") != 0) |
3424 | return (0); |
3425 | |
3426 | if (node->parent->attached) |
3427 | return (0); |
3428 | |
3429 | memset(&aaa, 0, sizeof(aaa))__builtin_memset((&aaa), (0), (sizeof(aaa))); |
3430 | aaa.aaa_iot = sc->sc_iot; |
3431 | aaa.aaa_memt = sc->sc_memt; |
3432 | aaa.aaa_node = node->parent; |
3433 | aaa.aaa_dev = dev; |
3434 | aaa.aaa_cdev = cdev; |
3435 | |
3436 | config_found(self, &aaa, acpi_print)config_found_sm((self), (&aaa), (acpi_print), ((void *)0) ); |
3437 | node->parent->attached = 1; |
3438 | |
3439 | return (0); |
3440 | } |
3441 | |
3442 | int |
3443 | acpiopen(dev_t dev, int flag, int mode, struct proc *p) |
3444 | { |
3445 | int error = 0; |
3446 | struct acpi_softc *sc; |
3447 | int s; |
3448 | |
3449 | if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) != 0 || |
3450 | !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0)])) |
3451 | return (ENXIO6); |
3452 | |
3453 | s = splbio()splraise(0x6); |
3454 | switch (APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0x0f)) { |
3455 | case APMDEV_CTL8: |
3456 | if (!(flag & FWRITE0x0002)) { |
3457 | error = EINVAL22; |
3458 | break; |
3459 | } |
3460 | if (sc->sc_flags & SCFLAG_OWRITE0x0000002) { |
3461 | error = EBUSY16; |
3462 | break; |
3463 | } |
3464 | sc->sc_flags |= SCFLAG_OWRITE0x0000002; |
3465 | break; |
3466 | case APMDEV_NORMAL0: |
3467 | if (!(flag & FREAD0x0001) || (flag & FWRITE0x0002)) { |
3468 | error = EINVAL22; |
3469 | break; |
3470 | } |
3471 | sc->sc_flags |= SCFLAG_OREAD0x0000001; |
3472 | break; |
3473 | default: |
3474 | error = ENXIO6; |
3475 | break; |
3476 | } |
3477 | splx(s)spllower(s); |
3478 | return (error); |
3479 | } |
3480 | |
3481 | int |
3482 | acpiclose(dev_t dev, int flag, int mode, struct proc *p) |
3483 | { |
3484 | int error = 0; |
3485 | struct acpi_softc *sc; |
3486 | int s; |
3487 | |
3488 | if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) != 0 || |
3489 | !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0)])) |
3490 | return (ENXIO6); |
3491 | |
3492 | s = splbio()splraise(0x6); |
3493 | switch (APMDEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0x0f)) { |
3494 | case APMDEV_CTL8: |
3495 | sc->sc_flags &= ~SCFLAG_OWRITE0x0000002; |
3496 | break; |
3497 | case APMDEV_NORMAL0: |
3498 | sc->sc_flags &= ~SCFLAG_OREAD0x0000001; |
3499 | break; |
3500 | default: |
3501 | error = ENXIO6; |
3502 | break; |
3503 | } |
3504 | splx(s)spllower(s); |
3505 | return (error); |
3506 | } |
3507 | |
3508 | int |
3509 | acpiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) |
3510 | { |
3511 | int error = 0; |
3512 | struct acpi_softc *sc; |
3513 | struct acpi_ac *ac; |
3514 | struct acpi_bat *bat; |
3515 | struct acpi_sbs *sbs; |
3516 | struct apm_power_info *pi = (struct apm_power_info *)data; |
3517 | int bats; |
3518 | unsigned int capacity, remaining, minutes, rate; |
3519 | int s; |
3520 | |
3521 | if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) != 0 || |
3522 | !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0)])) |
3523 | return (ENXIO6); |
3524 | |
3525 | s = splbio()splraise(0x6); |
3526 | /* fake APM */ |
3527 | switch (cmd) { |
3528 | case APM_IOC_SUSPEND((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('A')) << 8) | ((2))): |
3529 | case APM_IOC_STANDBY((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('A')) << 8) | ((1))): |
3530 | if ((flag & FWRITE0x0002) == 0) { |
3531 | error = EBADF9; |
3532 | break; |
3533 | } |
3534 | acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_SUSPEND0x01); |
3535 | acpi_wakeup(sc); |
3536 | break; |
3537 | #ifdef HIBERNATE1 |
3538 | case APM_IOC_HIBERNATE((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) | ((('A')) << 8) | ((9))): |
3539 | if ((error = suser(p)) != 0) |
3540 | break; |
3541 | if ((flag & FWRITE0x0002) == 0) { |
3542 | error = EBADF9; |
3543 | break; |
3544 | } |
3545 | if (get_hibernate_io_function(swdevt[0].sw_dev) == NULL((void *)0)) { |
3546 | error = EOPNOTSUPP45; |
3547 | break; |
3548 | } |
3549 | acpi_addtask(sc, acpi_sleep_task, sc, ACPI_SLEEP_HIBERNATE0x02); |
3550 | acpi_wakeup(sc); |
3551 | break; |
3552 | #endif |
3553 | case APM_IOC_GETPOWER((unsigned long)0x40000000 | ((sizeof(struct apm_power_info) & 0x1fff) << 16) | ((('A')) << 8) | ((3))): |
3554 | /* A/C */ |
3555 | pi->ac_state = APM_AC_UNKNOWN0xff; |
3556 | // XXX replace with new power code |
3557 | SLIST_FOREACH(ac, &sc->sc_ac, aac_link)for((ac) = ((&sc->sc_ac)->slh_first); (ac) != ((void *)0); (ac) = ((ac)->aac_link.sle_next)) { |
3558 | if (ac->aac_softc->sc_ac_stat == PSR_ONLINE0x01) |
3559 | pi->ac_state = APM_AC_ON0x01; |
3560 | else if (ac->aac_softc->sc_ac_stat == PSR_OFFLINE0x00) |
3561 | if (pi->ac_state == APM_AC_UNKNOWN0xff) |
3562 | pi->ac_state = APM_AC_OFF0x00; |
3563 | } |
3564 | |
3565 | /* battery */ |
3566 | pi->battery_state = APM_BATT_UNKNOWN0xff; |
3567 | pi->battery_life = 0; |
3568 | pi->minutes_left = 0; |
3569 | bats = 0; |
3570 | capacity = 0; |
3571 | remaining = 0; |
3572 | minutes = 0; |
3573 | rate = 0; |
3574 | SLIST_FOREACH(bat, &sc->sc_bat, aba_link)for((bat) = ((&sc->sc_bat)->slh_first); (bat) != (( void *)0); (bat) = ((bat)->aba_link.sle_next)) { |
3575 | if (bat->aba_softc->sc_bat_present == 0) |
3576 | continue; |
3577 | |
3578 | if (bat->aba_softc->sc_bix.bix_last_capacity == 0) |
3579 | continue; |
3580 | |
3581 | bats++; |
3582 | capacity += bat->aba_softc->sc_bix.bix_last_capacity; |
3583 | remaining += min(bat->aba_softc->sc_bst.bst_capacity, |
3584 | bat->aba_softc->sc_bix.bix_last_capacity); |
3585 | |
3586 | if (bat->aba_softc->sc_bst.bst_rate == BST_UNKNOWN0xffffffff) |
3587 | continue; |
3588 | else if (bat->aba_softc->sc_bst.bst_rate > 1) |
3589 | rate = bat->aba_softc->sc_bst.bst_rate; |
3590 | |
3591 | minutes += bat->aba_softc->sc_bst.bst_capacity; |
3592 | } |
3593 | |
3594 | SLIST_FOREACH(sbs, &sc->sc_sbs, asbs_link)for((sbs) = ((&sc->sc_sbs)->slh_first); (sbs) != (( void *)0); (sbs) = ((sbs)->asbs_link.sle_next)) { |
3595 | if (sbs->asbs_softc->sc_batteries_present == 0) |
3596 | continue; |
3597 | |
3598 | if (sbs->asbs_softc->sc_battery.rel_charge == 0) |
3599 | continue; |
3600 | |
3601 | bats++; |
3602 | capacity += 100; |
3603 | remaining += min(100, |
3604 | sbs->asbs_softc->sc_battery.rel_charge); |
3605 | |
3606 | if (sbs->asbs_softc->sc_battery.run_time == |
3607 | ACPISBS_VALUE_UNKNOWN65535) |
3608 | continue; |
3609 | |
3610 | rate = 60; /* XXX */ |
3611 | minutes += sbs->asbs_softc->sc_battery.run_time; |
3612 | } |
3613 | |
3614 | if (bats == 0) { |
3615 | pi->battery_state = APM_BATTERY_ABSENT4; |
3616 | pi->battery_life = 0; |
3617 | pi->minutes_left = (unsigned int)-1; |
3618 | break; |
3619 | } |
3620 | |
3621 | if (pi->ac_state == APM_AC_ON0x01 || rate == 0) |
3622 | pi->minutes_left = (unsigned int)-1; |
3623 | else |
3624 | pi->minutes_left = 60 * minutes / rate; |
3625 | |
3626 | /* running on battery */ |
3627 | pi->battery_life = remaining * 100 / capacity; |
3628 | if (pi->battery_life > 50) |
3629 | pi->battery_state = APM_BATT_HIGH0x00; |
3630 | else if (pi->battery_life > 25) |
3631 | pi->battery_state = APM_BATT_LOW0x01; |
3632 | else |
3633 | pi->battery_state = APM_BATT_CRITICAL0x02; |
3634 | |
3635 | break; |
3636 | |
3637 | default: |
3638 | error = ENOTTY25; |
3639 | } |
3640 | |
3641 | splx(s)spllower(s); |
3642 | return (error); |
3643 | } |
3644 | |
3645 | void acpi_filtdetach(struct knote *); |
3646 | int acpi_filtread(struct knote *, long); |
3647 | |
3648 | const struct filterops acpiread_filtops = { |
3649 | .f_flags = FILTEROP_ISFD0x00000001, |
3650 | .f_attach = NULL((void *)0), |
3651 | .f_detach = acpi_filtdetach, |
3652 | .f_event = acpi_filtread, |
3653 | }; |
3654 | |
3655 | int acpi_evindex; |
3656 | |
3657 | int |
3658 | acpi_record_event(struct acpi_softc *sc, u_int type) |
3659 | { |
3660 | if ((sc->sc_flags & SCFLAG_OPEN(0x0000001|0x0000002)) == 0) |
3661 | return (1); |
3662 | |
3663 | acpi_evindex++; |
3664 | KNOTE(sc->sc_note, APM_EVENT_COMPOSE(type, acpi_evindex))do { struct klist *__list = (sc->sc_note); if (__list != ( (void *)0)) knote(__list, ((((acpi_evindex) & 0x7fff) << 16)|((type) & 0xffff))); } while (0); |
3665 | return (0); |
3666 | } |
3667 | |
3668 | void |
3669 | acpi_filtdetach(struct knote *kn) |
3670 | { |
3671 | struct acpi_softc *sc = kn->kn_hook; |
3672 | int s; |
3673 | |
3674 | s = splbio()splraise(0x6); |
3675 | klist_remove_locked(sc->sc_note, kn); |
3676 | splx(s)spllower(s); |
3677 | } |
3678 | |
3679 | int |
3680 | acpi_filtread(struct knote *kn, long hint) |
3681 | { |
3682 | /* XXX weird kqueue_scan() semantics */ |
3683 | if (hint && !kn->kn_datakn_kevent.data) |
3684 | kn->kn_datakn_kevent.data = hint; |
3685 | return (1); |
3686 | } |
3687 | |
3688 | int |
3689 | acpikqfilter(dev_t dev, struct knote *kn) |
3690 | { |
3691 | struct acpi_softc *sc; |
3692 | int s; |
3693 | |
3694 | if (!acpi_cd.cd_ndevs || APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0) != 0 || |
3695 | !(sc = acpi_cd.cd_devs[APMUNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >> 8))&0xf0)])) |
3696 | return (ENXIO6); |
3697 | |
3698 | switch (kn->kn_filterkn_kevent.filter) { |
3699 | case EVFILT_READ(-1): |
3700 | kn->kn_fop = &acpiread_filtops; |
3701 | break; |
3702 | default: |
3703 | return (EINVAL22); |
3704 | } |
3705 | |
3706 | kn->kn_hook = sc; |
3707 | |
3708 | s = splbio()splraise(0x6); |
3709 | klist_insert_locked(sc->sc_note, kn); |
3710 | splx(s)spllower(s); |
3711 | |
3712 | return (0); |
3713 | } |
3714 | |
3715 | #else /* SMALL_KERNEL */ |
3716 | |
3717 | int |
3718 | acpiopen(dev_t dev, int flag, int mode, struct proc *p) |
3719 | { |
3720 | return (ENXIO6); |
3721 | } |
3722 | |
3723 | int |
3724 | acpiclose(dev_t dev, int flag, int mode, struct proc *p) |
3725 | { |
3726 | return (ENXIO6); |
3727 | } |
3728 | |
3729 | int |
3730 | acpiioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) |
3731 | { |
3732 | return (ENXIO6); |
3733 | } |
3734 | |
3735 | int |
3736 | acpikqfilter(dev_t dev, struct knote *kn) |
3737 | { |
3738 | return (EOPNOTSUPP45); |
3739 | } |
3740 | |
3741 | #endif /* SMALL_KERNEL */ |