linux/drivers/acpi/acpi_processor.c
<<
>>
Prefs
   1/*
   2 * acpi_processor.c - ACPI processor enumeration support
   3 *
   4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   6 * Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
   7 * Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
   8 * Copyright (C) 2013, Intel Corporation
   9 *                     Rafael J. Wysocki <rafael.j.wysocki@intel.com>
  10 *
  11 * This program is free software; you can redistribute it and/or modify it
  12 * under the terms of the GNU General Public License version 2 as published
  13 * by the Free Software Foundation.
  14 */
  15
  16#include <linux/acpi.h>
  17#include <linux/device.h>
  18#include <linux/kernel.h>
  19#include <linux/module.h>
  20#include <linux/pci.h>
  21
  22#include <acpi/processor.h>
  23
  24#include <asm/cpu.h>
  25
  26#include "internal.h"
  27
  28#define _COMPONENT      ACPI_PROCESSOR_COMPONENT
  29
  30ACPI_MODULE_NAME("processor");
  31
  32DEFINE_PER_CPU(struct acpi_processor *, processors);
  33EXPORT_PER_CPU_SYMBOL(processors);
  34
  35/* --------------------------------------------------------------------------
  36                                Errata Handling
  37   -------------------------------------------------------------------------- */
  38
  39struct acpi_processor_errata errata __read_mostly;
  40EXPORT_SYMBOL_GPL(errata);
  41
  42static int acpi_processor_errata_piix4(struct pci_dev *dev)
  43{
  44        u8 value1 = 0;
  45        u8 value2 = 0;
  46
  47
  48        if (!dev)
  49                return -EINVAL;
  50
  51        /*
  52         * Note that 'dev' references the PIIX4 ACPI Controller.
  53         */
  54
  55        switch (dev->revision) {
  56        case 0:
  57                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
  58                break;
  59        case 1:
  60                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
  61                break;
  62        case 2:
  63                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
  64                break;
  65        case 3:
  66                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
  67                break;
  68        default:
  69                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
  70                break;
  71        }
  72
  73        switch (dev->revision) {
  74
  75        case 0:         /* PIIX4 A-step */
  76        case 1:         /* PIIX4 B-step */
  77                /*
  78                 * See specification changes #13 ("Manual Throttle Duty Cycle")
  79                 * and #14 ("Enabling and Disabling Manual Throttle"), plus
  80                 * erratum #5 ("STPCLK# Deassertion Time") from the January
  81                 * 2002 PIIX4 specification update.  Applies to only older
  82                 * PIIX4 models.
  83                 */
  84                errata.piix4.throttle = 1;
  85
  86        case 2:         /* PIIX4E */
  87        case 3:         /* PIIX4M */
  88                /*
  89                 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
  90                 * Livelock") from the January 2002 PIIX4 specification update.
  91                 * Applies to all PIIX4 models.
  92                 */
  93
  94                /*
  95                 * BM-IDE
  96                 * ------
  97                 * Find the PIIX4 IDE Controller and get the Bus Master IDE
  98                 * Status register address.  We'll use this later to read
  99                 * each IDE controller's DMA status to make sure we catch all
 100                 * DMA activity.
 101                 */
 102                dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 103                                     PCI_DEVICE_ID_INTEL_82371AB,
 104                                     PCI_ANY_ID, PCI_ANY_ID, NULL);
 105                if (dev) {
 106                        errata.piix4.bmisx = pci_resource_start(dev, 4);
 107                        pci_dev_put(dev);
 108                }
 109
 110                /*
 111                 * Type-F DMA
 112                 * ----------
 113                 * Find the PIIX4 ISA Controller and read the Motherboard
 114                 * DMA controller's status to see if Type-F (Fast) DMA mode
 115                 * is enabled (bit 7) on either channel.  Note that we'll
 116                 * disable C3 support if this is enabled, as some legacy
 117                 * devices won't operate well if fast DMA is disabled.
 118                 */
 119                dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 120                                     PCI_DEVICE_ID_INTEL_82371AB_0,
 121                                     PCI_ANY_ID, PCI_ANY_ID, NULL);
 122                if (dev) {
 123                        pci_read_config_byte(dev, 0x76, &value1);
 124                        pci_read_config_byte(dev, 0x77, &value2);
 125                        if ((value1 & 0x80) || (value2 & 0x80))
 126                                errata.piix4.fdma = 1;
 127                        pci_dev_put(dev);
 128                }
 129
 130                break;
 131        }
 132
 133        if (errata.piix4.bmisx)
 134                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 135                                  "Bus master activity detection (BM-IDE) erratum enabled\n"));
 136        if (errata.piix4.fdma)
 137                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 138                                  "Type-F DMA livelock erratum (C3 disabled)\n"));
 139
 140        return 0;
 141}
 142
 143static int acpi_processor_errata(struct acpi_processor *pr)
 144{
 145        int result = 0;
 146        struct pci_dev *dev = NULL;
 147
 148
 149        if (!pr)
 150                return -EINVAL;
 151
 152        /*
 153         * PIIX4
 154         */
 155        dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 156                             PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
 157                             PCI_ANY_ID, NULL);
 158        if (dev) {
 159                result = acpi_processor_errata_piix4(dev);
 160                pci_dev_put(dev);
 161        }
 162
 163        return result;
 164}
 165
 166/* --------------------------------------------------------------------------
 167                                Initialization
 168   -------------------------------------------------------------------------- */
 169
 170#ifdef CONFIG_ACPI_HOTPLUG_CPU
 171static int acpi_processor_hotadd_init(struct acpi_processor *pr)
 172{
 173        unsigned long long sta;
 174        acpi_status status;
 175        int ret;
 176
 177        status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta);
 178        if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT))
 179                return -ENODEV;
 180
 181        ret = acpi_map_lsapic(pr->handle, &pr->id);
 182        if (ret)
 183                return ret;
 184
 185        ret = arch_register_cpu(pr->id);
 186        if (ret) {
 187                acpi_unmap_lsapic(pr->id);
 188                return ret;
 189        }
 190
 191        /*
 192         * CPU got hot-added, but cpu_data is not initialized yet.  Set a flag
 193         * to delay cpu_idle/throttling initialization and do it when the CPU
 194         * gets online for the first time.
 195         */
 196        pr_info("CPU%d has been hot-added\n", pr->id);
 197        pr->flags.need_hotplug_init = 1;
 198        return 0;
 199}
 200#else
 201static inline int acpi_processor_hotadd_init(struct acpi_processor *pr)
 202{
 203        return -ENODEV;
 204}
 205#endif /* CONFIG_ACPI_HOTPLUG_CPU */
 206
 207static int acpi_processor_get_info(struct acpi_device *device)
 208{
 209        union acpi_object object = { 0 };
 210        struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
 211        struct acpi_processor *pr = acpi_driver_data(device);
 212        int cpu_index, device_declaration = 0;
 213        acpi_status status = AE_OK;
 214        static int cpu0_initialized;
 215
 216        if (num_online_cpus() > 1)
 217                errata.smp = TRUE;
 218
 219        acpi_processor_errata(pr);
 220
 221        /*
 222         * Check to see if we have bus mastering arbitration control.  This
 223         * is required for proper C3 usage (to maintain cache coherency).
 224         */
 225        if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
 226                pr->flags.bm_control = 1;
 227                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 228                                  "Bus mastering arbitration control present\n"));
 229        } else
 230                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 231                                  "No bus mastering arbitration control\n"));
 232
 233        if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
 234                /* Declared with "Processor" statement; match ProcessorID */
 235                status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
 236                if (ACPI_FAILURE(status)) {
 237                        dev_err(&device->dev,
 238                                "Failed to evaluate processor object (0x%x)\n",
 239                                status);
 240                        return -ENODEV;
 241                }
 242
 243                /*
 244                 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
 245                 *      >>> 'acpi_get_processor_id(acpi_id, &id)' in
 246                 *      arch/xxx/acpi.c
 247                 */
 248                pr->acpi_id = object.processor.proc_id;
 249        } else {
 250                /*
 251                 * Declared with "Device" statement; match _UID.
 252                 * Note that we don't handle string _UIDs yet.
 253                 */
 254                unsigned long long value;
 255                status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
 256                                                NULL, &value);
 257                if (ACPI_FAILURE(status)) {
 258                        dev_err(&device->dev,
 259                                "Failed to evaluate processor _UID (0x%x)\n",
 260                                status);
 261                        return -ENODEV;
 262                }
 263                device_declaration = 1;
 264                pr->acpi_id = value;
 265        }
 266        cpu_index = acpi_get_cpuid(pr->handle, device_declaration, pr->acpi_id);
 267
 268        /* Handle UP system running SMP kernel, with no LAPIC in MADT */
 269        if (!cpu0_initialized && (cpu_index == -1) &&
 270            (num_online_cpus() == 1)) {
 271                cpu_index = 0;
 272        }
 273
 274        cpu0_initialized = 1;
 275
 276        pr->id = cpu_index;
 277
 278        /*
 279         *  Extra Processor objects may be enumerated on MP systems with
 280         *  less than the max # of CPUs. They should be ignored _iff
 281         *  they are physically not present.
 282         */
 283        if (pr->id == -1) {
 284                int ret = acpi_processor_hotadd_init(pr);
 285                if (ret)
 286                        return ret;
 287        }
 288        /*
 289         * On some boxes several processors use the same processor bus id.
 290         * But they are located in different scope. For example:
 291         * \_SB.SCK0.CPU0
 292         * \_SB.SCK1.CPU0
 293         * Rename the processor device bus id. And the new bus id will be
 294         * generated as the following format:
 295         * CPU+CPU ID.
 296         */
 297        sprintf(acpi_device_bid(device), "CPU%X", pr->id);
 298        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
 299                          pr->acpi_id));
 300
 301        if (!object.processor.pblk_address)
 302                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
 303        else if (object.processor.pblk_length != 6)
 304                dev_err(&device->dev, "Invalid PBLK length [%d]\n",
 305                            object.processor.pblk_length);
 306        else {
 307                pr->throttling.address = object.processor.pblk_address;
 308                pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
 309                pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
 310
 311                pr->pblk = object.processor.pblk_address;
 312
 313                /*
 314                 * We don't care about error returns - we just try to mark
 315                 * these reserved so that nobody else is confused into thinking
 316                 * that this region might be unused..
 317                 *
 318                 * (In particular, allocating the IO range for Cardbus)
 319                 */
 320                request_region(pr->throttling.address, 6, "ACPI CPU throttle");
 321        }
 322
 323        /*
 324         * If ACPI describes a slot number for this CPU, we can use it to
 325         * ensure we get the right value in the "physical id" field
 326         * of /proc/cpuinfo
 327         */
 328        status = acpi_evaluate_object(pr->handle, "_SUN", NULL, &buffer);
 329        if (ACPI_SUCCESS(status))
 330                arch_fix_phys_package_id(pr->id, object.integer.value);
 331
 332        return 0;
 333}
 334
 335/*
 336 * Do not put anything in here which needs the core to be online.
 337 * For example MSR access or setting up things which check for cpuinfo_x86
 338 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
 339 * Such things have to be put in and set up by the processor driver's .probe().
 340 */
 341static DEFINE_PER_CPU(void *, processor_device_array);
 342
 343static int acpi_processor_add(struct acpi_device *device,
 344                                        const struct acpi_device_id *id)
 345{
 346        struct acpi_processor *pr;
 347        struct device *dev;
 348        int result = 0;
 349
 350        pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
 351        if (!pr)
 352                return -ENOMEM;
 353
 354        if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
 355                result = -ENOMEM;
 356                goto err_free_pr;
 357        }
 358
 359        pr->handle = device->handle;
 360        strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
 361        strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
 362        device->driver_data = pr;
 363
 364        result = acpi_processor_get_info(device);
 365        if (result) /* Processor is not physically present or unavailable */
 366                return 0;
 367
 368#ifdef CONFIG_SMP
 369        if (pr->id >= setup_max_cpus && pr->id != 0)
 370                return 0;
 371#endif
 372
 373        BUG_ON(pr->id >= nr_cpu_ids);
 374
 375        /*
 376         * Buggy BIOS check.
 377         * ACPI id of processors can be reported wrongly by the BIOS.
 378         * Don't trust it blindly
 379         */
 380        if (per_cpu(processor_device_array, pr->id) != NULL &&
 381            per_cpu(processor_device_array, pr->id) != device) {
 382                dev_warn(&device->dev,
 383                        "BIOS reported wrong ACPI id %d for the processor\n",
 384                        pr->id);
 385                /* Give up, but do not abort the namespace scan. */
 386                goto err;
 387        }
 388        /*
 389         * processor_device_array is not cleared on errors to allow buggy BIOS
 390         * checks.
 391         */
 392        per_cpu(processor_device_array, pr->id) = device;
 393        per_cpu(processors, pr->id) = pr;
 394
 395        dev = get_cpu_device(pr->id);
 396        if (!dev) {
 397                result = -ENODEV;
 398                goto err;
 399        }
 400
 401        result = acpi_bind_one(dev, pr->handle);
 402        if (result)
 403                goto err;
 404
 405        pr->dev = dev;
 406        dev->offline = pr->flags.need_hotplug_init;
 407
 408        /* Trigger the processor driver's .probe() if present. */
 409        if (device_attach(dev) >= 0)
 410                return 1;
 411
 412        dev_err(dev, "Processor driver could not be attached\n");
 413        acpi_unbind_one(dev);
 414
 415 err:
 416        free_cpumask_var(pr->throttling.shared_cpu_map);
 417        device->driver_data = NULL;
 418        per_cpu(processors, pr->id) = NULL;
 419 err_free_pr:
 420        kfree(pr);
 421        return result;
 422}
 423
 424#ifdef CONFIG_ACPI_HOTPLUG_CPU
 425/* --------------------------------------------------------------------------
 426                                    Removal
 427   -------------------------------------------------------------------------- */
 428
 429static void acpi_processor_remove(struct acpi_device *device)
 430{
 431        struct acpi_processor *pr;
 432
 433        if (!device || !acpi_driver_data(device))
 434                return;
 435
 436        pr = acpi_driver_data(device);
 437        if (pr->id >= nr_cpu_ids)
 438                goto out;
 439
 440        /*
 441         * The only reason why we ever get here is CPU hot-removal.  The CPU is
 442         * already offline and the ACPI device removal locking prevents it from
 443         * being put back online at this point.
 444         *
 445         * Unbind the driver from the processor device and detach it from the
 446         * ACPI companion object.
 447         */
 448        device_release_driver(pr->dev);
 449        acpi_unbind_one(pr->dev);
 450
 451        /* Clean up. */
 452        per_cpu(processor_device_array, pr->id) = NULL;
 453        per_cpu(processors, pr->id) = NULL;
 454
 455        /* Remove the CPU. */
 456        get_online_cpus();
 457        arch_unregister_cpu(pr->id);
 458        acpi_unmap_lsapic(pr->id);
 459        put_online_cpus();
 460
 461        try_offline_node(cpu_to_node(pr->id));
 462
 463 out:
 464        free_cpumask_var(pr->throttling.shared_cpu_map);
 465        kfree(pr);
 466}
 467#endif /* CONFIG_ACPI_HOTPLUG_CPU */
 468
 469/*
 470 * The following ACPI IDs are known to be suitable for representing as
 471 * processor devices.
 472 */
 473static const struct acpi_device_id processor_device_ids[] = {
 474
 475        { ACPI_PROCESSOR_OBJECT_HID, },
 476        { ACPI_PROCESSOR_DEVICE_HID, },
 477
 478        { }
 479};
 480
 481static struct acpi_scan_handler __refdata processor_handler = {
 482        .ids = processor_device_ids,
 483        .attach = acpi_processor_add,
 484#ifdef CONFIG_ACPI_HOTPLUG_CPU
 485        .detach = acpi_processor_remove,
 486#endif
 487        .hotplug = {
 488                .enabled = true,
 489        },
 490};
 491
 492void __init acpi_processor_init(void)
 493{
 494        acpi_scan_add_handler_with_hotplug(&processor_handler, "processor");
 495}
 496
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.