sys/dev/acpica/acpi_hpet.c

   1 /*-
   2  * Copyright (c) 2005 Poul-Henning Kamp
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/acpica/acpi_hpet.c,v 1.12.2.1.2.1 2008/11/25 02:59:29 kensmith Exp $
  27  */
  28
  29 #include "opt_acpi.h"
  30
  31 #include <sys/param.h>
  32 #include <sys/bus.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/systimer.h>
  36 #include <sys/rman.h>
  37
  38 #include "acpi.h"
  39 #include "accommon.h"
  40 #include "acpivar.h"
  41 #include "acpi_hpet.h"
  42
  43 /* Hooks for the ACPICA debugging infrastructure */
  44 #define _COMPONENT      ACPI_TIMER
  45 ACPI_MODULE_NAME("HPET")
  46
  47 static bus_space_handle_t       acpi_hpet_bsh;
  48 static bus_space_tag_t          acpi_hpet_bst;
  49 static u_long                   acpi_hpet_res_start;
  50
  51 struct acpi_hpet_softc {
  52         device_t                dev;
  53         struct resource         *mem_res;
  54         ACPI_HANDLE             handle;
  55 };
  56
  57 #define DEV_HPET(x)     (acpi_get_magic(x) == (uintptr_t)&acpi_hpet_devclass)
  58
  59 static sysclock_t       acpi_hpet_get_timecount(void);
  60 static void             acpi_hpet_construct(struct cputimer *, sysclock_t);
  61
  62 static int              acpi_hpet_identify(driver_t *, device_t);
  63 static int              acpi_hpet_probe(device_t);
  64 static int              acpi_hpet_attach(device_t);
  65 static int              acpi_hpet_resume(device_t);
  66 static int              acpi_hpet_suspend(device_t);
  67
  68 static void             acpi_hpet_test(struct acpi_hpet_softc *sc);
  69 static u_int            acpi_hpet_read(void);
  70 static void             acpi_hpet_enable(struct acpi_hpet_softc *);
  71 static void             acpi_hpet_disable(struct acpi_hpet_softc *);
  72
  73 static char *hpet_ids[] = { "PNP0103", NULL };
  74
  75 static struct cputimer acpi_hpet_timer = {
  76         .next           = SLIST_ENTRY_INITIALIZER,
  77         .name           = "HPET",
  78         .pri            = CPUTIMER_PRI_HPET,
  79         .type           = CPUTIMER_HPET,
  80         .count          = acpi_hpet_get_timecount,
  81         .fromhz         = cputimer_default_fromhz,
  82         .fromus         = cputimer_default_fromus,
  83         .construct      = acpi_hpet_construct,
  84         .destruct       = cputimer_default_destruct,
  85         .freq           = 0     /* determined later */
  86 };
  87
  88 static device_method_t acpi_hpet_methods[] = {
  89         DEVMETHOD(device_identify,      acpi_hpet_identify),
  90         DEVMETHOD(device_probe,         acpi_hpet_probe),
  91         DEVMETHOD(device_attach,        acpi_hpet_attach),
  92         DEVMETHOD(device_suspend,       acpi_hpet_suspend),
  93         DEVMETHOD(device_resume,        acpi_hpet_resume),
  94         DEVMETHOD_END
  95 };
  96
  97 static driver_t acpi_hpet_driver = {
  98         "acpi_hpet",
  99         acpi_hpet_methods,
 100         sizeof(struct acpi_hpet_softc),
 101 };
 102
 103 static devclass_t acpi_hpet_devclass;
 104 DRIVER_MODULE(acpi_hpet, acpi, acpi_hpet_driver, acpi_hpet_devclass, NULL, NULL);
 105 MODULE_DEPEND(acpi_hpet, acpi, 1, 1, 1);
 106
 107 static u_int
 108 acpi_hpet_read(void)
 109 {
 110         return bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh,
 111                                 HPET_MAIN_COUNTER);
 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_hpet_identify(driver_t *driver, device_t parent)
 120 {
 121         ACPI_TABLE_HPET *hpet;
 122         ACPI_TABLE_HEADER *hdr;
 123         ACPI_STATUS status;
 124         device_t child;
 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         /* Only one HPET device can be added. */
 135         if (devclass_get_device(acpi_hpet_devclass, 0))
 136                 return ENXIO;
 137
 138         /* Currently, ID and minimum clock tick info is unused. */
 139
 140         status = AcpiGetTable(ACPI_SIG_HPET, 1, &hdr);
 141         if (ACPI_FAILURE(status))
 142                 return ENXIO;
 143
 144         /*
 145          * The unit number could be derived from hdr->Sequence but we only
 146          * support one HPET device.
 147          */
 148         hpet = (ACPI_TABLE_HPET *)hdr;
 149         if (hpet->Sequence != 0) {
 150                 kprintf("ACPI HPET table warning: Sequence is non-zero (%d)\n",
 151                         hpet->Sequence);
 152         }
 153
 154         child = BUS_ADD_CHILD(parent, parent, 0, "acpi_hpet", 0);
 155         if (child == NULL) {
 156                 device_printf(parent, "%s: can't add acpi_hpet0\n", __func__);
 157                 return ENXIO;
 158         }
 159
 160         /* Record a magic value so we can detect this device later. */
 161         acpi_set_magic(child, (uintptr_t)&acpi_hpet_devclass);
 162
 163         acpi_hpet_res_start = hpet->Address.Address;
 164         if (bus_set_resource(child, SYS_RES_MEMORY, 0,
 165                              hpet->Address.Address, HPET_MEM_WIDTH, -1)) {
 166                 device_printf(child, "could not set iomem resources: "
 167                               "0x%jx, %d\n", (uintmax_t)hpet->Address.Address,
 168                               HPET_MEM_WIDTH);
 169                 return ENOMEM;
 170         }
 171         return 0;
 172 }
 173
 174 static int
 175 acpi_hpet_probe(device_t dev)
 176 {
 177         ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);
 178
 179         if (acpi_disabled("hpet"))
 180                 return ENXIO;
 181
 182         if (!DEV_HPET(dev) &&
 183             (ACPI_ID_PROBE(device_get_parent(dev), dev, hpet_ids) == NULL ||
 184              device_get_unit(dev) != 0))
 185                 return ENXIO;
 186
 187         device_set_desc(dev, "High Precision Event Timer");
 188         return 0;
 189 }
 190
 191 static int
 192 acpi_hpet_attach(device_t dev)
 193 {
 194         struct acpi_hpet_softc *sc;
 195         int rid;
 196         uint32_t val, val2;
 197         uintmax_t freq;
 198
 199         ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);
 200
 201         sc = device_get_softc(dev);
 202         sc->dev = dev;
 203         sc->handle = acpi_get_handle(dev);
 204
 205         rid = 0;
 206         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 207                                              RF_ACTIVE);
 208         if (sc->mem_res == NULL) {
 209                 /*
 210                  * We only need to make sure that main counter
 211                  * is accessable.
 212                  */
 213                 device_printf(dev, "can't map %dB register space, try %dB\n",
 214                               HPET_MEM_WIDTH, HPET_MEM_WIDTH_MIN);
 215                 rid = 0;
 216                 sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
 217                                 acpi_hpet_res_start,
 218                                 acpi_hpet_res_start + HPET_MEM_WIDTH_MIN - 1,
 219                                 HPET_MEM_WIDTH_MIN, RF_ACTIVE);
 220                 if (sc->mem_res == NULL)
 221                         return ENOMEM;
 222         }
 223
 224         /* Validate that we can access the whole region. */
 225         if (rman_get_size(sc->mem_res) < HPET_MEM_WIDTH_MIN) {
 226                 device_printf(dev, "memory region width %ld too small\n",
 227                               rman_get_size(sc->mem_res));
 228                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->mem_res);
 229                 return ENXIO;
 230         }
 231
 232         acpi_hpet_bsh = rman_get_bushandle(sc->mem_res);
 233         acpi_hpet_bst = rman_get_bustag(sc->mem_res);
 234
 235         /* Be sure timer is enabled. */
 236         acpi_hpet_enable(sc);
 237
 238         /* Read basic statistics about the timer. */
 239         val = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_PERIOD);
 240         if (val == 0) {
 241                 device_printf(dev, "invalid period\n");
 242                 acpi_hpet_disable(sc);
 243                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->mem_res);
 244                 return ENXIO;
 245         }
 246
 247         freq = (1000000000000000LL + val / 2) / val;
 248         if (bootverbose) {
 249                 val = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh,
 250                                        HPET_CAPABILITIES);
 251                 device_printf(dev,
 252                     "vend: 0x%x, rev: 0x%x, num: %d, opts:%s%s\n",
 253                     val >> 16, val & HPET_CAP_REV_ID,
 254                     (val & HPET_CAP_NUM_TIM) >> 8,
 255                     (val & HPET_CAP_LEG_RT) ? " legacy_route" : "",
 256                     (val & HPET_CAP_COUNT_SIZE) ? " 64-bit" : "");
 257         }
 258
 259         if (ktestenv("debug.acpi.hpet_test"))
 260                 acpi_hpet_test(sc);
 261
 262         /*
 263          * Don't attach if the timer never increments.  Since the spec
 264          * requires it to be at least 10 MHz, it has to change in 1 us.
 265          */
 266         val = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh,
 267                                HPET_MAIN_COUNTER);
 268         DELAY(1);
 269         val2 = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh,
 270                                 HPET_MAIN_COUNTER);
 271         if (val == val2) {
 272                 device_printf(dev, "HPET never increments, disabling\n");
 273                 acpi_hpet_disable(sc);
 274                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->mem_res);
 275                 return ENXIO;
 276         }
 277
 278         acpi_hpet_timer.freq = freq;
 279         device_printf(dev, "frequency %u\n", acpi_hpet_timer.freq);
 280
 281         cputimer_register(&acpi_hpet_timer);
 282         cputimer_select(&acpi_hpet_timer, 0);
 283
 284         return 0;
 285 }
 286
 287 /*
 288  * Construct the timer.  Adjust the base so the system clock does not
 289  * jump weirdly.
 290  */
 291 static void
 292 acpi_hpet_construct(struct cputimer *timer, sysclock_t oldclock)
 293 {
 294         timer->base = 0;
 295         timer->base = oldclock - acpi_hpet_get_timecount();
 296 }
 297
 298 static sysclock_t
 299 acpi_hpet_get_timecount(void)
 300 {
 301         return acpi_hpet_read() + acpi_hpet_timer.base;
 302 }
 303
 304 static void
 305 acpi_hpet_enable(struct acpi_hpet_softc *sc)
 306 {
 307         uint32_t val;
 308
 309         val = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_CONFIG);
 310         bus_space_write_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_CONFIG,
 311                           val | HPET_CNF_ENABLE);
 312 }
 313
 314 static void
 315 acpi_hpet_disable(struct acpi_hpet_softc *sc)
 316 {
 317         uint32_t val;
 318
 319         val = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_CONFIG);
 320         bus_space_write_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_CONFIG,
 321                           val & ~HPET_CNF_ENABLE);
 322 }
 323
 324 static int
 325 acpi_hpet_suspend(device_t dev)
 326 {
 327         /*
 328          * According to IA-PC HPET specification rev 1.0a
 329          *
 330          * Page 10, 2.3.3:
 331          * "1. The Event Timer registers (including the main counter)
 332          *  are not expected to be preserved through an S3, S4, or S5
 333          *  state."
 334          *
 335          * Page 11, 2.3.3:
 336          * "3. The main counter is permitted, but not required, to run
 337          *  during S1 or S2 states. ..."
 338          *
 339          * These mean we are not allowed to enter any of Sx states,
 340          * if HPET is used as the sys_cputimer.
 341          */
 342         if (sys_cputimer != &acpi_hpet_timer) {
 343                 struct acpi_hpet_softc *sc;
 344
 345                 sc = device_get_softc(dev);
 346                 acpi_hpet_disable(sc);
 347
 348                 return 0;
 349         } else {
 350                 return EOPNOTSUPP;
 351         }
 352 }
 353
 354 static int
 355 acpi_hpet_resume(device_t dev)
 356 {
 357         if (sys_cputimer != &acpi_hpet_timer) {
 358                 struct acpi_hpet_softc *sc;
 359
 360                 sc = device_get_softc(dev);
 361                 acpi_hpet_enable(sc);
 362         }
 363         return 0;
 364 }
 365
 366 /* Print some basic latency/rate information to assist in debugging. */
 367 static void
 368 acpi_hpet_test(struct acpi_hpet_softc *sc)
 369 {
 370         int i;
 371         uint32_t u1, u2;
 372         struct timeval b0, b1, b2;
 373         struct timespec ts;
 374
 375         microuptime(&b0);
 376         microuptime(&b0);
 377         microuptime(&b1);
 378         u1 = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_MAIN_COUNTER);
 379         for (i = 1; i < 1000; i++) {
 380                 u2 = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh,
 381                                       HPET_MAIN_COUNTER);
 382         }
 383         microuptime(&b2);
 384         u2 = bus_space_read_4(acpi_hpet_bst, acpi_hpet_bsh, HPET_MAIN_COUNTER);
 385
 386         timevalsub(&b2, &b1);
 387         timevalsub(&b1, &b0);
 388         timevalsub(&b2, &b1);
 389
 390         TIMEVAL_TO_TIMESPEC(&b2, &ts);
 391
 392         device_printf(sc->dev, "%ld.%09ld: %u ... %u = %u\n",
 393             (long)b2.tv_sec, b2.tv_usec, u1, u2, u2 - u1);
 394
 395         device_printf(sc->dev, "time per call: %ld ns\n", ts.tv_nsec / 1000);
 396 }