sys/dev/acpica5/acpi_cpu.c

   1 /*-
   2  * Copyright (c) 2003-2005 Nate Lawson (SDG)
   3  * Copyright (c) 2001 Michael Smith
   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_cpu.c,v 1.72 2008/04/12 12:06:00 rpaulo Exp $
  28  * $DragonFly: src/sys/dev/acpica5/acpi_cpu.c,v 1.21 2008/09/05 10:28:35 hasso Exp $
  29  */
  30
  31 #include "opt_acpi.h"
  32
  33 #include <sys/param.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/sysctl.h>
  37
  38 #include <machine/globaldata.h>
  39 #include <machine/smp.h>
  40
  41 #include "acpi.h"
  42 #include "acpivar.h"
  43 #include "acpi_cpu.h"
  44
  45 #define ACPI_NOTIFY_CX_STATES   0x81    /* _CST changed. */
  46
  47 static int      acpi_cpu_probe(device_t dev);
  48 static int      acpi_cpu_attach(device_t dev);
  49 static struct resource_list *
  50                 acpi_cpu_get_rlist(device_t, device_t);
  51 static struct resource *
  52                 acpi_cpu_alloc_resource(device_t, device_t,
  53                         int, int *, u_long, u_long, u_long, u_int);
  54 static int      acpi_cpu_release_resource(device_t, device_t,
  55                         int, int, struct resource *);
  56
  57 static int      acpi_cpu_get_id(uint32_t, uint32_t *, uint32_t *);
  58 static void     acpi_cpu_notify(ACPI_HANDLE, UINT32, void *);
  59
  60 static device_method_t acpi_cpu_methods[] = {
  61     /* Device interface */
  62     DEVMETHOD(device_probe,             acpi_cpu_probe),
  63     DEVMETHOD(device_attach,            acpi_cpu_attach),
  64     DEVMETHOD(device_detach,            bus_generic_detach),
  65     DEVMETHOD(device_shutdown,          bus_generic_shutdown),
  66     DEVMETHOD(device_suspend,           bus_generic_suspend),
  67     DEVMETHOD(device_resume,            bus_generic_resume),
  68
  69     /* Bus interface */
  70     DEVMETHOD(bus_add_child,            bus_generic_add_child),
  71     DEVMETHOD(bus_print_child,          bus_generic_print_child),
  72     DEVMETHOD(bus_read_ivar,            bus_generic_read_ivar),
  73     DEVMETHOD(bus_write_ivar,           bus_generic_write_ivar),
  74     DEVMETHOD(bus_get_resource_list,    acpi_cpu_get_rlist),
  75     DEVMETHOD(bus_set_resource,         bus_generic_rl_set_resource),
  76     DEVMETHOD(bus_get_resource,         bus_generic_rl_get_resource),
  77     DEVMETHOD(bus_alloc_resource,       acpi_cpu_alloc_resource),
  78     DEVMETHOD(bus_release_resource,     acpi_cpu_release_resource),
  79     DEVMETHOD(bus_driver_added,         bus_generic_driver_added),
  80     DEVMETHOD(bus_activate_resource,    bus_generic_activate_resource),
  81     DEVMETHOD(bus_deactivate_resource,  bus_generic_deactivate_resource),
  82     DEVMETHOD(bus_setup_intr,           bus_generic_setup_intr),
  83     DEVMETHOD(bus_teardown_intr,        bus_generic_teardown_intr),
  84
  85     { 0, 0 }
  86 };
  87
  88 static driver_t acpi_cpu_driver = {
  89     "cpu",
  90     acpi_cpu_methods,
  91     sizeof(struct acpi_cpux_softc)
  92 };
  93
  94 static devclass_t acpi_cpu_devclass;
  95 DRIVER_MODULE(cpu, acpi, acpi_cpu_driver, acpi_cpu_devclass, 0, 0);
  96 MODULE_DEPEND(cpu, acpi, 1, 1, 1);
  97
  98 static int
  99 acpi_cpu_probe(device_t dev)
 100 {
 101     int acpi_id, cpu_id;
 102     ACPI_BUFFER buf;
 103     ACPI_HANDLE handle;
 104     ACPI_STATUS status;
 105     ACPI_OBJECT *obj;
 106
 107     if (acpi_disabled("cpu") || acpi_get_type(dev) != ACPI_TYPE_PROCESSOR)
 108         return ENXIO;
 109
 110     handle = acpi_get_handle(dev);
 111
 112     /*
 113      * Get our Processor object.
 114      */
 115     buf.Pointer = NULL;
 116     buf.Length = ACPI_ALLOCATE_BUFFER;
 117     status = AcpiEvaluateObject(handle, NULL, NULL, &buf);
 118     if (ACPI_FAILURE(status)) {
 119         device_printf(dev, "probe failed to get Processor obj - %s\n",
 120                       AcpiFormatException(status));
 121         return ENXIO;
 122     }
 123
 124     obj = (ACPI_OBJECT *)buf.Pointer;
 125     if (obj->Type != ACPI_TYPE_PROCESSOR) {
 126         device_printf(dev, "Processor object has bad type %d\n", obj->Type);
 127         AcpiOsFree(obj);
 128         return ENXIO;
 129     }
 130
 131     acpi_id = obj->Processor.ProcId;
 132     AcpiOsFree(obj);
 133
 134     /*
 135      * Find the processor associated with our unit.  We could use the
 136      * ProcId as a key, however, some boxes do not have the same values
 137      * in their Processor object as the ProcId values in the MADT.
 138      */
 139     if (acpi_cpu_get_id(device_get_unit(dev), &acpi_id, &cpu_id) != 0)
 140         return ENXIO;
 141
 142     acpi_set_magic(dev, cpu_id);
 143     device_set_desc(dev, "ACPI CPU");
 144
 145     return 0;
 146 }
 147
 148 static int
 149 acpi_cpu_attach(device_t dev)
 150 {
 151     struct acpi_cpux_softc *sc = device_get_softc(dev);
 152     ACPI_HANDLE handle;
 153     device_t child;
 154     int cpu_id;
 155     struct acpi_softc *acpi_sc;
 156
 157     handle = acpi_get_handle(dev);
 158     cpu_id = acpi_get_magic(dev);
 159
 160     acpi_sc = acpi_device_get_parent_softc(dev);
 161     if (cpu_id == 0) {
 162         sysctl_ctx_init(&sc->glob_sysctl_ctx);
 163         sc->glob_sysctl_tree = SYSCTL_ADD_NODE(&sc->glob_sysctl_ctx,
 164                                SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
 165                                OID_AUTO, "cpu", CTLFLAG_RD, 0,
 166                                "node for CPU global settings");
 167         if (sc->glob_sysctl_tree == NULL)
 168             return ENOMEM;
 169     }
 170
 171     sysctl_ctx_init(&sc->pcpu_sysctl_ctx);
 172     sc->pcpu_sysctl_tree = SYSCTL_ADD_NODE(&sc->pcpu_sysctl_ctx,
 173                            SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
 174                            OID_AUTO, device_get_nameunit(dev), CTLFLAG_RD, 0,
 175                            "node for per-CPU settings");
 176     if (sc->pcpu_sysctl_tree == NULL) {
 177         sysctl_ctx_free(&sc->glob_sysctl_ctx);
 178         return ENOMEM;
 179     }
 180
 181     child = BUS_ADD_CHILD(dev, dev, 0, "cpu_cst", -1);
 182     if (child == NULL)
 183         return ENXIO;
 184     acpi_set_handle(child, handle);
 185     acpi_set_magic(child, cpu_id);
 186     sc->cpux_cst = child;
 187
 188     child = BUS_ADD_CHILD(dev, dev, 0, "cpu_pst", -1);
 189     if (child == NULL)
 190         return ENXIO;
 191     acpi_set_handle(child, handle);
 192     acpi_set_magic(child, cpu_id);
 193
 194     bus_generic_attach(dev);
 195
 196     AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY, acpi_cpu_notify, sc);
 197
 198     return 0;
 199 }
 200
 201 /*
 202  * All resources are assigned directly to us by acpi,
 203  * so 'child' is bypassed here.
 204  */
 205 static struct resource_list *
 206 acpi_cpu_get_rlist(device_t dev, device_t child __unused)
 207 {
 208     return BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev);
 209 }
 210
 211 static struct resource *
 212 acpi_cpu_alloc_resource(device_t dev, device_t child __unused,
 213                         int type, int *rid, u_long start, u_long end,
 214                         u_long count, u_int flags)
 215 {
 216     return BUS_ALLOC_RESOURCE(device_get_parent(dev), dev, type, rid,
 217                               start, end, count, flags);
 218 }
 219
 220 static int
 221 acpi_cpu_release_resource(device_t dev, device_t child __unused,
 222                           int type, int rid, struct resource *r)
 223 {
 224     return BUS_RELEASE_RESOURCE(device_get_parent(dev), dev, type, rid, r);
 225 }
 226
 227 /*
 228  * Find the nth present CPU and return its pc_cpuid as well as set the
 229  * pc_acpi_id from the most reliable source.
 230  */
 231 static int
 232 acpi_cpu_get_id(uint32_t idx, uint32_t *acpi_id, uint32_t *cpu_id)
 233 {
 234     struct mdglobaldata *md;
 235     uint32_t i;
 236
 237     KASSERT(acpi_id != NULL, ("Null acpi_id"));
 238     KASSERT(cpu_id != NULL, ("Null cpu_id"));
 239     for (i = 0; i < ncpus; i++) {
 240         if ((smp_active_mask & (1 << i)) == 0)
 241             continue;
 242         md = (struct mdglobaldata *)globaldata_find(i);
 243         KASSERT(md != NULL, ("no pcpu data for %d", i));
 244         if (idx-- == 0) {
 245             /*
 246              * If pc_acpi_id was not initialized (e.g., a non-APIC UP box)
 247              * override it with the value from the ASL.  Otherwise, if the
 248              * two don't match, prefer the MADT-derived value.  Finally,
 249              * return the pc_cpuid to reference this processor.
 250              */
 251             if (md->gd_acpi_id == 0xffffffff)
 252                 md->gd_acpi_id = *acpi_id;
 253             else if (md->gd_acpi_id != *acpi_id)
 254                 *acpi_id = md->gd_acpi_id;
 255             *cpu_id = md->mi.gd_cpuid;
 256             return 0;
 257         }
 258     }
 259     return ESRCH;
 260 }
 261
 262 static void
 263 acpi_cpu_notify(ACPI_HANDLE handler __unused, UINT32 notify, void *xsc)
 264 {
 265     struct acpi_cpux_softc *sc = xsc;
 266
 267     switch (notify) {
 268     case ACPI_NOTIFY_CX_STATES:
 269         if (sc->cpux_cst_notify != NULL)
 270             sc->cpux_cst_notify(sc->cpux_cst);
 271         break;
 272     }
 273 }