1 /*-
2 * Copyright (c) 2000 Michael Smith
3 * Copyright (c) 2000 BSDi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD$
28 */
29 /******************************************************************************
30 *
31 * 1. Copyright Notice
32 *
33 * Some or all of this work - Copyright (c) 1999, Intel Corp. All rights
34 * reserved.
35 *
36 * 2. License
37 *
38 * 2.1. This is your license from Intel Corp. under its intellectual property
39 * rights. You may have additional license terms from the party that provided
40 * you this software, covering your right to use that party's intellectual
41 * property rights.
42 *
43 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
44 * copy of the source code appearing in this file ("Covered Code") an
45 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
46 * base code distributed originally by Intel ("Original Intel Code") to copy,
47 * make derivatives, distribute, use and display any portion of the Covered
48 * Code in any form, with the right to sublicense such rights; and
49 *
50 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
51 * license (with the right to sublicense), under only those claims of Intel
52 * patents that are infringed by the Original Intel Code, to make, use, sell,
53 * offer to sell, and import the Covered Code and derivative works thereof
54 * solely to the minimum extent necessary to exercise the above copyright
55 * license, and in no event shall the patent license extend to any additions
56 * to or modifications of the Original Intel Code. No other license or right
57 * is granted directly or by implication, estoppel or otherwise;
58 *
59 * The above copyright and patent license is granted only if the following
60 * conditions are met:
61 *
62 * 3. Conditions
63 *
64 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
65 * Redistribution of source code of any substantial portion of the Covered
66 * Code or modification with rights to further distribute source must include
67 * the above Copyright Notice, the above License, this list of Conditions,
68 * and the following Disclaimer and Export Compliance provision. In addition,
69 * Licensee must cause all Covered Code to which Licensee contributes to
70 * contain a file documenting the changes Licensee made to create that Covered
71 * Code and the date of any change. Licensee must include in that file the
72 * documentation of any changes made by any predecessor Licensee. Licensee
73 * must include a prominent statement that the modification is derived,
74 * directly or indirectly, from Original Intel Code.
75 *
76 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
77 * Redistribution of source code of any substantial portion of the Covered
78 * Code or modification without rights to further distribute source must
79 * include the following Disclaimer and Export Compliance provision in the
80 * documentation and/or other materials provided with distribution. In
81 * addition, Licensee may not authorize further sublicense of source of any
82 * portion of the Covered Code, and must include terms to the effect that the
83 * license from Licensee to its licensee is limited to the intellectual
84 * property embodied in the software Licensee provides to its licensee, and
85 * not to intellectual property embodied in modifications its licensee may
86 * make.
87 *
88 * 3.3. Redistribution of Executable. Redistribution in executable form of any
89 * substantial portion of the Covered Code or modification must reproduce the
90 * above Copyright Notice, and the following Disclaimer and Export Compliance
91 * provision in the documentation and/or other materials provided with the
92 * distribution.
93 *
94 * 3.4. Intel retains all right, title, and interest in and to the Original
95 * Intel Code.
96 *
97 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
98 * Intel shall be used in advertising or otherwise to promote the sale, use or
99 * other dealings in products derived from or relating to the Covered Code
100 * without prior written authorization from Intel.
101 *
102 * 4. Disclaimer and Export Compliance
103 *
104 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
105 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
106 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
107 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
108 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
109 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
110 * PARTICULAR PURPOSE.
111 *
112 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
113 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
114 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
115 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
116 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
117 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
118 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
119 * LIMITED REMEDY.
120 *
121 * 4.3. Licensee shall not export, either directly or indirectly, any of this
122 * software or system incorporating such software without first obtaining any
123 * required license or other approval from the U. S. Department of Commerce or
124 * any other agency or department of the United States Government. In the
125 * event Licensee exports any such software from the United States or
126 * re-exports any such software from a foreign destination, Licensee shall
127 * ensure that the distribution and export/re-export of the software is in
128 * compliance with all laws, regulations, orders, or other restrictions of the
129 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
130 * any of its subsidiaries will export/re-export any technical data, process,
131 * software, or service, directly or indirectly, to any country for which the
132 * United States government or any agency thereof requires an export license,
133 * other governmental approval, or letter of assurance, without first obtaining
134 * such license, approval or letter.
135 *
136 *****************************************************************************/
137
138 #include "opt_acpi.h"
139 #include <sys/param.h>
140 #include <sys/kernel.h>
141 #include <sys/bus.h>
142
143 #include <machine/bus.h>
144 #include <machine/resource.h>
145 #include <sys/rman.h>
146
147 #include "acpi.h"
148
149 #include <dev/acpica/acpivar.h>
150
151 /*
152 * Hooks for the ACPI CA debugging infrastructure
153 */
154 #define _COMPONENT ACPI_EC
155 ACPI_MODULE_NAME("EC")
156
157 /*
158 * EC_COMMAND:
159 * -----------
160 */
161 typedef UINT8 EC_COMMAND;
162
163 #define EC_COMMAND_UNKNOWN ((EC_COMMAND) 0x00)
164 #define EC_COMMAND_READ ((EC_COMMAND) 0x80)
165 #define EC_COMMAND_WRITE ((EC_COMMAND) 0x81)
166 #define EC_COMMAND_BURST_ENABLE ((EC_COMMAND) 0x82)
167 #define EC_COMMAND_BURST_DISABLE ((EC_COMMAND) 0x83)
168 #define EC_COMMAND_QUERY ((EC_COMMAND) 0x84)
169
170 /*
171 * EC_STATUS:
172 * ----------
173 * The encoding of the EC status register is illustrated below.
174 * Note that a set bit (1) indicates the property is TRUE
175 * (e.g. if bit 0 is set then the output buffer is full).
176 * +-+-+-+-+-+-+-+-+
177 * |7|6|5|4|3|2|1|0|
178 * +-+-+-+-+-+-+-+-+
179 * | | | | | | | |
180 * | | | | | | | +- Output Buffer Full?
181 * | | | | | | +--- Input Buffer Full?
182 * | | | | | +----- <reserved>
183 * | | | | +------- Data Register is Command Byte?
184 * | | | +--------- Burst Mode Enabled?
185 * | | +----------- SCI Event?
186 * | +------------- SMI Event?
187 * +--------------- <Reserved>
188 *
189 */
190 typedef UINT8 EC_STATUS;
191
192 #define EC_FLAG_OUTPUT_BUFFER ((EC_STATUS) 0x01)
193 #define EC_FLAG_INPUT_BUFFER ((EC_STATUS) 0x02)
194 #define EC_FLAG_BURST_MODE ((EC_STATUS) 0x10)
195 #define EC_FLAG_SCI ((EC_STATUS) 0x20)
196
197 /*
198 * EC_EVENT:
199 * ---------
200 */
201 typedef UINT8 EC_EVENT;
202
203 #define EC_EVENT_UNKNOWN ((EC_EVENT) 0x00)
204 #define EC_EVENT_OUTPUT_BUFFER_FULL ((EC_EVENT) 0x01)
205 #define EC_EVENT_INPUT_BUFFER_EMPTY ((EC_EVENT) 0x02)
206 #define EC_EVENT_SCI ((EC_EVENT) 0x20)
207
208 /*
209 * Register access primitives
210 */
211 #define EC_GET_DATA(sc) \
212 bus_space_read_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0)
213
214 #define EC_SET_DATA(sc, v) \
215 bus_space_write_1((sc)->ec_data_tag, (sc)->ec_data_handle, 0, (v))
216
217 #define EC_GET_CSR(sc) \
218 bus_space_read_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0)
219
220 #define EC_SET_CSR(sc, v) \
221 bus_space_write_1((sc)->ec_csr_tag, (sc)->ec_csr_handle, 0, (v))
222
223 /*
224 * Driver softc.
225 */
226 struct acpi_ec_softc {
227 device_t ec_dev;
228 ACPI_HANDLE ec_handle;
229 UINT32 ec_gpebit;
230
231 int ec_data_rid;
232 struct resource *ec_data_res;
233 bus_space_tag_t ec_data_tag;
234 bus_space_handle_t ec_data_handle;
235
236 int ec_csr_rid;
237 struct resource *ec_csr_res;
238 bus_space_tag_t ec_csr_tag;
239 bus_space_handle_t ec_csr_handle;
240
241 int ec_locked;
242 int ec_lockhandle;
243 int ec_pendquery;
244 int ec_csrvalue;
245 };
246
247 static int acpi_ec_event_driven = 0;
248 TUNABLE_INT("hw.acpi.ec.event_driven", &acpi_ec_event_driven);
249
250 #define EC_LOCK_TIMEOUT 1000 /* 1ms */
251
252 static __inline ACPI_STATUS
253 EcLock(struct acpi_ec_softc *sc)
254 {
255 ACPI_STATUS status;
256
257 /* XXX ACPI_WAIT_FOREVER is probably a bad idea, what is a better time? */
258 status = AcpiAcquireGlobalLock(ACPI_WAIT_FOREVER, &sc->ec_lockhandle);
259 if (ACPI_SUCCESS(status))
260 sc->ec_locked = 1;
261
262 return (status);
263 }
264
265 static __inline void
266 EcUnlock(struct acpi_ec_softc *sc)
267 {
268 sc->ec_locked = 0;
269 AcpiReleaseGlobalLock(sc->ec_lockhandle);
270 }
271
272 static __inline int
273 EcIsLocked(struct acpi_ec_softc *sc)
274 {
275 return (sc->ec_locked != 0);
276 }
277
278 typedef struct
279 {
280 EC_COMMAND Command;
281 UINT8 Address;
282 UINT8 Data;
283 } EC_REQUEST;
284
285 static void EcGpeHandler(void *Context);
286 static ACPI_STATUS EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function,
287 void *Context, void **return_Context);
288 static ACPI_STATUS EcSpaceHandler(UINT32 Function,
289 ACPI_PHYSICAL_ADDRESS Address,
290 UINT32 width, ACPI_INTEGER *Value,
291 void *Context, void *RegionContext);
292 static ACPI_STATUS EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event);
293 static ACPI_STATUS EcQuery(struct acpi_ec_softc *sc, UINT8 *Data);
294 static ACPI_STATUS EcTransaction(struct acpi_ec_softc *sc,
295 EC_REQUEST *EcRequest);
296 static ACPI_STATUS EcRead(struct acpi_ec_softc *sc, UINT8 Address,
297 UINT8 *Data);
298 static ACPI_STATUS EcWrite(struct acpi_ec_softc *sc, UINT8 Address,
299 UINT8 *Data);
300 static void acpi_ec_identify(driver_t driver, device_t bus);
301 static int acpi_ec_probe(device_t dev);
302 static int acpi_ec_attach(device_t dev);
303
304 static device_method_t acpi_ec_methods[] = {
305 /* Device interface */
306 DEVMETHOD(device_identify, acpi_ec_identify),
307 DEVMETHOD(device_probe, acpi_ec_probe),
308 DEVMETHOD(device_attach, acpi_ec_attach),
309
310 {0, 0}
311 };
312
313 static driver_t acpi_ec_driver = {
314 "acpi_ec",
315 acpi_ec_methods,
316 sizeof(struct acpi_ec_softc),
317 };
318
319 static devclass_t acpi_ec_devclass;
320 DRIVER_MODULE(acpi_ec, acpi, acpi_ec_driver, acpi_ec_devclass, 0, 0);
321
322 /*
323 * Look for an ECDT table and if we find one, set up a default EC
324 * space handler to catch possible attempts to access EC space before
325 * we have a real driver instance in place.
326 * We're not really an identify routine, but because we get called
327 * before most other things, this works out OK.
328 */
329 static void
330 acpi_ec_identify(driver_t driver, device_t bus)
331 {
332 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
333
334 /* XXX implement - need an ACPI 2.0 system to test this */
335 }
336
337 /*
338 * We could setup resources in the probe routine in order to have them printed
339 * when the device is attached.
340 */
341 static int
342 acpi_ec_probe(device_t dev)
343 {
344
345 if (acpi_get_type(dev) == ACPI_TYPE_DEVICE && !acpi_disabled("ec") &&
346 acpi_MatchHid(dev, "PNP0C09")) {
347
348 /*
349 * Set device description
350 */
351 device_set_desc(dev, "embedded controller");
352 return (0);
353 }
354 return (ENXIO);
355 }
356
357 static int
358 acpi_ec_attach(device_t dev)
359 {
360 struct acpi_ec_softc *sc;
361 ACPI_STATUS Status;
362 int errval = 0;
363
364 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
365
366 /*
367 * Fetch/initialise softc
368 */
369 sc = device_get_softc(dev);
370 bzero(sc, sizeof(*sc));
371 sc->ec_dev = dev;
372 sc->ec_handle = acpi_get_handle(dev);
373
374 /*
375 * Attach bus resources
376 */
377 sc->ec_data_rid = 0;
378 sc->ec_data_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT,
379 &sc->ec_data_rid, 0, ~0, 1, RF_ACTIVE);
380 if (sc->ec_data_res == NULL) {
381 device_printf(dev, "can't allocate data port\n");
382 errval = ENXIO;
383 goto out;
384 }
385 sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
386 sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
387
388 sc->ec_csr_rid = 1;
389 sc->ec_csr_res = bus_alloc_resource(sc->ec_dev, SYS_RES_IOPORT,
390 &sc->ec_csr_rid, 0, ~0, 1, RF_ACTIVE);
391 if (sc->ec_csr_res == NULL) {
392 device_printf(dev, "can't allocate command/status port\n");
393 errval = ENXIO;
394 goto out;
395 }
396 sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
397 sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
398
399 /*
400 * Install GPE handler
401 *
402 * Evaluate the _GPE method to find the GPE bit used by the EC to signal
403 * status (SCI).
404 */
405 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE\n"));
406 Status = acpi_EvaluateInteger(sc->ec_handle, "_GPE", &sc->ec_gpebit);
407 if (ACPI_FAILURE(Status)) {
408 device_printf(dev, "can't evaluate _GPE - %s\n",
409 AcpiFormatException(Status));
410 errval = ENXIO;
411 goto out;
412 }
413
414 /*
415 * Install a handler for this EC's GPE bit. Note that EC SCIs are
416 * treated as both edge- and level-triggered interrupts; in other words
417 * we clear the status bit immediately after getting an EC-SCI, then
418 * again after we're done processing the event. This guarantees that
419 * events we cause while performing a transaction (e.g. IBE/OBF) get
420 * cleared before re-enabling the GPE.
421 */
422 Status = AcpiInstallGpeHandler(sc->ec_gpebit,
423 ACPI_EVENT_LEVEL_TRIGGERED | ACPI_EVENT_EDGE_TRIGGERED,
424 EcGpeHandler, sc);
425 if (ACPI_FAILURE(Status)) {
426 device_printf(dev, "can't install GPE handler for %s - %s\n",
427 acpi_name(sc->ec_handle), AcpiFormatException(Status));
428 errval = ENXIO;
429 goto out;
430 }
431
432 /*
433 * Install address space handler
434 */
435 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
436 Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
437 EcSpaceHandler, EcSpaceSetup, sc);
438 if (ACPI_FAILURE(Status)) {
439 device_printf(dev, "can't install address space handler for %s - %s\n",
440 acpi_name(sc->ec_handle), AcpiFormatException(Status));
441 panic("very suck");
442 errval = ENXIO;
443 goto out;
444 }
445 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attach complete\n"));
446 return_VALUE (0);
447
448 out:
449 if (sc->ec_csr_res)
450 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
451 sc->ec_csr_res);
452 if (sc->ec_data_res)
453 bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
454 sc->ec_data_res);
455 return_VALUE (errval);
456 }
457
458 static void
459 EcGpeQueryHandler(void *Context)
460 {
461 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
462 UINT8 Data;
463 ACPI_STATUS Status;
464 char qxx[5];
465
466 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
467
468 for (;;) {
469
470 /*
471 * Check EC_SCI.
472 *
473 * Bail out if the EC_SCI bit of the status register is not set.
474 * Note that this function should only be called when
475 * this bit is set (polling is used to detect IBE/OBF events).
476 *
477 * It is safe to do this without locking the controller, as it's
478 * OK to call EcQuery when there's no data ready; in the worst
479 * case we should just find nothing waiting for us and bail.
480 */
481 if ((EC_GET_CSR(sc) & EC_EVENT_SCI) == 0)
482 break;
483
484 /*
485 * Find out why the EC is signalling us
486 */
487 Status = EcQuery(sc, &Data);
488
489 /*
490 * If we failed to get anything from the EC, give up
491 */
492 if (ACPI_FAILURE(Status)) {
493 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
494 "GPE query failed - %s\n", AcpiFormatException(Status));
495 break;
496 }
497
498 /*
499 * Evaluate _Qxx to respond to the controller.
500 */
501 sprintf(qxx, "_Q%02x", Data);
502 strupr(qxx);
503 Status = AcpiEvaluateObject(sc->ec_handle, qxx, NULL, NULL);
504 /*
505 * Ignore spurious query requests.
506 */
507 if (ACPI_FAILURE(Status) && (Data != 0 || Status != AE_NOT_FOUND)) {
508 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
509 "evaluation of GPE query method %s failed - %s\n",
510 qxx, AcpiFormatException(Status));
511 }
512 }
513 /* I know I request Level trigger cleanup */
514 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE)))
515 printf("EcGpeQueryHandler:ClearEvent Failed\n");
516 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0)))
517 printf("EcGpeQueryHandler:EnableEvent Failed\n");
518 }
519
520 /*
521 * Handle a GPE sent to us.
522 */
523 static void
524 EcGpeHandler(void *Context)
525 {
526 struct acpi_ec_softc *sc = Context;
527 int csrvalue;
528
529 /*
530 * If EC is locked, the intr must process EcRead/Write wait only.
531 * Query request must be pending.
532 */
533 if (EcIsLocked(sc)) {
534 csrvalue = EC_GET_CSR(sc);
535 if (csrvalue & EC_EVENT_SCI)
536 sc->ec_pendquery = 1;
537 if ((csrvalue & EC_FLAG_OUTPUT_BUFFER) != 0 ||
538 (csrvalue & EC_FLAG_INPUT_BUFFER) == 0) {
539 sc->ec_csrvalue = csrvalue;
540 wakeup(&sc->ec_csrvalue);
541 }
542 } else {
543 /* Queue GpeQuery Handler */
544 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
545 EcGpeQueryHandler,Context))) {
546 printf("QueryHandler Queuing Failed\n");
547 }
548 }
549 }
550
551 static ACPI_STATUS
552 EcSpaceSetup(ACPI_HANDLE Region, UINT32 Function, void *Context,
553 void **RegionContext)
554 {
555
556 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
557
558 /*
559 * Just pass the context through, there's nothing to do here.
560 */
561 *RegionContext = Context;
562
563 return_ACPI_STATUS (AE_OK);
564 }
565
566 static ACPI_STATUS
567 EcSpaceHandler(UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 width,
568 ACPI_INTEGER *Value, void *Context, void *RegionContext)
569 {
570 struct acpi_ec_softc *sc = (struct acpi_ec_softc *)Context;
571 ACPI_STATUS Status = AE_OK;
572 EC_REQUEST EcRequest;
573 int i;
574
575 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Address);
576
577 if (Address > 0xFF || width % 8 != 0 || Value == NULL || Context == NULL)
578 return_ACPI_STATUS (AE_BAD_PARAMETER);
579
580 switch (Function) {
581 case ACPI_READ:
582 EcRequest.Command = EC_COMMAND_READ;
583 EcRequest.Address = Address;
584 (*Value) = 0;
585 break;
586 case ACPI_WRITE:
587 EcRequest.Command = EC_COMMAND_WRITE;
588 EcRequest.Address = Address;
589 break;
590 default:
591 device_printf(sc->ec_dev, "invalid Address Space function %d\n",
592 Function);
593 return_ACPI_STATUS (AE_BAD_PARAMETER);
594 }
595
596 /*
597 * Perform the transaction.
598 */
599 for (i = 0; i < width; i += 8) {
600 if (Function == ACPI_READ)
601 EcRequest.Data = 0;
602 else
603 EcRequest.Data = (UINT8)((*Value) >> i);
604 Status = EcTransaction(sc, &EcRequest);
605 if (ACPI_FAILURE(Status))
606 break;
607 *Value |= (ACPI_INTEGER)EcRequest.Data << i;
608 if (++EcRequest.Address == 0)
609 return_ACPI_STATUS (AE_BAD_PARAMETER);
610 }
611 return_ACPI_STATUS (Status);
612 }
613
614 /*
615 * Wait for an event interrupt for a specific condition.
616 */
617 static ACPI_STATUS
618 EcWaitEventIntr(struct acpi_ec_softc *sc, EC_EVENT Event)
619 {
620 EC_STATUS EcStatus;
621 int i;
622
623 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, (UINT32)Event);
624
625 /* XXX this should test whether interrupts are available some other way */
626 if (cold || acpi_ec_event_driven)
627 return_ACPI_STATUS (EcWaitEvent(sc, Event));
628
629 if (!EcIsLocked(sc)) {
630 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
631 "EcWaitEventIntr called without EC lock!\n");
632 }
633
634 EcStatus = EC_GET_CSR(sc);
635
636 /* XXX waiting too long? */
637 for (i = 0; i < 10; i++) {
638 /*
639 * Check EC status against the desired event.
640 */
641 if ((Event == EC_EVENT_OUTPUT_BUFFER_FULL) &&
642 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0)
643 return_ACPI_STATUS (AE_OK);
644
645 if ((Event == EC_EVENT_INPUT_BUFFER_EMPTY) &&
646 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0)
647 return_ACPI_STATUS (AE_OK);
648
649 sc->ec_csrvalue = 0;
650 /* XXX sleeping with Acpi Global Lock held */
651 if (tsleep(&sc->ec_csrvalue, PZERO, "EcWait", 1) != EWOULDBLOCK) {
652 EcStatus = sc->ec_csrvalue;
653 } else {
654 EcStatus = EC_GET_CSR(sc);
655 }
656 }
657 return_ACPI_STATUS (AE_ERROR);
658 }
659
660 static ACPI_STATUS
661 EcWaitEvent(struct acpi_ec_softc *sc, EC_EVENT Event)
662 {
663 EC_STATUS EcStatus;
664 UINT32 i = 0;
665
666 if (!EcIsLocked(sc)) {
667 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
668 "EcWaitEvent called without EC lock!\n");
669 }
670
671 /*
672 * Stall 1us:
673 * ----------
674 * Stall for 1 microsecond before reading the status register
675 * for the first time. This allows the EC to set the IBF/OBF
676 * bit to its proper state.
677 *
678 * XXX it is not clear why we read the CSR twice.
679 */
680 AcpiOsStall(1);
681 EcStatus = EC_GET_CSR(sc);
682
683 /*
684 * Wait For Event:
685 * ---------------
686 * Poll the EC status register to detect completion of the last
687 * command. Wait up to 10ms (in 10us chunks) for this to occur.
688 */
689 for (i = 0; i < 1000; i++) {
690 EcStatus = EC_GET_CSR(sc);
691
692 if (Event == EC_EVENT_OUTPUT_BUFFER_FULL &&
693 (EcStatus & EC_FLAG_OUTPUT_BUFFER) != 0)
694 return (AE_OK);
695
696 if (Event == EC_EVENT_INPUT_BUFFER_EMPTY &&
697 (EcStatus & EC_FLAG_INPUT_BUFFER) == 0)
698 return(AE_OK);
699
700 AcpiOsStall(10);
701 }
702
703 return (AE_ERROR);
704 }
705
706 static ACPI_STATUS
707 EcQuery(struct acpi_ec_softc *sc, UINT8 *Data)
708 {
709 ACPI_STATUS Status;
710
711 Status = EcLock(sc);
712 if (ACPI_FAILURE(Status))
713 return (Status);
714
715 EC_SET_CSR(sc, EC_COMMAND_QUERY);
716 Status = EcWaitEvent(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
717 if (ACPI_SUCCESS(Status))
718 *Data = EC_GET_DATA(sc);
719
720 EcUnlock(sc);
721
722 if (ACPI_FAILURE(Status)) {
723 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
724 "timeout waiting for EC to respond to EC_COMMAND_QUERY\n");
725 }
726 return (Status);
727 }
728
729 static ACPI_STATUS
730 EcTransaction(struct acpi_ec_softc *sc, EC_REQUEST *EcRequest)
731 {
732 ACPI_STATUS Status;
733
734 Status = EcLock(sc);
735 if (ACPI_FAILURE(Status))
736 return (Status);
737
738 /*
739 * Perform the transaction.
740 */
741 switch (EcRequest->Command) {
742 case EC_COMMAND_READ:
743 Status = EcRead(sc, EcRequest->Address, &EcRequest->Data);
744 break;
745 case EC_COMMAND_WRITE:
746 Status = EcWrite(sc, EcRequest->Address, &EcRequest->Data);
747 break;
748 default:
749 Status = AE_SUPPORT;
750 break;
751 }
752
753 EcUnlock(sc);
754
755 /*
756 * Clear & Re-Enable the EC GPE:
757 * -----------------------------
758 * 'Consume' any EC GPE events that we generated while performing
759 * the transaction (e.g. IBF/OBF). Clearing the GPE here shouldn't
760 * have an adverse affect on outstanding EC-SCI's, as the source
761 * (EC-SCI) will still be high and thus should trigger the GPE
762 * immediately after we re-enabling it.
763 */
764 if (sc->ec_pendquery) {
765 if (ACPI_FAILURE(AcpiOsQueueForExecution(OSD_PRIORITY_HIGH,
766 EcGpeQueryHandler, sc)))
767 printf("Pend Query Queuing Failed\n");
768 sc->ec_pendquery = 0;
769 }
770
771 if (ACPI_FAILURE(AcpiClearEvent(sc->ec_gpebit, ACPI_EVENT_GPE))) {
772 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
773 "EcRequest: Unable to clear the EC GPE.\n");
774 }
775 if (ACPI_FAILURE(AcpiEnableEvent(sc->ec_gpebit, ACPI_EVENT_GPE, 0))) {
776 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
777 "EcRequest: Unable to re-enable the EC GPE.\n");
778 }
779
780 return (Status);
781 }
782
783
784 static ACPI_STATUS
785 EcRead(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
786 {
787 ACPI_STATUS Status;
788
789 if (!EcIsLocked(sc)) {
790 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
791 "EcRead called without EC lock!\n");
792 }
793
794 /*EcBurstEnable(EmbeddedController);*/
795
796 EC_SET_CSR(sc, EC_COMMAND_READ);
797 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
798 if (ACPI_FAILURE(Status)) {
799 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
800 "EcRead: Failed waiting for EC to process read command.\n");
801 return (Status);
802 }
803
804 EC_SET_DATA(sc, Address);
805 Status = EcWaitEventIntr(sc, EC_EVENT_OUTPUT_BUFFER_FULL);
806 if (ACPI_FAILURE(Status)) {
807 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
808 "EcRead: Failed waiting for EC to send data.\n");
809 return (Status);
810 }
811
812 *Data = EC_GET_DATA(sc);
813
814 /*EcBurstDisable(EmbeddedController);*/
815
816 return (AE_OK);
817 }
818
819 static ACPI_STATUS
820 EcWrite(struct acpi_ec_softc *sc, UINT8 Address, UINT8 *Data)
821 {
822 ACPI_STATUS Status;
823
824 if (!EcIsLocked(sc)) {
825 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
826 "EcWrite called without EC lock!\n");
827 }
828
829 /*EcBurstEnable(EmbeddedController);*/
830
831 EC_SET_CSR(sc, EC_COMMAND_WRITE);
832 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
833 if (ACPI_FAILURE(Status)) {
834 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
835 "EcWrite: Failed waiting for EC to process write command.\n");
836 return (Status);
837 }
838
839 EC_SET_DATA(sc, Address);
840 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
841 if (ACPI_FAILURE(Status)) {
842 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
843 "EcRead: Failed waiting for EC to process address.\n");
844 return (Status);
845 }
846
847 EC_SET_DATA(sc, *Data);
848 Status = EcWaitEventIntr(sc, EC_EVENT_INPUT_BUFFER_EMPTY);
849 if (ACPI_FAILURE(Status)) {
850 ACPI_VPRINT(sc->ec_dev, acpi_device_get_parent_softc(sc->ec_dev),
851 "EcWrite: Failed waiting for EC to process data.\n");
852 return (Status);
853 }
854
855 /*EcBurstDisable(EmbeddedController);*/
856
857 return (AE_OK);
858 }
Cache object: 17204cb67fd03bc29ded417ba09d9663
|