The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_timer.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: acf73c96ef15a8b2f50a5ca5cd0276c5


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.