Annotation of src/sys/dev/acpi/acpi_ec.c, Revision 1.35.2.1
1.35.2.1! yamt 1: /* $NetBSD: acpi_ec.c,v 1.35 2005/12/24 20:27:29 perry Exp $ */
1.1 thorpej 2:
3: /*
4: * Copyright 2001 Wasabi Systems, Inc.
5: * All rights reserved.
6: *
7: * Written by Jason R. Thorpe for Wasabi Systems, Inc.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed for the NetBSD Project by
20: * Wasabi Systems, Inc.
21: * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22: * or promote products derived from this software without specific prior
23: * written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
29: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35: * POSSIBILITY OF SUCH DAMAGE.
36: */
37:
38: /*-
39: * Copyright (c) 2000 Michael Smith
40: * Copyright (c) 2000 BSDi
41: * All rights reserved.
42: *
43: * Redistribution and use in source and binary forms, with or without
44: * modification, are permitted provided that the following conditions
45: * are met:
46: * 1. Redistributions of source code must retain the above copyright
47: * notice, this list of conditions and the following disclaimer.
48: * 2. Redistributions in binary form must reproduce the above copyright
49: * notice, this list of conditions and the following disclaimer in the
50: * documentation and/or other materials provided with the distribution.
51: *
52: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
53: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
55: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
56: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
57: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
58: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
59: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
60: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
61: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
62: * SUCH DAMAGE.
63: */
64:
65: /******************************************************************************
66: *
67: * 1. Copyright Notice
68: *
69: * Some or all of this work - Copyright (c) 1999, Intel Corp. All rights
70: * reserved.
71: *
72: * 2. License
73: *
74: * 2.1. This is your license from Intel Corp. under its intellectual property
75: * rights. You may have additional license terms from the party that provided
76: * you this software, covering your right to use that party's intellectual
77: * property rights.
78: *
79: * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
80: * copy of the source code appearing in this file ("Covered Code") an
81: * irrevocable, perpetual, worldwide license under Intel's copyrights in the
82: * base code distributed originally by Intel ("Original Intel Code") to copy,
83: * make derivatives, distribute, use and display any portion of the Covered
84: * Code in any form, with the right to sublicense such rights; and
85: *
86: * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
87: * license (with the right to sublicense), under only those claims of Intel
88: * patents that are infringed by the Original Intel Code, to make, use, sell,
89: * offer to sell, and import the Covered Code and derivative works thereof
90: * solely to the minimum extent necessary to exercise the above copyright
91: * license, and in no event shall the patent license extend to any additions
92: * to or modifications of the Original Intel Code. No other license or right
93: * is granted directly or by implication, estoppel or otherwise;
94: *
95: * The above copyright and patent license is granted only if the following
96: * conditions are met:
97: *
1.24 kochi 98: * 3. Conditions
1.1 thorpej 99: *
1.24 kochi 100: * 3.1. Redistribution of Source with Rights to Further Distribute Source.
1.1 thorpej 101: * Redistribution of source code of any substantial portion of the Covered
102: * Code or modification with rights to further distribute source must include
103: * the above Copyright Notice, the above License, this list of Conditions,
104: * and the following Disclaimer and Export Compliance provision. In addition,
105: * Licensee must cause all Covered Code to which Licensee contributes to
106: * contain a file documenting the changes Licensee made to create that Covered
107: * Code and the date of any change. Licensee must include in that file the
1.24 kochi 108: * documentation of any changes made by any predecessor Licensee. Licensee
1.1 thorpej 109: * must include a prominent statement that the modification is derived,
110: * directly or indirectly, from Original Intel Code.
111: *
1.24 kochi 112: * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
1.1 thorpej 113: * Redistribution of source code of any substantial portion of the Covered
114: * Code or modification without rights to further distribute source must
115: * include the following Disclaimer and Export Compliance provision in the
116: * documentation and/or other materials provided with distribution. In
117: * addition, Licensee may not authorize further sublicense of source of any
118: * portion of the Covered Code, and must include terms to the effect that the
119: * license from Licensee to its licensee is limited to the intellectual
120: * property embodied in the software Licensee provides to its licensee, and
121: * not to intellectual property embodied in modifications its licensee may
122: * make.
123: *
124: * 3.3. Redistribution of Executable. Redistribution in executable form of any
125: * substantial portion of the Covered Code or modification must reproduce the
126: * above Copyright Notice, and the following Disclaimer and Export Compliance
127: * provision in the documentation and/or other materials provided with the
128: * distribution.
129: *
130: * 3.4. Intel retains all right, title, and interest in and to the Original
131: * Intel Code.
132: *
133: * 3.5. Neither the name Intel nor any other trademark owned or controlled by
134: * Intel shall be used in advertising or otherwise to promote the sale, use or
135: * other dealings in products derived from or relating to the Covered Code
136: * without prior written authorization from Intel.
137: *
138: * 4. Disclaimer and Export Compliance
139: *
140: * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
141: * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
142: * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
143: * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
144: * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
145: * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
1.24 kochi 146: * PARTICULAR PURPOSE.
1.1 thorpej 147: *
148: * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
149: * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
150: * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
151: * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
152: * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
153: * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
154: * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
155: * LIMITED REMEDY.
156: *
157: * 4.3. Licensee shall not export, either directly or indirectly, any of this
158: * software or system incorporating such software without first obtaining any
159: * required license or other approval from the U. S. Department of Commerce or
160: * any other agency or department of the United States Government. In the
161: * event Licensee exports any such software from the United States or
162: * re-exports any such software from a foreign destination, Licensee shall
163: * ensure that the distribution and export/re-export of the software is in
164: * compliance with all laws, regulations, orders, or other restrictions of the
165: * U.S. Export Administration Regulations. Licensee agrees that neither it nor
166: * any of its subsidiaries will export/re-export any technical data, process,
167: * software, or service, directly or indirectly, to any country for which the
168: * United States government or any agency thereof requires an export license,
169: * other governmental approval, or letter of assurance, without first obtaining
170: * such license, approval or letter.
171: *
172: *****************************************************************************/
1.3 lukem 173:
174: #include <sys/cdefs.h>
1.35.2.1! yamt 175: __KERNEL_RCSID(0, "$NetBSD: acpi_ec.c,v 1.35 2005/12/24 20:27:29 perry Exp $");
1.1 thorpej 176:
177: #include <sys/param.h>
178: #include <sys/systm.h>
179: #include <sys/device.h>
1.23 kochi 180: #include <sys/malloc.h>
1.1 thorpej 181: #include <sys/proc.h>
182: #include <sys/kernel.h>
183:
184: #include <machine/bus.h>
185:
186: #include <dev/acpi/acpica.h>
1.4 thorpej 187: #include <dev/acpi/acpireg.h>
1.1 thorpej 188: #include <dev/acpi/acpivar.h>
189: #include <dev/acpi/acpi_ecreg.h>
190:
1.23 kochi 191: MALLOC_DECLARE(M_ACPI);
192:
1.4 thorpej 193: #define _COMPONENT ACPI_EC_COMPONENT
194: ACPI_MODULE_NAME("EC")
1.1 thorpej 195:
196: struct acpi_ec_softc {
197: struct device sc_dev; /* base device glue */
1.23 kochi 198: ACPI_HANDLE sc_handle; /* ACPI handle */
1.1 thorpej 199:
200: UINT32 sc_gpebit; /* our GPE interrupt bit */
201:
202: bus_space_tag_t sc_data_st; /* space tag for data register */
203: bus_space_handle_t sc_data_sh; /* space handle for data register */
204:
205: bus_space_tag_t sc_csr_st; /* space tag for control register */
206: bus_space_handle_t sc_csr_sh; /* space handle for control register */
207:
208: int sc_flags; /* see below */
209:
210: uint32_t sc_csrvalue; /* saved control register */
1.23 kochi 211: uint32_t sc_uid; /* _UID in namespace (ECDT only) */
1.17 mycroft 212:
213: struct lock sc_lock; /* serialize operations to this EC */
1.20 yamt 214: struct simplelock sc_slock; /* protect against interrupts */
1.17 mycroft 215: UINT32 sc_glkhandle; /* global lock handle */
216: UINT32 sc_glk; /* need global lock? */
1.23 kochi 217: };
1.1 thorpej 218:
1.16 kochi 219: static const char * const ec_hid[] = {
220: "PNP0C09",
221: NULL
222: };
223:
1.20 yamt 224: #define EC_F_TRANSACTION 0x01 /* doing transaction */
225: #define EC_F_PENDQUERY 0x02 /* query is pending */
1.1 thorpej 226:
1.17 mycroft 227: /*
228: * how long to wait to acquire global lock.
229: * the value is taken from FreeBSD driver.
230: */
231: #define EC_LOCK_TIMEOUT 1000
232:
1.1 thorpej 233: #define EC_DATA_READ(sc) \
234: bus_space_read_1((sc)->sc_data_st, (sc)->sc_data_sh, 0)
235: #define EC_DATA_WRITE(sc, v) \
236: bus_space_write_1((sc)->sc_data_st, (sc)->sc_data_sh, 0, (v))
237:
238: #define EC_CSR_READ(sc) \
239: bus_space_read_1((sc)->sc_csr_st, (sc)->sc_csr_sh, 0)
240: #define EC_CSR_WRITE(sc, v) \
241: bus_space_write_1((sc)->sc_csr_st, (sc)->sc_csr_sh, 0, (v))
242:
1.20 yamt 243: typedef struct {
244: EC_COMMAND Command;
245: UINT8 Address;
246: UINT8 Data;
247: } EC_REQUEST;
248:
1.35.2.1! yamt 249: static UINT32 EcGpeHandler(void *);
! 250: static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE, UINT32, void *, void **);
! 251: static ACPI_STATUS EcSpaceHandler(UINT32, ACPI_PHYSICAL_ADDRESS, UINT32,
! 252: ACPI_INTEGER *, void *, void *);
! 253:
! 254: static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *, EC_EVENT);
! 255: static ACPI_STATUS EcQuery(struct acpi_ec_softc *, UINT8 *);
! 256: static ACPI_STATUS EcTransaction(struct acpi_ec_softc *, EC_REQUEST *);
! 257: static ACPI_STATUS EcRead(struct acpi_ec_softc *, UINT8, UINT8 *);
! 258: static ACPI_STATUS EcWrite(struct acpi_ec_softc *, UINT8, UINT8 *);
1.20 yamt 259: static void EcGpeQueryHandler(void *);
1.35 perry 260: static inline int EcIsLocked(struct acpi_ec_softc *);
261: static inline void EcLock(struct acpi_ec_softc *);
262: static inline void EcUnlock(struct acpi_ec_softc *);
1.20 yamt 263:
264:
1.31 kochi 265: static int acpiec_match(struct device *, struct cfdata *, void *);
266: static void acpiec_attach(struct device *, struct device *, void *);
1.20 yamt 267:
268: CFATTACH_DECL(acpiec, sizeof(struct acpi_ec_softc),
269: acpiec_match, acpiec_attach, NULL, NULL);
270:
1.23 kochi 271: static struct acpi_ec_softc *ecdt_sc;
272:
1.35 perry 273: static inline int
1.9 tshiozak 274: EcIsLocked(struct acpi_ec_softc *sc)
275: {
1.24 kochi 276:
1.17 mycroft 277: return (lockstatus(&sc->sc_lock) == LK_EXCLUSIVE);
1.9 tshiozak 278: }
1.4 thorpej 279:
1.35 perry 280: static inline void
1.1 thorpej 281: EcLock(struct acpi_ec_softc *sc)
282: {
1.25 kochi 283: ACPI_STATUS rv;
1.20 yamt 284: int s;
1.1 thorpej 285:
1.17 mycroft 286: lockmgr(&sc->sc_lock, LK_EXCLUSIVE, NULL);
287: if (sc->sc_glk) {
1.25 kochi 288: rv = AcpiAcquireGlobalLock(EC_LOCK_TIMEOUT,
1.17 mycroft 289: &sc->sc_glkhandle);
1.25 kochi 290: if (ACPI_FAILURE(rv)) {
1.17 mycroft 291: printf("%s: failed to acquire global lock\n",
292: sc->sc_dev.dv_xname);
293: lockmgr(&sc->sc_lock, LK_RELEASE, NULL);
294: return;
295: }
296: }
1.20 yamt 297:
298: s = splvm(); /* XXX */
299: simple_lock(&sc->sc_slock);
300: sc->sc_flags |= EC_F_TRANSACTION;
301: simple_unlock(&sc->sc_slock);
302: splx(s);
1.1 thorpej 303: }
304:
1.35 perry 305: static inline void
1.1 thorpej 306: EcUnlock(struct acpi_ec_softc *sc)
307: {
1.25 kochi 308: ACPI_STATUS rv;
1.20 yamt 309: int s;
310:
311: /*
312: * Clear & Re-Enable the EC GPE:
313: * -----------------------------
314: * 'Consume' any EC GPE events that we generated while performing
315: * the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't
316: * have an adverse affect on outstanding EC-SCI's, as the source
317: * (EC-SCI) will still be high and thus should trigger the GPE
318: * immediately after we re-enabling it.
319: */
320: s = splvm(); /* XXX */
321: simple_lock(&sc->sc_slock);
322: if (sc->sc_flags & EC_F_PENDQUERY) {
1.25 kochi 323: ACPI_STATUS rv2;
1.20 yamt 324:
1.25 kochi 325: rv2 = AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
1.20 yamt 326: EcGpeQueryHandler, sc);
1.25 kochi 327: if (ACPI_FAILURE(rv2))
1.20 yamt 328: printf("%s: unable to queue pending query: %s\n",
1.25 kochi 329: sc->sc_dev.dv_xname, AcpiFormatException(rv2));
1.20 yamt 330: sc->sc_flags &= ~EC_F_PENDQUERY;
331: }
332: sc->sc_flags &= ~EC_F_TRANSACTION;
333: simple_unlock(&sc->sc_slock);
334: splx(s);
1.11 mycroft 335:
1.17 mycroft 336: if (sc->sc_glk) {
1.25 kochi 337: rv = AcpiReleaseGlobalLock(sc->sc_glkhandle);
338: if (ACPI_FAILURE(rv))
1.17 mycroft 339: printf("%s: failed to release global lock\n",
340: sc->sc_dev.dv_xname);
341: }
342: lockmgr(&sc->sc_lock, LK_RELEASE, NULL);
1.1 thorpej 343: }
344:
345: /*
346: * acpiec_match:
347: *
348: * Autoconfiguration `match' routine.
349: */
1.31 kochi 350: static int
1.1 thorpej 351: acpiec_match(struct device *parent, struct cfdata *match, void *aux)
352: {
353: struct acpi_attach_args *aa = aux;
354:
355: if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
1.25 kochi 356: return 0;
1.1 thorpej 357:
1.25 kochi 358: return acpi_match_hid(aa->aa_node->ad_devinfo, ec_hid);
1.1 thorpej 359: }
360:
1.17 mycroft 361: void
362: acpiec_early_attach(struct device *parent)
363: {
1.23 kochi 364: struct acpi_softc *sc = (struct acpi_softc *)parent;
1.17 mycroft 365: EC_BOOT_RESOURCES *ep;
366: ACPI_HANDLE handle;
1.23 kochi 367: ACPI_STATUS rv;
368: ACPI_INTEGER tmp;
1.17 mycroft 369:
1.23 kochi 370: rv = AcpiGetFirmwareTable("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
371: (void *)&ep);
372: if (ACPI_FAILURE(rv))
1.17 mycroft 373: return;
374:
375: if (ep->EcControl.RegisterBitWidth != 8 ||
376: ep->EcData.RegisterBitWidth != 8) {
377: printf("%s: ECDT data is invalid, RegisterBitWidth=%d/%d\n",
1.23 kochi 378: parent->dv_xname,
1.25 kochi 379: ep->EcControl.RegisterBitWidth,
380: ep->EcData.RegisterBitWidth);
1.17 mycroft 381: return;
382: }
383:
1.23 kochi 384: rv = AcpiGetHandle(ACPI_ROOT_OBJECT, ep->EcId, &handle);
385: if (ACPI_FAILURE(rv)) {
386: printf("%s: failed to look up EC object %s: %s\n",
387: parent->dv_xname,
388: ep->EcId, AcpiFormatException(rv));
389: return;
390: }
391:
392: ecdt_sc = malloc(sizeof(*ecdt_sc), M_ACPI, M_ZERO);
393:
394: strcpy(ecdt_sc->sc_dev.dv_xname, "acpiecdt0"); /* XXX */
395: ecdt_sc->sc_handle = handle;
396:
397: ecdt_sc->sc_gpebit = ep->GpeBit;
398: ecdt_sc->sc_uid = ep->Uid;
399:
400: ecdt_sc->sc_data_st = sc->sc_iot;
401: if (bus_space_map(ecdt_sc->sc_data_st,
402: (bus_addr_t)(ep->EcData.Address), 1, 0,
403: &ecdt_sc->sc_data_sh) != 0) {
404: printf("%s: bus_space_map failed for EC data.\n",
405: parent->dv_xname);
406: goto out1;
407: }
408:
409: ecdt_sc->sc_csr_st = sc->sc_iot;
410: if (bus_space_map(ecdt_sc->sc_csr_st,
411: (bus_addr_t)(ep->EcControl.Address), 1, 0,
412: &ecdt_sc->sc_csr_sh) != 0) {
413: printf("%s: bus_space_map failed for EC control.\n",
414: parent->dv_xname);
415: goto out2;
416: }
417:
418: rv = acpi_eval_integer(handle, "_GLK", &tmp);
419: if (ACPI_SUCCESS(rv) && tmp == 1)
420: ecdt_sc->sc_glk = 1;
421:
422: rv = AcpiInstallGpeHandler(NULL, ecdt_sc->sc_gpebit,
1.33 kochi 423: ACPI_GPE_EDGE_TRIGGERED, EcGpeHandler, ecdt_sc);
1.23 kochi 424: if (ACPI_FAILURE(rv)) {
425: printf("%s: unable to install GPE handler: %s\n",
1.33 kochi 426: parent->dv_xname, AcpiFormatException(rv));
1.23 kochi 427: goto out3;
428: }
429:
1.33 kochi 430: rv = AcpiSetGpeType(NULL, ecdt_sc->sc_gpebit, ACPI_GPE_TYPE_RUNTIME);
431: if (ACPI_FAILURE(rv)) {
432: printf("%s: unable to set GPE type: %s\n",
433: parent->dv_xname, AcpiFormatException(rv));
434: goto out4;
435: }
436:
437: rv = AcpiEnableGpe(NULL, ecdt_sc->sc_gpebit, ACPI_NOT_ISR);
438: if (ACPI_FAILURE(rv)) {
439: printf("%s: unable to enable GPE: %s\n",
440: parent->dv_xname, AcpiFormatException(rv));
441: goto out4;
442: }
443:
1.23 kochi 444: rv = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
445: ACPI_ADR_SPACE_EC, EcSpaceHandler, EcSpaceSetup, ecdt_sc);
446: if (ACPI_FAILURE(rv)) {
447: printf("%s: unable to install address space handler: %s\n",
448: parent->dv_xname,
449: AcpiFormatException(rv));
450: goto out4;
1.17 mycroft 451: }
1.23 kochi 452:
453: printf("%s: found ECDT, GPE %d\n", parent->dv_xname,
454: ecdt_sc->sc_gpebit);
455:
456: lockinit(&ecdt_sc->sc_lock, PWAIT, "eclock", 0, 0);
457: simple_lock_init(&ecdt_sc->sc_slock);
458:
459: AcpiOsUnmapMemory(ep, ep->Length);
460: return;
461:
462: out4:
463: AcpiRemoveGpeHandler(NULL, ecdt_sc->sc_gpebit, EcGpeHandler);
464: out3:
465: bus_space_unmap(ecdt_sc->sc_csr_st, ecdt_sc->sc_csr_sh, 1);
466: out2:
467: bus_space_unmap(ecdt_sc->sc_data_st, ecdt_sc->sc_data_sh, 1);
468: out1:
469: free(ecdt_sc, M_ACPI);
470: ecdt_sc = NULL;
471:
472: AcpiOsUnmapMemory(ep, ep->Length);
473:
474: return;
1.17 mycroft 475: }
476:
1.1 thorpej 477: /*
478: * acpiec_attach:
479: *
480: * Autoconfiguration `attach' routine.
481: */
1.31 kochi 482: static void
1.1 thorpej 483: acpiec_attach(struct device *parent, struct device *self, void *aux)
484: {
485: struct acpi_ec_softc *sc = (void *) self;
486: struct acpi_attach_args *aa = aux;
487: struct acpi_io *io0, *io1;
1.28 kochi 488: struct acpi_resources res;
1.1 thorpej 489: ACPI_STATUS rv;
1.21 kanaoka 490: ACPI_INTEGER v;
1.1 thorpej 491:
1.4 thorpej 492: ACPI_FUNCTION_TRACE(__FUNCTION__);
1.1 thorpej 493:
494: printf(": ACPI Embedded Controller\n");
495:
1.17 mycroft 496: lockinit(&sc->sc_lock, PWAIT, "eclock", 0, 0);
1.20 yamt 497: simple_lock_init(&sc->sc_slock);
1.17 mycroft 498:
1.23 kochi 499: sc->sc_handle = aa->aa_node->ad_handle;
1.1 thorpej 500:
501: /* Parse our resources. */
502: ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "parsing EC resources\n"));
1.28 kochi 503: rv = acpi_resource_parse(&sc->sc_dev, sc->sc_handle, "_CRS",
504: &res, &acpi_resource_parse_ops_default);
1.18 mycroft 505: if (ACPI_FAILURE(rv))
1.1 thorpej 506: return;
507:
1.28 kochi 508: #define adi aa->aa_node->ad_devinfo
1.23 kochi 509:
510: /* check if we already attached EC via ECDT */
1.28 kochi 511: if (ecdt_sc &&
512: ((adi->Valid & ACPI_VALID_UID) == ACPI_VALID_UID) &&
513: ecdt_sc->sc_uid == strtoul(adi->UniqueId.Value, NULL, 10)) {
1.23 kochi 514: /* detach all ECDT handles */
515: rv = AcpiRemoveAddressSpaceHandler(ACPI_ROOT_OBJECT,
516: ACPI_ADR_SPACE_EC, EcSpaceHandler);
517: if (ACPI_FAILURE(rv))
518: printf("ERROR: RemoveAddressSpaceHandler: %s\n",
519: AcpiFormatException(rv));
520: rv = AcpiRemoveGpeHandler(NULL, ecdt_sc->sc_gpebit,
521: EcGpeHandler);
522: if (ACPI_FAILURE(rv))
523: printf("ERROR: RemoveAddressSpaceHandler: %s\n",
524: AcpiFormatException(rv));
525:
526: bus_space_unmap(ecdt_sc->sc_csr_st,
527: ecdt_sc->sc_csr_sh, 1);
528: bus_space_unmap(ecdt_sc->sc_data_st,
529: ecdt_sc->sc_data_sh, 1);
530:
531: free(ecdt_sc, M_ACPI);
532: ecdt_sc = NULL;
533: }
534:
1.28 kochi 535: #undef adi
536:
1.1 thorpej 537: sc->sc_data_st = aa->aa_iot;
1.28 kochi 538: io0 = acpi_res_io(&res, 0);
1.1 thorpej 539: if (io0 == NULL) {
540: printf("%s: unable to find data register resource\n",
541: sc->sc_dev.dv_xname);
1.27 kochi 542: goto out;
1.1 thorpej 543: }
544: if (bus_space_map(sc->sc_data_st, io0->ar_base, io0->ar_length,
545: 0, &sc->sc_data_sh) != 0) {
546: printf("%s: unable to map data register\n",
547: sc->sc_dev.dv_xname);
1.27 kochi 548: goto out;
1.1 thorpej 549: }
550:
551: sc->sc_csr_st = aa->aa_iot;
1.28 kochi 552: io1 = acpi_res_io(&res, 1);
1.1 thorpej 553: if (io1 == NULL) {
554: printf("%s: unable to find csr register resource\n",
555: sc->sc_dev.dv_xname);
1.27 kochi 556: goto out;
1.1 thorpej 557: }
558: if (bus_space_map(sc->sc_csr_st, io1->ar_base, io1->ar_length,
559: 0, &sc->sc_csr_sh) != 0) {
560: printf("%s: unable to map csr register\n",
561: sc->sc_dev.dv_xname);
1.27 kochi 562: goto out;
1.1 thorpej 563: }
564:
565: /*
1.23 kochi 566: * evaluate _GLK to see if we should acquire global lock
567: * when accessing the EC.
568: */
569: rv = acpi_eval_integer(sc->sc_handle, "_GLK", &v);
570: if (ACPI_FAILURE(rv)) {
571: if (rv != AE_NOT_FOUND)
572: printf("%s: unable to evaluate _GLK: %s\n",
573: sc->sc_dev.dv_xname,
574: AcpiFormatException(rv));
575: sc->sc_glk = 0;
576: } else
577: sc->sc_glk = v;
578:
579: /*
1.1 thorpej 580: * Install GPE handler.
581: *
582: * We evaluate the _GPE method to find the GPE bit used by the
583: * Embedded Controller to signal status (SCI).
584: */
1.23 kochi 585: rv = acpi_eval_integer(sc->sc_handle, "_GPE", &v);
1.18 mycroft 586: if (ACPI_FAILURE(rv)) {
587: printf("%s: unable to evaluate _GPE: %s\n",
588: sc->sc_dev.dv_xname, AcpiFormatException(rv));
1.27 kochi 589: goto out;
1.17 mycroft 590: }
1.21 kanaoka 591: sc->sc_gpebit = v;
1.17 mycroft 592:
593: /*
1.24 kochi 594: * Install a handler for this EC's GPE bit. Note that EC SCIs are
1.1 thorpej 595: * treated as both edge- and level-triggered interrupts; in other words
596: * we clear the status bit immediately after getting an EC-SCI, then
597: * again after we're done processing the event. This guarantees that
1.24 kochi 598: * events we cause while performing a transaction (e.g. IBE/OBF) get
1.1 thorpej 599: * cleared before re-enabling the GPE.
600: */
1.18 mycroft 601: rv = AcpiInstallGpeHandler(NULL, sc->sc_gpebit,
1.33 kochi 602: ACPI_GPE_EDGE_TRIGGERED, EcGpeHandler, sc);
1.18 mycroft 603: if (ACPI_FAILURE(rv)) {
604: printf("%s: unable to install GPE handler: %s\n",
605: sc->sc_dev.dv_xname, AcpiFormatException(rv));
1.27 kochi 606: goto out;
1.1 thorpej 607: }
608:
1.33 kochi 609: rv = AcpiSetGpeType(NULL, sc->sc_gpebit, ACPI_GPE_TYPE_RUNTIME);
610: if (ACPI_FAILURE(rv)) {
611: printf("%s: unable to set GPE type: %s\n",
612: sc->sc_dev.dv_xname, AcpiFormatException(rv));
613: goto out2;
614: }
615:
616: rv = AcpiEnableGpe(NULL, sc->sc_gpebit, ACPI_NOT_ISR);
617: if (ACPI_FAILURE(rv)) {
618: printf("%s: unable to enable GPE: %s\n",
619: sc->sc_dev.dv_xname, AcpiFormatException(rv));
620: goto out2;
621: }
622:
1.1 thorpej 623: /* Install address space handler. */
1.23 kochi 624: rv = AcpiInstallAddressSpaceHandler(sc->sc_handle,
1.18 mycroft 625: ACPI_ADR_SPACE_EC, EcSpaceHandler, EcSpaceSetup, sc);
626: if (ACPI_FAILURE(rv)) {
627: printf("%s: unable to install address space handler: %s\n",
628: sc->sc_dev.dv_xname, AcpiFormatException(rv));
1.33 kochi 629: goto out2;
1.1 thorpej 630: }
631:
1.33 kochi 632: return_VOID;
633: out2:
634: (void)AcpiRemoveGpeHandler(NULL, sc->sc_gpebit, EcGpeHandler);
635:
1.27 kochi 636: out:
1.28 kochi 637: acpi_resource_cleanup(&res);
1.1 thorpej 638: return_VOID;
639: }
640:
641: static void
642: EcGpeQueryHandler(void *Context)
643: {
644: struct acpi_ec_softc *sc = Context;
645: UINT8 Data;
1.25 kochi 646: ACPI_STATUS rv;
1.1 thorpej 647: char qxx[5];
648:
1.4 thorpej 649: ACPI_FUNCTION_TRACE(__FUNCTION__);
1.1 thorpej 650:
651: for (;;) {
652: /*
653: * Check EC_SCI.
1.24 kochi 654: *
1.1 thorpej 655: * Bail out if the EC_SCI bit of the status register is not
656: * set. Note that this function should only be called when
657: * this bit is set (polling is used to detect IBE/OBF events).
658: *
659: * It is safe to do this without locking the controller, as
660: * it's OK to call EcQuery when there's no data ready; in the
661: * worst case we should just find nothing waiting for us and
662: * bail.
663: */
664: if ((EC_CSR_READ(sc) & EC_EVENT_SCI) == 0)
665: break;
666:
1.20 yamt 667: EcLock(sc);
668:
1.1 thorpej 669: /*
670: * Find out why the EC is signalling us
671: */
1.25 kochi 672: rv = EcQuery(sc, &Data);
1.20 yamt 673:
674: EcUnlock(sc);
1.24 kochi 675:
1.1 thorpej 676: /*
677: * If we failed to get anything from the EC, give up.
678: */
1.25 kochi 679: if (ACPI_FAILURE(rv)) {
1.18 mycroft 680: printf("%s: GPE query failed: %s\n",
1.25 kochi 681: sc->sc_dev.dv_xname, AcpiFormatException(rv));
1.1 thorpej 682: break;
683: }
684:
685: /*
686: * Evaluate _Qxx to respond to the controller.
687: */
1.29 itojun 688: snprintf(qxx, sizeof(qxx), "_Q%02X", Data);
1.25 kochi 689: rv = AcpiEvaluateObject(sc->sc_handle, qxx,
1.1 thorpej 690: NULL, NULL);
691:
692: /*
693: * Ignore spurious query requests.
694: */
1.25 kochi 695: if (ACPI_FAILURE(rv) &&
696: (Data != 0 || rv != AE_NOT_FOUND)) {
1.1 thorpej 697: printf("%s: evaluation of GPE query method %s "
1.18 mycroft 698: "failed: %s\n", sc->sc_dev.dv_xname, qxx,
1.25 kochi 699: AcpiFormatException(rv));
1.1 thorpej 700: }
701: }
702:
703: /* I know I request Level trigger cleanup */
1.25 kochi 704: rv = AcpiClearGpe(NULL, sc->sc_gpebit, ACPI_NOT_ISR);
705: if (ACPI_FAILURE(rv))
1.18 mycroft 706: printf("%s: AcpiClearGpe failed: %s\n", sc->sc_dev.dv_xname,
1.25 kochi 707: AcpiFormatException(rv));
1.1 thorpej 708:
709: return_VOID;
710: }
711:
1.33 kochi 712: static UINT32
1.1 thorpej 713: EcGpeHandler(void *Context)
714: {
715: struct acpi_ec_softc *sc = Context;
716: uint32_t csrvalue;
1.25 kochi 717: ACPI_STATUS rv;
1.1 thorpej 718:
1.24 kochi 719: /*
1.1 thorpej 720: * If EC is locked, the intr must process EcRead/Write wait only.
721: * Query request must be pending.
722: */
1.20 yamt 723: simple_lock(&sc->sc_slock);
724: if (sc->sc_flags & EC_F_TRANSACTION) {
1.1 thorpej 725: csrvalue = EC_CSR_READ(sc);
1.30 yamt 726: sc->sc_flags |= EC_F_PENDQUERY;
1.1 thorpej 727:
728: if ((csrvalue & EC_FLAG_OUTPUT_BUFFER) != 0 ||
729: (csrvalue & EC_FLAG_INPUT_BUFFER) == 0) {
730: sc->sc_csrvalue = csrvalue;
731: wakeup(&sc->sc_csrvalue);
732: }
1.20 yamt 733: simple_unlock(&sc->sc_slock);
1.1 thorpej 734: } else {
1.20 yamt 735: simple_unlock(&sc->sc_slock);
1.1 thorpej 736: /* Enqueue GpeQuery handler. */
1.25 kochi 737: rv = AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
1.18 mycroft 738: EcGpeQueryHandler, Context);
1.25 kochi 739: if (ACPI_FAILURE(rv))
1.18 mycroft 740: printf("%s: failed to enqueue query handler: %s\n",
1.25 kochi 741: sc->sc_dev.dv_xname, AcpiFormatException(rv));
1.1 thorpej 742: }
1.33 kochi 743:
744: return 0; /* XXX not yet used in ACPI-CA */
1.1 thorpej 745: }
746:
747: static ACPI_STATUS
748: EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
749: void **RegionContext)
750: {
751:
1.4 thorpej 752: ACPI_FUNCTION_TRACE(__FUNCTION__);
1.1 thorpej 753:
754: /*
755: * Just pass the context through, there's nothing to do here.
756: */
1.23 kochi 757: if (Function == ACPI_REGION_DEACTIVATE)
758: *RegionContext = NULL;
759: else
760: *RegionContext = Context;
1.1 thorpej 761:
762: return_ACPI_STATUS(AE_OK);
763: }
764:
765: static ACPI_STATUS
766: EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width,
1.4 thorpej 767: ACPI_INTEGER *Value, void *Context, void *RegionContext)
1.1 thorpej 768: {
769: struct acpi_ec_softc *sc = Context;
1.25 kochi 770: ACPI_STATUS rv = AE_OK;
1.1 thorpej 771: EC_REQUEST EcRequest;
772: int i;
773:
1.4 thorpej 774: ACPI_FUNCTION_TRACE_U32(__FUNCTION__, (UINT32)Address);
1.1 thorpej 775:
776: if ((Address > 0xFF) || (width % 8 != 0) || (Value == NULL) ||
777: (Context == NULL))
778: return_ACPI_STATUS(AE_BAD_PARAMETER);
779:
780: switch (Function) {
1.4 thorpej 781: case ACPI_READ:
1.1 thorpej 782: EcRequest.Command = EC_COMMAND_READ;
783: EcRequest.Address = Address;
784: (*Value) = 0;
785: break;
786:
1.4 thorpej 787: case ACPI_WRITE:
1.1 thorpej 788: EcRequest.Command = EC_COMMAND_WRITE;
789: EcRequest.Address = Address;
790: break;
791:
792: default:
793: printf("%s: invalid Address Space function: %d\n",
794: sc->sc_dev.dv_xname, Function);
795: return_ACPI_STATUS(AE_BAD_PARAMETER);
796: }
797:
798: /*
799: * Perform the transaction.
800: */
801: for (i = 0; i < width; i += 8) {
1.4 thorpej 802: if (Function == ACPI_READ)
1.1 thorpej 803: EcRequest.Data = 0;
804: else
805: EcRequest.Data = (UINT8)((*Value) >> i);
806:
1.25 kochi 807: rv = EcTransaction(sc, &EcRequest);
808: if (ACPI_FAILURE(rv))
1.1 thorpej 809: break;
810:
811: (*Value) |= (UINT32)EcRequest.Data << i;
812: if (++EcRequest.Address == 0)
813: return_ACPI_STATUS(AE_BAD_PARAMETER);
814: }
815:
1.25 kochi 816: return_ACPI_STATUS(rv);
1.1 thorpej 817: }
818:
819: static ACPI_STATUS
820: EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event)
821: {
822: EC_STATUS EcStatus;
823: int i;
824:
1.4 thorpej 825: ACPI_FUNCTION_TRACE_U32(__FUNCTION__, (UINT32)Event);
1.1 thorpej 826:
827: /* XXX Need better test for "yes, you have interrupts". */
828: if (cold)
829: return_ACPI_STATUS(EcWaitEvent(sc, Event));
830:
831: if (EcIsLocked(sc) == 0)
832: printf("%s: EcWaitEventIntr called without EC lock!\n",
833: sc->sc_dev.dv_xname);
834:
835: EcStatus = EC_CSR_READ(sc);
836:
837: /* Too long? */
838: for (i = 0; i < 10; i++) {
839: /* Check EC status against the desired event. */
840: if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
841: (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0)
842: return_ACPI_STATUS(AE_OK);
1.24 kochi 843:
1.1 thorpej 844: if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
845: (EcStatus & EC_FLAG_INPUT_BUFFER) == 0)
846: return_ACPI_STATUS(AE_OK);
847:
848: sc->sc_csrvalue = 0;
849: /* XXXJRT Sleeping with a lock held? */
1.32 yamt 850: if (tsleep(&sc->sc_csrvalue, 0, "EcWait", (hz + 99) / 100)
851: != EWOULDBLOCK)
1.1 thorpej 852: EcStatus = sc->sc_csrvalue;
853: else
854: EcStatus = EC_CSR_READ(sc);
855: }
856: return_ACPI_STATUS(AE_ERROR);
857: }
858:
859: static ACPI_STATUS
860: EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
861: {
862: EC_STATUS EcStatus;
863: UINT32 i = 0;
864:
865: if (EcIsLocked(sc) == 0)
866: printf("%s: EcWaitEvent called without EC lock!\n",
867: sc->sc_dev.dv_xname);
868:
869: /*
870: * Stall 1us:
871: * ----------
872: * Stall for 1 microsecond before reading the status register
873: * for the first time. This allows the EC to set the IBF/OBF
874: * bit to its proper state.
875: *
876: * XXX it is not clear why we read the CSR twice.
877: */
878: AcpiOsStall(1);
879: EcStatus = EC_CSR_READ(sc);
880:
881: /*
882: * Wait For Event:
883: * ---------------
884: * Poll the EC status register to detect completion of the last
885: * command. Wait up to 10ms (in 100us chunks) for this to occur.
886: */
887: for (i = 0; i < 100; i++) {
888: EcStatus = EC_CSR_READ(sc);
889:
890: if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
891: (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0)
1.25 kochi 892: return AE_OK;
1.1 thorpej 893:
894: if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
895: (EcStatus & EC_FLAG_INPUT_BUFFER) == 0)
1.25 kochi 896: return AE_OK;
1.1 thorpej 897:
898: AcpiOsStall(10);
899: }
900:
1.25 kochi 901: return AE_ERROR;
1.24 kochi 902: }
1.1 thorpej 903:
904: static ACPI_STATUS
905: EcQuery(struct acpi_ec_softc *sc, UINT8 *Data)
906: {
1.25 kochi 907: ACPI_STATUS rv;
1.1 thorpej 908:
1.20 yamt 909: if (EcIsLocked(sc) == 0)
910: printf("%s: EcQuery called without EC lock!\n",
911: sc->sc_dev.dv_xname);
1.1 thorpej 912:
913: EC_CSR_WRITE(sc, EC_COMMAND_QUERY);
1.25 kochi 914: rv = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
915: if (ACPI_SUCCESS(rv))
1.1 thorpej 916: *Data = EC_DATA_READ(sc);
917:
1.25 kochi 918: if (ACPI_FAILURE(rv))
1.2 enami 919: printf("%s: timed out waiting for EC to respond to "
1.1 thorpej 920: "EC_COMMAND_QUERY\n", sc->sc_dev.dv_xname);
921:
1.25 kochi 922: return rv;
1.24 kochi 923: }
1.1 thorpej 924:
925: static ACPI_STATUS
926: EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest)
927: {
1.25 kochi 928: ACPI_STATUS rv;
1.1 thorpej 929:
1.11 mycroft 930: EcLock(sc);
1.1 thorpej 931:
932: /*
933: * Perform the transaction.
934: */
935: switch (EcRequest->Command) {
936: case EC_COMMAND_READ:
1.25 kochi 937: rv = EcRead(sc, EcRequest->Address, &(EcRequest->Data));
1.1 thorpej 938: break;
939:
940: case EC_COMMAND_WRITE:
1.25 kochi 941: rv = EcWrite(sc, EcRequest->Address, &(EcRequest->Data));
1.1 thorpej 942: break;
943:
944: default:
1.25 kochi 945: rv = AE_SUPPORT;
1.1 thorpej 946: break;
947: }
948:
949: EcUnlock(sc);
950:
1.25 kochi 951: return rv;
1.1 thorpej 952: }
953:
954: static ACPI_STATUS
955: EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
956: {
1.25 kochi 957: ACPI_STATUS rv;
1.1 thorpej 958:
959: if (EcIsLocked(sc) == 0)
960: printf("%s: EcRead called without EC lock!\n",
961: sc->sc_dev.dv_xname);
962:
963: /* EcBurstEnable(EmbeddedController); */
964:
965: EC_CSR_WRITE(sc, EC_COMMAND_READ);
1.25 kochi 966: if ((rv = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) !=
1.1 thorpej 967: AE_OK) {
968: printf("%s: EcRead: timeout waiting for EC to process "
969: "read command\n", sc->sc_dev.dv_xname);
1.25 kochi 970: return rv;
1.1 thorpej 971: }
972:
973: EC_DATA_WRITE(sc, Address);
1.25 kochi 974: if ((rv = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL)) !=
1.1 thorpej 975: AE_OK) {
976: printf("%s: EcRead: timeout waiting for EC to send data\n",
977: sc->sc_dev.dv_xname);
1.25 kochi 978: return rv;
1.1 thorpej 979: }
980:
981: (*Data) = EC_DATA_READ(sc);
982:
983: /* EcBurstDisable(EmbeddedController); */
984:
1.25 kochi 985: return AE_OK;
1.24 kochi 986: }
1.1 thorpej 987:
988: static ACPI_STATUS
989: EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
990: {
1.25 kochi 991: ACPI_STATUS rv;
1.1 thorpej 992:
993: if (EcIsLocked(sc) == 0)
994: printf("%s: EcWrite called without EC lock!\n",
995: sc->sc_dev.dv_xname);
996:
997: /* EcBurstEnable(EmbeddedController); */
998:
999: EC_CSR_WRITE(sc, EC_COMMAND_WRITE);
1.25 kochi 1000: if ((rv = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) !=
1.1 thorpej 1001: AE_OK) {
1002: printf("%s: EcWrite: timeout waiting for EC to process "
1003: "write command\n", sc->sc_dev.dv_xname);
1.25 kochi 1004: return rv;
1.1 thorpej 1005: }
1006:
1007: EC_DATA_WRITE(sc, Address);
1.25 kochi 1008: if ((rv = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) !=
1.1 thorpej 1009: AE_OK) {
1010: printf("%s: EcWrite: timeout waiting for EC to process "
1011: "address\n", sc->sc_dev.dv_xname);
1.25 kochi 1012: return rv;
1.1 thorpej 1013: }
1014:
1015: EC_DATA_WRITE(sc, *Data);
1.25 kochi 1016: if ((rv = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY)) !=
1.1 thorpej 1017: AE_OK) {
1018: printf("%s: EcWrite: timeout waiting for EC to process "
1019: "data\n", sc->sc_dev.dv_xname);
1.25 kochi 1020: return rv;
1.1 thorpej 1021: }
1022:
1023: /* EcBurstDisable(EmbeddedController); */
1024:
1.25 kochi 1025: return AE_OK;
1.1 thorpej 1026: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to acpi_ec.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / dev / acpi