AMD64 - Enable module building, sync i386 headers etc as needed.
[dragonfly.git] / sys / dev / acpica5 / acpi_timer.c
1 /*-
2  * Copyright (c) 2000, 2001 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: src/sys/dev/acpica/acpi_timer.c,v 1.35 2004/07/22 05:42:14 njl Exp $
28  * $DragonFly: src/sys/dev/acpica5/acpi_timer.c,v 1.13 2007/10/09 09:46:56 y0netan1 Exp $
29  */
30 #include "opt_acpi.h"
31 #include <sys/param.h>
32 #include <sys/bus.h>
33 #include <sys/kernel.h>
34 #include <sys/module.h>
35 #include <sys/sysctl.h>
36 #include <sys/systimer.h>
37 #include <sys/rman.h>
38
39 #include <machine/lock.h>
40 #include <bus/pci/pcivar.h>
41
42 #include "acpi.h"
43 #include "acpivar.h"
44
45 /*
46  * A timecounter based on the free-running ACPI timer.
47  *
48  * Based on the i386-only mp_clock.c by <phk@FreeBSD.ORG>.
49  */
50
51 /* Hooks for the ACPI CA debugging infrastructure */
52 #define _COMPONENT      ACPI_TIMER
53 ACPI_MODULE_NAME("TIMER")
54
55 static device_t                 acpi_timer_dev;
56 static struct resource          *acpi_timer_reg;
57 static bus_space_handle_t       acpi_timer_bsh;
58 static bus_space_tag_t          acpi_timer_bst;
59 static sysclock_t               acpi_counter_mask;
60 static sysclock_t               acpi_last_counter;
61
62 #define ACPI_TIMER_FREQ         (14318182 / 4)
63
64 static sysclock_t acpi_timer_get_timecount(void);
65 static sysclock_t acpi_timer_get_timecount24(void);
66 static sysclock_t acpi_timer_get_timecount_safe(void);
67 static void acpi_timer_construct(struct cputimer *timer, sysclock_t oldclock);
68
69 static struct cputimer acpi_cputimer = {
70         SLIST_ENTRY_INITIALIZER,
71         "ACPI",
72         CPUTIMER_PRI_ACPI,
73         CPUTIMER_ACPI,
74         acpi_timer_get_timecount_safe,
75         cputimer_default_fromhz,
76         cputimer_default_fromus,
77         acpi_timer_construct,
78         cputimer_default_destruct,
79         ACPI_TIMER_FREQ,
80         0, 0, 0
81 };
82
83 static int      acpi_timer_identify(driver_t *driver, device_t parent);
84 static int      acpi_timer_probe(device_t dev);
85 static int      acpi_timer_attach(device_t dev);
86 static int      acpi_timer_sysctl_freq(SYSCTL_HANDLER_ARGS);
87
88 static u_int    acpi_timer_read(void);
89 static int      acpi_timer_test(void);
90
91 static device_method_t acpi_timer_methods[] = {
92     DEVMETHOD(device_identify,  acpi_timer_identify),
93     DEVMETHOD(device_probe,     acpi_timer_probe),
94     DEVMETHOD(device_attach,    acpi_timer_attach),
95
96     {0, 0}
97 };
98
99 static driver_t acpi_timer_driver = {
100     "acpi_timer",
101     acpi_timer_methods,
102     0,
103 };
104
105 static devclass_t acpi_timer_devclass;
106 DRIVER_MODULE(acpi_timer, acpi, acpi_timer_driver, acpi_timer_devclass, 0, 0);
107 MODULE_DEPEND(acpi_timer, acpi, 1, 1, 1);
108
109 static u_int
110 acpi_timer_read(void)
111 {
112     return (bus_space_read_4(acpi_timer_bst, acpi_timer_bsh, 0));
113 }
114
115 /*
116  * Locate the ACPI timer using the FADT, set up and allocate the I/O resources
117  * we will be using.
118  */
119 static int
120 acpi_timer_identify(driver_t *driver, device_t parent)
121 {
122     device_t dev;
123     u_long rlen, rstart;
124     int rid, rtype;
125
126     /*
127      * Just try once, do nothing if the 'acpi' bus is rescanned.
128      */
129     if (device_get_state(parent) == DS_ATTACHED)
130         return (0);
131
132     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
133
134     if (acpi_disabled("timer") || acpi_timer_dev)
135         return (ENXIO);
136
137     if ((dev = BUS_ADD_CHILD(parent, parent, 0, "acpi_timer", 0)) == NULL) {
138         device_printf(parent, "could not add acpi_timer0\n");
139         return (ENXIO);
140     }
141     acpi_timer_dev = dev;
142
143     rid = 0;
144     rtype = AcpiGbl_FADT.XPmTimerBlock.SpaceId ?
145         SYS_RES_IOPORT : SYS_RES_MEMORY;
146     rlen = AcpiGbl_FADT.PmTimerLength;
147     rstart = AcpiGbl_FADT.XPmTimerBlock.Address;
148     if (bus_set_resource(dev, rtype, rid, rstart, rlen)) {
149         device_printf(dev, "couldn't set resource (%s 0x%lx+0x%lx)\n",
150             (rtype == SYS_RES_IOPORT) ? "port" : "mem", rstart, rlen);
151         return (ENXIO);
152     }
153     return (0);
154 }
155
156 static int
157 acpi_timer_probe(device_t dev)
158 {
159     char desc[40];
160     int i, j, rid, rtype;
161
162     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
163
164     if (dev != acpi_timer_dev)
165         return (ENXIO);
166
167     rid = 0;
168     rtype = AcpiGbl_FADT.XPmTimerBlock.SpaceId ?
169         SYS_RES_IOPORT : SYS_RES_MEMORY;
170     acpi_timer_reg = bus_alloc_resource_any(dev, rtype, &rid, RF_ACTIVE);
171     if (acpi_timer_reg == NULL) {
172         device_printf(dev, "couldn't allocate resource (%s 0x%lx)\n",
173             (rtype == SYS_RES_IOPORT) ? "port" : "mem",
174             (u_long)AcpiGbl_FADT.XPmTimerBlock.Address);
175         return (ENXIO);
176     }
177     acpi_timer_bsh = rman_get_bushandle(acpi_timer_reg);
178     acpi_timer_bst = rman_get_bustag(acpi_timer_reg);
179     if ((AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER) != 0)
180         acpi_counter_mask = 0xffffffff;
181     else
182         acpi_counter_mask = 0x00ffffff;
183
184     /*
185      * If all tests of the counter succeed, use the ACPI-fast method.  If
186      * at least one failed, default to using the safe routine, which reads
187      * the timer multiple times to get a consistent value before returning.
188      */
189     j = 0;
190     for (i = 0; i < 10; i++)
191         j += acpi_timer_test();
192     if (j == 10) {
193         if (acpi_counter_mask == 0xffffffff) {
194             acpi_cputimer.name = "ACPI-fast";
195             acpi_cputimer.count = acpi_timer_get_timecount;
196         } else {
197             acpi_cputimer.name = "ACPI-fast24";
198             acpi_cputimer.count = acpi_timer_get_timecount24;
199         }
200     } else {
201         if (acpi_counter_mask == 0xffffffff)
202                 acpi_cputimer.name = "ACPI-safe";
203         else
204                 acpi_cputimer.name = "ACPI-safe24";
205         acpi_cputimer.count = acpi_timer_get_timecount_safe;
206     }
207
208     ksprintf(desc, "%d-bit timer at 3.579545MHz",
209             (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER) ? 32 : 24);
210     device_set_desc_copy(dev, desc);
211
212     cputimer_register(&acpi_cputimer);
213     cputimer_select(&acpi_cputimer, 0);
214     /* Release the resource, we'll allocate it again during attach. */
215     bus_release_resource(dev, rtype, rid, acpi_timer_reg);
216     return (0);
217 }
218
219 static int
220 acpi_timer_attach(device_t dev)
221 {
222     int rid, rtype;
223
224     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
225
226     rid = 0;
227     rtype = AcpiGbl_FADT.XPmTimerBlock.SpaceId ?
228         SYS_RES_IOPORT : SYS_RES_MEMORY;
229     acpi_timer_reg = bus_alloc_resource_any(dev, rtype, &rid, RF_ACTIVE);
230     if (acpi_timer_reg == NULL)
231         return (ENXIO);
232     acpi_timer_bsh = rman_get_bushandle(acpi_timer_reg);
233     acpi_timer_bst = rman_get_bustag(acpi_timer_reg);
234     return (0);
235 }
236
237 /*
238  * Construct the timer.  Adjust the base so the system clock does not
239  * jump weirdly.
240  */
241 static void
242 acpi_timer_construct(struct cputimer *timer, sysclock_t oldclock)
243 {
244     timer->base = 0;
245     timer->base = oldclock - acpi_timer_get_timecount_safe();
246 }
247
248 /*
249  * Fetch current time value from reliable hardware.
250  *
251  * The cputimer interface requires a 32 bit return value.  If the ACPI timer
252  * is only 24 bits then we have to keep track of the upper 8 bits on our
253  * own.
254  *
255  * XXX we could probably get away with using a per-cpu field for this and
256  * just use interrupt disablement instead of clock_lock.
257  */
258 static sysclock_t
259 acpi_timer_get_timecount24(void)
260 {
261     sysclock_t counter;
262
263     clock_lock();
264     counter = acpi_timer_read();
265     if (counter < acpi_last_counter)
266         acpi_cputimer.base += 0x01000000;
267     acpi_last_counter = counter;
268     counter += acpi_cputimer.base;
269     clock_unlock();
270     return (counter);
271 }
272
273 static sysclock_t
274 acpi_timer_get_timecount(void)
275 {
276     return (acpi_timer_read() + acpi_cputimer.base);
277 }
278
279 /*
280  * Fetch current time value from hardware that may not correctly
281  * latch the counter.  We need to read until we have three monotonic
282  * samples and then use the middle one, otherwise we are not protected
283  * against the fact that the bits can be wrong in two directions.  If
284  * we only cared about monosity, two reads would be enough.
285  */
286 static sysclock_t
287 acpi_timer_get_timecount_safe(void)
288 {
289     u_int u1, u2, u3;
290
291     if (acpi_counter_mask != 0xffffffff)
292         clock_lock();
293
294     u2 = acpi_timer_read();
295     u3 = acpi_timer_read();
296     do {
297         u1 = u2;
298         u2 = u3;
299         u3 = acpi_timer_read();
300     } while (u1 > u2 || u2 > u3);
301
302     if (acpi_counter_mask != 0xffffffff) {
303         if (u2 < acpi_last_counter)
304             acpi_cputimer.base += 0x01000000;
305         acpi_last_counter = u2;
306         clock_unlock();
307     }
308     return (u2 + acpi_cputimer.base);
309 }
310
311 /*
312  * Timecounter freqency adjustment interface.
313  */ 
314 static int
315 acpi_timer_sysctl_freq(SYSCTL_HANDLER_ARGS)
316 {
317     int error;
318     u_int freq;
319  
320     if (acpi_cputimer.freq == 0)
321         return (EOPNOTSUPP);
322     freq = acpi_cputimer.freq;
323     error = sysctl_handle_int(oidp, &freq, sizeof(freq), req);
324     if (error == 0 && req->newptr != NULL)
325         cputimer_set_frequency(&acpi_cputimer, freq);
326
327     return (error);
328 }
329  
330 SYSCTL_PROC(_machdep, OID_AUTO, acpi_timer_freq, CTLTYPE_INT | CTLFLAG_RW,
331             0, sizeof(u_int), acpi_timer_sysctl_freq, "I", "");
332
333 /*
334  * Some ACPI timers are known or believed to suffer from implementation
335  * problems which can lead to erroneous values being read.  This function
336  * tests for consistent results from the timer and returns 1 if it believes
337  * the timer is consistent, otherwise it returns 0.
338  *
339  * It appears the cause is that the counter is not latched to the PCI bus
340  * clock when read:
341  *
342  * ] 20. ACPI Timer Errata
343  * ]
344  * ]   Problem: The power management timer may return improper result when
345  * ]   read. Although the timer value settles properly after incrementing,
346  * ]   while incrementing there is a 3nS window every 69.8nS where the
347  * ]   timer value is indeterminate (a 4.2% chance that the data will be
348  * ]   incorrect when read). As a result, the ACPI free running count up
349  * ]   timer specification is violated due to erroneous reads.  Implication:
350  * ]   System hangs due to the "inaccuracy" of the timer when used by
351  * ]   software for time critical events and delays.
352  * ]
353  * ] Workaround: Read the register twice and compare.
354  * ] Status: This will not be fixed in the PIIX4 or PIIX4E, it is fixed
355  * ] in the PIIX4M.
356  */
357
358 static int
359 acpi_timer_test(void)
360 {
361     uint32_t    last, this;
362     int         min, max, n, delta;
363     register_t  s;
364
365     min = 10000000;
366     max = 0;
367
368     /* Test the timer with interrupts disabled to get accurate results. */
369 #if defined(__i386__)
370     s = read_eflags();
371 #elif defined(__amd64__)
372     s = read_rflags();
373 #else
374 #error "no read_eflags"
375 #endif
376     cpu_disable_intr();
377     last = acpi_timer_read();
378     for (n = 0; n < 2000; n++) {
379         this = acpi_timer_read();
380         delta = acpi_TimerDelta(this, last);
381         if (delta > max)
382             max = delta;
383         else if (delta < min)
384             min = delta;
385         last = this;
386     }
387 #if defined(__i386__)
388     write_eflags(s);
389 #elif defined(__amd64__)
390     write_rflags(s);
391 #else
392 #error "no read_eflags"
393 #endif
394
395     if (max - min > 2)
396         n = 0;
397     else if (min < 0 || max == 0)
398         n = 0;
399     else
400         n = 1;
401     if (bootverbose) {
402         kprintf("ACPI timer looks %s min = %d, max = %d, width = %d\n",
403                 n ? "GOOD" : "BAD ",
404                 min, max, max - min);
405     }
406
407     return (n);
408 }
409