drivers/acpi/processor_core.c

   1 /*
   2  * acpi_processor.c - ACPI Processor Driver ($Revision: 71 $)
   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  *                      - Added processor hotplug support
   9  *
  10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or (at
  15  *  your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful, but
  18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  *  General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License along
  23  *  with this program; if not, write to the Free Software Foundation, Inc.,
  24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25  *
  26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  27  *  TBD:
  28  *      1. Make # power states dynamic.
  29  *      2. Support duty_cycle values that span bit 4.
  30  *      3. Optimize by having scheduler determine business instead of
  31  *         having us try to calculate it here.
  32  *      4. Need C1 timing -- must modify kernel (IRQ handler) to get this.
  33  */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/module.h>
  37 #include <linux/init.h>
  38 #include <linux/types.h>
  39 #include <linux/pci.h>
  40 #include <linux/pm.h>
  41 #include <linux/cpufreq.h>
  42 #include <linux/cpu.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #include <linux/dmi.h>
  46 #include <linux/moduleparam.h>
  47
  48 #include <asm/io.h>
  49 #include <asm/system.h>
  50 #include <asm/cpu.h>
  51 #include <asm/delay.h>
  52 #include <asm/uaccess.h>
  53 #include <asm/processor.h>
  54 #include <asm/smp.h>
  55 #include <asm/acpi.h>
  56
  57 #include <acpi/acpi_bus.h>
  58 #include <acpi/acpi_drivers.h>
  59 #include <acpi/processor.h>
  60
  61
  62 #define ACPI_PROCESSOR_COMPONENT        0x01000000
  63 #define ACPI_PROCESSOR_CLASS            "processor"
  64 #define ACPI_PROCESSOR_DRIVER_NAME      "ACPI Processor Driver"
  65 #define ACPI_PROCESSOR_DEVICE_NAME      "Processor"
  66 #define ACPI_PROCESSOR_FILE_INFO        "info"
  67 #define ACPI_PROCESSOR_FILE_THROTTLING  "throttling"
  68 #define ACPI_PROCESSOR_FILE_LIMIT       "limit"
  69 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
  70 #define ACPI_PROCESSOR_NOTIFY_POWER     0x81
  71
  72 #define ACPI_PROCESSOR_LIMIT_USER       0
  73 #define ACPI_PROCESSOR_LIMIT_THERMAL    1
  74
  75 #define ACPI_STA_PRESENT 0x00000001
  76
  77 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
  78 ACPI_MODULE_NAME                ("acpi_processor")
  79
  80 MODULE_AUTHOR("Paul Diefenbaugh");
  81 MODULE_DESCRIPTION(ACPI_PROCESSOR_DRIVER_NAME);
  82 MODULE_LICENSE("GPL");
  83
  84
  85 static int acpi_processor_add (struct acpi_device *device);
  86 static int acpi_processor_start (struct acpi_device *device);
  87 static int acpi_processor_remove (struct acpi_device *device, int type);
  88 static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
  89 static void acpi_processor_notify ( acpi_handle handle, u32 event, void *data);
  90 static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
  91 static int acpi_processor_handle_eject(struct acpi_processor *pr);
  92
  93 static struct acpi_driver acpi_processor_driver = {
  94         .name =         ACPI_PROCESSOR_DRIVER_NAME,
  95         .class =        ACPI_PROCESSOR_CLASS,
  96         .ids =          ACPI_PROCESSOR_HID,
  97         .ops =          {
  98                                 .add =          acpi_processor_add,
  99                                 .remove =       acpi_processor_remove,
 100                                 .start  =       acpi_processor_start,
 101                         },
 102 };
 103
 104 #define INSTALL_NOTIFY_HANDLER          1
 105 #define UNINSTALL_NOTIFY_HANDLER        2
 106
 107
 108 static struct file_operations acpi_processor_info_fops = {
 109         .open           = acpi_processor_info_open_fs,
 110         .read           = seq_read,
 111         .llseek         = seq_lseek,
 112         .release        = single_release,
 113 };
 114
 115
 116 struct acpi_processor   *processors[NR_CPUS];
 117 struct acpi_processor_errata errata;
 118
 119
 120 /* --------------------------------------------------------------------------
 121                                 Errata Handling
 122    -------------------------------------------------------------------------- */
 123
 124 static int
 125 acpi_processor_errata_piix4 (
 126         struct pci_dev          *dev)
 127 {
 128         u8                      rev = 0;
 129         u8                      value1 = 0;
 130         u8                      value2 = 0;
 131
 132         ACPI_FUNCTION_TRACE("acpi_processor_errata_piix4");
 133
 134         if (!dev)
 135                 return_VALUE(-EINVAL);
 136
 137         /*
 138          * Note that 'dev' references the PIIX4 ACPI Controller.
 139          */
 140
 141         pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
 142
 143         switch (rev) {
 144         case 0:
 145                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
 146                 break;
 147         case 1:
 148                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
 149                 break;
 150         case 2:
 151                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
 152                 break;
 153         case 3:
 154                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
 155                 break;
 156         default:
 157                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
 158                 break;
 159         }
 160
 161         switch (rev) {
 162
 163         case 0:         /* PIIX4 A-step */
 164         case 1:         /* PIIX4 B-step */
 165                 /*
 166                  * See specification changes #13 ("Manual Throttle Duty Cycle")
 167                  * and #14 ("Enabling and Disabling Manual Throttle"), plus
 168                  * erratum #5 ("STPCLK# Deassertion Time") from the January
 169                  * 2002 PIIX4 specification update.  Applies to only older
 170                  * PIIX4 models.
 171                  */
 172                 errata.piix4.throttle = 1;
 173
 174         case 2:         /* PIIX4E */
 175         case 3:         /* PIIX4M */
 176                 /*
 177                  * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
 178                  * Livelock") from the January 2002 PIIX4 specification update.
 179                  * Applies to all PIIX4 models.
 180                  */
 181
 182                 /*
 183                  * BM-IDE
 184                  * ------
 185                  * Find the PIIX4 IDE Controller and get the Bus Master IDE
 186                  * Status register address.  We'll use this later to read
 187                  * each IDE controller's DMA status to make sure we catch all
 188                  * DMA activity.
 189                  */
 190                 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 191                            PCI_DEVICE_ID_INTEL_82371AB,
 192                            PCI_ANY_ID, PCI_ANY_ID, NULL);
 193                 if (dev) {
 194                         errata.piix4.bmisx = pci_resource_start(dev, 4);
 195                         pci_dev_put(dev);
 196                 }
 197
 198                 /*
 199                  * Type-F DMA
 200                  * ----------
 201                  * Find the PIIX4 ISA Controller and read the Motherboard
 202                  * DMA controller's status to see if Type-F (Fast) DMA mode
 203                  * is enabled (bit 7) on either channel.  Note that we'll
 204                  * disable C3 support if this is enabled, as some legacy
 205                  * devices won't operate well if fast DMA is disabled.
 206                  */
 207                 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 208                         PCI_DEVICE_ID_INTEL_82371AB_0,
 209                         PCI_ANY_ID, PCI_ANY_ID, NULL);
 210                 if (dev) {
 211                         pci_read_config_byte(dev, 0x76, &value1);
 212                         pci_read_config_byte(dev, 0x77, &value2);
 213                         if ((value1 & 0x80) || (value2 & 0x80))
 214                                 errata.piix4.fdma = 1;
 215                         pci_dev_put(dev);
 216                 }
 217
 218                 break;
 219         }
 220
 221         if (errata.piix4.bmisx)
 222                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 223                         "Bus master activity detection (BM-IDE) erratum enabled\n"));
 224         if (errata.piix4.fdma)
 225                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 226                         "Type-F DMA livelock erratum (C3 disabled)\n"));
 227
 228         return_VALUE(0);
 229 }
 230
 231
 232 int
 233 acpi_processor_errata (
 234         struct acpi_processor   *pr)
 235 {
 236         int                     result = 0;
 237         struct pci_dev          *dev = NULL;
 238
 239         ACPI_FUNCTION_TRACE("acpi_processor_errata");
 240
 241         if (!pr)
 242                 return_VALUE(-EINVAL);
 243
 244         /*
 245          * PIIX4
 246          */
 247         dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
 248                 PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID, PCI_ANY_ID, NULL);
 249         if (dev) {
 250                 result = acpi_processor_errata_piix4(dev);
 251                 pci_dev_put(dev);
 252         }
 253
 254         return_VALUE(result);
 255 }
 256
 257
 258 /* --------------------------------------------------------------------------
 259                               FS Interface (/proc)
 260    -------------------------------------------------------------------------- */
 261
 262 static struct proc_dir_entry    *acpi_processor_dir = NULL;
 263
 264 static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
 265 {
 266         struct acpi_processor   *pr = (struct acpi_processor *)seq->private;
 267
 268         ACPI_FUNCTION_TRACE("acpi_processor_info_seq_show");
 269
 270         if (!pr)
 271                 goto end;
 272
 273         seq_printf(seq, "processor id:            %d\n"
 274                         "acpi id:                 %d\n"
 275                         "bus mastering control:   %s\n"
 276                         "power management:        %s\n"
 277                         "throttling control:      %s\n"
 278                         "limit interface:         %s\n",
 279                         pr->id,
 280                         pr->acpi_id,
 281                         pr->flags.bm_control ? "yes" : "no",
 282                         pr->flags.power ? "yes" : "no",
 283                         pr->flags.throttling ? "yes" : "no",
 284                         pr->flags.limit ? "yes" : "no");
 285
 286 end:
 287         return_VALUE(0);
 288 }
 289
 290 static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
 291 {
 292         return single_open(file, acpi_processor_info_seq_show,
 293                                                 PDE(inode)->data);
 294 }
 295
 296
 297 static int
 298 acpi_processor_add_fs (
 299         struct acpi_device      *device)
 300 {
 301         struct proc_dir_entry   *entry = NULL;
 302
 303         ACPI_FUNCTION_TRACE("acpi_processor_add_fs");
 304
 305         if (!acpi_device_dir(device)) {
 306                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 307                         acpi_processor_dir);
 308                 if (!acpi_device_dir(device))
 309                         return_VALUE(-ENODEV);
 310         }
 311         acpi_device_dir(device)->owner = THIS_MODULE;
 312
 313         /* 'info' [R] */
 314         entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
 315                 S_IRUGO, acpi_device_dir(device));
 316         if (!entry)
 317                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 318                         "Unable to create '%s' fs entry\n",
 319                         ACPI_PROCESSOR_FILE_INFO));
 320         else {
 321                 entry->proc_fops = &acpi_processor_info_fops;
 322                 entry->data = acpi_driver_data(device);
 323                 entry->owner = THIS_MODULE;
 324         }
 325
 326         /* 'throttling' [R/W] */
 327         entry = create_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
 328                 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
 329         if (!entry)
 330                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 331                         "Unable to create '%s' fs entry\n",
 332                         ACPI_PROCESSOR_FILE_THROTTLING));
 333         else {
 334                 entry->proc_fops = &acpi_processor_throttling_fops;
 335                 entry->proc_fops->write = acpi_processor_write_throttling;
 336                 entry->data = acpi_driver_data(device);
 337                 entry->owner = THIS_MODULE;
 338         }
 339
 340         /* 'limit' [R/W] */
 341         entry = create_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
 342                 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
 343         if (!entry)
 344                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 345                         "Unable to create '%s' fs entry\n",
 346                         ACPI_PROCESSOR_FILE_LIMIT));
 347         else {
 348                 entry->proc_fops = &acpi_processor_limit_fops;
 349                 entry->proc_fops->write = acpi_processor_write_limit;
 350                 entry->data = acpi_driver_data(device);
 351                 entry->owner = THIS_MODULE;
 352         }
 353
 354         return_VALUE(0);
 355 }
 356
 357
 358 static int
 359 acpi_processor_remove_fs (
 360         struct acpi_device      *device)
 361 {
 362         ACPI_FUNCTION_TRACE("acpi_processor_remove_fs");
 363
 364         if (acpi_device_dir(device)) {
 365                 remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,acpi_device_dir(device));
 366                 remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
 367                         acpi_device_dir(device));
 368                 remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,acpi_device_dir(device));
 369                 remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
 370                 acpi_device_dir(device) = NULL;
 371         }
 372
 373         return_VALUE(0);
 374 }
 375
 376 /* Use the acpiid in MADT to map cpus in case of SMP */
 377 #ifndef CONFIG_SMP
 378 #define convert_acpiid_to_cpu(acpi_id) (0xff)
 379 #else
 380
 381 #ifdef CONFIG_IA64
 382 #define arch_acpiid_to_apicid   ia64_acpiid_to_sapicid
 383 #define arch_cpu_to_apicid      ia64_cpu_to_sapicid
 384 #define ARCH_BAD_APICID         (0xffff)
 385 #else
 386 #define arch_acpiid_to_apicid   x86_acpiid_to_apicid
 387 #define arch_cpu_to_apicid      x86_cpu_to_apicid
 388 #define ARCH_BAD_APICID         (0xff)
 389 #endif
 390
 391 static u8 convert_acpiid_to_cpu(u8 acpi_id)
 392 {
 393         u16 apic_id;
 394         int i;
 395
 396         apic_id = arch_acpiid_to_apicid[acpi_id];
 397         if (apic_id == ARCH_BAD_APICID)
 398                 return -1;
 399
 400         for (i = 0; i < NR_CPUS; i++) {
 401                 if (arch_cpu_to_apicid[i] == apic_id)
 402                         return i;
 403         }
 404         return -1;
 405 }
 406 #endif
 407
 408 /* --------------------------------------------------------------------------
 409                                  Driver Interface
 410    -------------------------------------------------------------------------- */
 411
 412 static int
 413 acpi_processor_get_info (
 414         struct acpi_processor   *pr)
 415 {
 416         acpi_status             status = 0;
 417         union acpi_object       object = {0};
 418         struct acpi_buffer      buffer = {sizeof(union acpi_object), &object};
 419         u8                      cpu_index;
 420         static int              cpu0_initialized;
 421
 422         ACPI_FUNCTION_TRACE("acpi_processor_get_info");
 423
 424         if (!pr)
 425                 return_VALUE(-EINVAL);
 426
 427         if (num_online_cpus() > 1)
 428                 errata.smp = TRUE;
 429
 430         acpi_processor_errata(pr);
 431
 432         /*
 433          * Check to see if we have bus mastering arbitration control.  This
 434          * is required for proper C3 usage (to maintain cache coherency).
 435          */
 436         if (acpi_fadt.V1_pm2_cnt_blk && acpi_fadt.pm2_cnt_len) {
 437                 pr->flags.bm_control = 1;
 438                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 439                         "Bus mastering arbitration control present\n"));
 440         }
 441         else
 442                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 443                         "No bus mastering arbitration control\n"));
 444
 445         /*
 446          * Evalute the processor object.  Note that it is common on SMP to
 447          * have the first (boot) processor with a valid PBLK address while
 448          * all others have a NULL address.
 449          */
 450         status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
 451         if (ACPI_FAILURE(status)) {
 452                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 453                         "Error evaluating processor object\n"));
 454                 return_VALUE(-ENODEV);
 455         }
 456
 457         /*
 458          * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
 459          *      >>> 'acpi_get_processor_id(acpi_id, &id)' in arch/xxx/acpi.c
 460          */
 461         pr->acpi_id = object.processor.proc_id;
 462
 463         cpu_index = convert_acpiid_to_cpu(pr->acpi_id);
 464
 465         /* Handle UP system running SMP kernel, with no LAPIC in MADT */
 466         if ( !cpu0_initialized && (cpu_index == 0xff) &&
 467                         (num_online_cpus() == 1)) {
 468                 cpu_index = 0;
 469         }
 470
 471         cpu0_initialized = 1;
 472
 473         pr->id = cpu_index;
 474
 475         /*
 476          *  Extra Processor objects may be enumerated on MP systems with
 477          *  less than the max # of CPUs. They should be ignored _iff
 478          *  they are physically not present.
 479          */
 480         if (cpu_index >=  NR_CPUS) {
 481                 if (ACPI_FAILURE(acpi_processor_hotadd_init(pr->handle, &pr->id))) {
 482                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 483                                 "Error getting cpuindex for acpiid 0x%x\n",
 484                                 pr->acpi_id));
 485                         return_VALUE(-ENODEV);
 486                 }
 487         }
 488
 489         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
 490                 pr->acpi_id));
 491
 492         if (!object.processor.pblk_address)
 493                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
 494         else if (object.processor.pblk_length != 6)
 495                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid PBLK length [%d]\n",
 496                         object.processor.pblk_length));
 497         else {
 498                 pr->throttling.address = object.processor.pblk_address;
 499                 pr->throttling.duty_offset = acpi_fadt.duty_offset;
 500                 pr->throttling.duty_width = acpi_fadt.duty_width;
 501
 502                 pr->pblk = object.processor.pblk_address;
 503
 504                 /*
 505                  * We don't care about error returns - we just try to mark
 506                  * these reserved so that nobody else is confused into thinking
 507                  * that this region might be unused..
 508                  *
 509                  * (In particular, allocating the IO range for Cardbus)
 510                  */
 511                 request_region(pr->throttling.address, 6, "ACPI CPU throttle");
 512         }
 513
 514 #ifdef CONFIG_CPU_FREQ
 515         acpi_processor_ppc_has_changed(pr);
 516 #endif
 517         acpi_processor_get_throttling_info(pr);
 518         acpi_processor_get_limit_info(pr);
 519
 520         return_VALUE(0);
 521 }
 522
 523 static int
 524 acpi_processor_start(
 525         struct acpi_device      *device)
 526 {
 527         int                     result = 0;
 528         acpi_status             status = AE_OK;
 529         struct acpi_processor   *pr;
 530
 531         ACPI_FUNCTION_TRACE("acpi_processor_start");
 532
 533         pr = acpi_driver_data(device);
 534
 535         result = acpi_processor_get_info(pr);
 536         if (result) {
 537                 /* Processor is physically not present */
 538                 return_VALUE(0);
 539         }
 540
 541         BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0));
 542
 543         processors[pr->id] = pr;
 544
 545         result = acpi_processor_add_fs(device);
 546         if (result)
 547                 goto end;
 548
 549         status = acpi_install_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
 550                 acpi_processor_notify, pr);
 551         if (ACPI_FAILURE(status)) {
 552                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 553                         "Error installing device notify handler\n"));
 554         }
 555
 556         acpi_processor_power_init(pr, device);
 557
 558         if (pr->flags.throttling) {
 559                 printk(KERN_INFO PREFIX "%s [%s] (supports",
 560                         acpi_device_name(device), acpi_device_bid(device));
 561                 printk(" %d throttling states", pr->throttling.state_count);
 562                 printk(")\n");
 563         }
 564
 565 end:
 566
 567         return_VALUE(result);
 568 }
 569
 570
 571
 572 static void
 573 acpi_processor_notify (
 574         acpi_handle             handle,
 575         u32                     event,
 576         void                    *data)
 577 {
 578         struct acpi_processor   *pr = (struct acpi_processor *) data;
 579         struct acpi_device      *device = NULL;
 580
 581         ACPI_FUNCTION_TRACE("acpi_processor_notify");
 582
 583         if (!pr)
 584                 return_VOID;
 585
 586         if (acpi_bus_get_device(pr->handle, &device))
 587                 return_VOID;
 588
 589         switch (event) {
 590         case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
 591                 acpi_processor_ppc_has_changed(pr);
 592                 acpi_bus_generate_event(device, event,
 593                         pr->performance_platform_limit);
 594                 break;
 595         case ACPI_PROCESSOR_NOTIFY_POWER:
 596                 acpi_processor_cst_has_changed(pr);
 597                 acpi_bus_generate_event(device, event, 0);
 598                 break;
 599         default:
 600                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 601                         "Unsupported event [0x%x]\n", event));
 602                 break;
 603         }
 604
 605         return_VOID;
 606 }
 607
 608
 609 static int
 610 acpi_processor_add (
 611         struct acpi_device      *device)
 612 {
 613         struct acpi_processor   *pr = NULL;
 614
 615         ACPI_FUNCTION_TRACE("acpi_processor_add");
 616
 617         if (!device)
 618                 return_VALUE(-EINVAL);
 619
 620         pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL);
 621         if (!pr)
 622                 return_VALUE(-ENOMEM);
 623         memset(pr, 0, sizeof(struct acpi_processor));
 624
 625         pr->handle = device->handle;
 626         strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
 627         strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
 628         acpi_driver_data(device) = pr;
 629
 630         return_VALUE(0);
 631 }
 632
 633
 634 static int
 635 acpi_processor_remove (
 636         struct acpi_device      *device,
 637         int                     type)
 638 {
 639         acpi_status             status = AE_OK;
 640         struct acpi_processor   *pr = NULL;
 641
 642         ACPI_FUNCTION_TRACE("acpi_processor_remove");
 643
 644         if (!device || !acpi_driver_data(device))
 645                 return_VALUE(-EINVAL);
 646
 647         pr = (struct acpi_processor *) acpi_driver_data(device);
 648
 649         if (pr->id >= NR_CPUS) {
 650                 kfree(pr);
 651                 return_VALUE(0);
 652         }
 653
 654         if (type == ACPI_BUS_REMOVAL_EJECT) {
 655                 if (acpi_processor_handle_eject(pr))
 656                         return_VALUE(-EINVAL);
 657         }
 658
 659         acpi_processor_power_exit(pr, device);
 660
 661         status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
 662                 acpi_processor_notify);
 663         if (ACPI_FAILURE(status)) {
 664                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 665                         "Error removing notify handler\n"));
 666         }
 667
 668         acpi_processor_remove_fs(device);
 669
 670         processors[pr->id] = NULL;
 671
 672         kfree(pr);
 673
 674         return_VALUE(0);
 675 }
 676
 677 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 678 /****************************************************************************
 679  *      Acpi processor hotplug support                                      *
 680  ****************************************************************************/
 681
 682 static int is_processor_present(acpi_handle handle);
 683
 684 static int
 685 is_processor_present(
 686         acpi_handle handle)
 687 {
 688         acpi_status             status;
 689         unsigned long           sta = 0;
 690
 691         ACPI_FUNCTION_TRACE("is_processor_present");
 692
 693         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
 694         if (ACPI_FAILURE(status) || !(sta & ACPI_STA_PRESENT)) {
 695                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 696                         "Processor Device is not present\n"));
 697                 return_VALUE(0);
 698         }
 699         return_VALUE(1);
 700 }
 701
 702
 703 static
 704 int acpi_processor_device_add(
 705         acpi_handle     handle,
 706         struct acpi_device **device)
 707 {
 708         acpi_handle             phandle;
 709         struct acpi_device      *pdev;
 710         struct acpi_processor   *pr;
 711
 712         ACPI_FUNCTION_TRACE("acpi_processor_device_add");
 713
 714         if (acpi_get_parent(handle, &phandle)) {
 715                 return_VALUE(-ENODEV);
 716         }
 717
 718         if (acpi_bus_get_device(phandle, &pdev)) {
 719                 return_VALUE(-ENODEV);
 720         }
 721
 722         if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
 723                 return_VALUE(-ENODEV);
 724         }
 725
 726         acpi_bus_scan(*device);
 727
 728         pr = acpi_driver_data(*device);
 729         if (!pr)
 730                 return_VALUE(-ENODEV);
 731
 732         if ((pr->id >=0) && (pr->id < NR_CPUS)) {
 733                 kobject_hotplug(&(*device)->kobj, KOBJ_ONLINE);
 734         }
 735         return_VALUE(0);
 736 }
 737
 738
 739 static void
 740 acpi_processor_hotplug_notify (
 741         acpi_handle             handle,
 742         u32                     event,
 743         void                    *data)
 744 {
 745         struct acpi_processor   *pr;
 746         struct acpi_device      *device = NULL;
 747         int result;
 748
 749         ACPI_FUNCTION_TRACE("acpi_processor_hotplug_notify");
 750
 751         switch (event) {
 752         case ACPI_NOTIFY_BUS_CHECK:
 753         case ACPI_NOTIFY_DEVICE_CHECK:
 754                 printk("Processor driver received %s event\n",
 755                         (event==ACPI_NOTIFY_BUS_CHECK)?
 756                         "ACPI_NOTIFY_BUS_CHECK":"ACPI_NOTIFY_DEVICE_CHECK");
 757
 758                 if (!is_processor_present(handle))
 759                         break;
 760
 761                 if (acpi_bus_get_device(handle, &device)) {
 762                         result = acpi_processor_device_add(handle, &device);
 763                         if (result)
 764                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 765                                         "Unable to add the device\n"));
 766                         break;
 767                 }
 768
 769                 pr = acpi_driver_data(device);
 770                 if (!pr) {
 771                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 772                                 "Driver data is NULL\n"));
 773                         break;
 774                 }
 775
 776                 if (pr->id >= 0 && (pr->id < NR_CPUS)) {
 777                         kobject_hotplug(&device->kobj, KOBJ_OFFLINE);
 778                         break;
 779                 }
 780
 781                 result = acpi_processor_start(device);
 782                 if ((!result) && ((pr->id >=0) && (pr->id < NR_CPUS))) {
 783                         kobject_hotplug(&device->kobj, KOBJ_ONLINE);
 784                 } else {
 785                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 786                                 "Device [%s] failed to start\n",
 787                                 acpi_device_bid(device)));
 788                 }
 789         break;
 790         case ACPI_NOTIFY_EJECT_REQUEST:
 791                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"received ACPI_NOTIFY_EJECT_REQUEST\n"));
 792
 793                 if (acpi_bus_get_device(handle, &device)) {
 794                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"Device don't exist, dropping EJECT\n"));
 795                         break;
 796                 }
 797                 pr = acpi_driver_data(device);
 798                 if (!pr) {
 799                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"Driver data is NULL, dropping EJECT\n"));
 800                         return_VOID;
 801                 }
 802
 803                 if ((pr->id < NR_CPUS) && (cpu_present(pr->id)))
 804                         kobject_hotplug(&device->kobj, KOBJ_OFFLINE);
 805                 break;
 806         default:
 807                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 808                         "Unsupported event [0x%x]\n", event));
 809                 break;
 810         }
 811
 812         return_VOID;
 813 }
 814
 815 static acpi_status
 816 processor_walk_namespace_cb(acpi_handle handle,
 817         u32 lvl,
 818         void *context,
 819         void **rv)
 820 {
 821         acpi_status                     status;
 822         int *action = context;
 823         acpi_object_type        type = 0;
 824
 825         status = acpi_get_type(handle, &type);
 826         if (ACPI_FAILURE(status))
 827                 return(AE_OK);
 828
 829         if (type != ACPI_TYPE_PROCESSOR)
 830                 return(AE_OK);
 831
 832         switch(*action) {
 833         case INSTALL_NOTIFY_HANDLER:
 834                 acpi_install_notify_handler(handle,
 835                         ACPI_SYSTEM_NOTIFY,
 836                         acpi_processor_hotplug_notify,
 837                         NULL);
 838                 break;
 839         case UNINSTALL_NOTIFY_HANDLER:
 840                 acpi_remove_notify_handler(handle,
 841                         ACPI_SYSTEM_NOTIFY,
 842                         acpi_processor_hotplug_notify);
 843                 break;
 844         default:
 845                 break;
 846         }
 847
 848         return(AE_OK);
 849 }
 850
 851
 852 static acpi_status
 853 acpi_processor_hotadd_init(
 854         acpi_handle             handle,
 855         int                     *p_cpu)
 856 {
 857         ACPI_FUNCTION_TRACE("acpi_processor_hotadd_init");
 858
 859         if (!is_processor_present(handle)) {
 860                 return_VALUE(AE_ERROR);
 861         }
 862
 863         if (acpi_map_lsapic(handle, p_cpu))
 864                 return_VALUE(AE_ERROR);
 865
 866         if (arch_register_cpu(*p_cpu)) {
 867                 acpi_unmap_lsapic(*p_cpu);
 868                 return_VALUE(AE_ERROR);
 869         }
 870
 871         return_VALUE(AE_OK);
 872 }
 873
 874
 875 static int
 876 acpi_processor_handle_eject(struct acpi_processor *pr)
 877 {
 878         if (cpu_online(pr->id)) {
 879                 return(-EINVAL);
 880         }
 881         arch_unregister_cpu(pr->id);
 882         acpi_unmap_lsapic(pr->id);
 883         return(0);
 884 }
 885 #else
 886 static acpi_status
 887 acpi_processor_hotadd_init(
 888         acpi_handle             handle,
 889         int                     *p_cpu)
 890 {
 891         return AE_ERROR;
 892 }
 893 static int
 894 acpi_processor_handle_eject(struct acpi_processor *pr)
 895 {
 896         return(-EINVAL);
 897 }
 898 #endif
 899
 900
 901 static
 902 void acpi_processor_install_hotplug_notify(void)
 903 {
 904 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 905         int action = INSTALL_NOTIFY_HANDLER;
 906         acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
 907                                      ACPI_ROOT_OBJECT,
 908                                      ACPI_UINT32_MAX,
 909                                      processor_walk_namespace_cb,
 910                                      &action, NULL);
 911 #endif
 912 }
 913
 914
 915 static
 916 void acpi_processor_uninstall_hotplug_notify(void)
 917 {
 918 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 919         int action = UNINSTALL_NOTIFY_HANDLER;
 920         acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
 921                                      ACPI_ROOT_OBJECT,
 922                                      ACPI_UINT32_MAX,
 923                                      processor_walk_namespace_cb,
 924                                      &action, NULL);
 925 #endif
 926 }
 927
 928 /*
 929  * We keep the driver loaded even when ACPI is not running.
 930  * This is needed for the powernow-k8 driver, that works even without
 931  * ACPI, but needs symbols from this driver
 932  */
 933
 934 static int __init
 935 acpi_processor_init (void)
 936 {
 937         int                     result = 0;
 938
 939         ACPI_FUNCTION_TRACE("acpi_processor_init");
 940
 941         memset(&processors, 0, sizeof(processors));
 942         memset(&errata, 0, sizeof(errata));
 943
 944         acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
 945         if (!acpi_processor_dir)
 946                 return_VALUE(0);
 947         acpi_processor_dir->owner = THIS_MODULE;
 948
 949         result = acpi_bus_register_driver(&acpi_processor_driver);
 950         if (result < 0) {
 951                 remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
 952                 return_VALUE(0);
 953         }
 954
 955         acpi_processor_install_hotplug_notify();
 956
 957         acpi_thermal_cpufreq_init();
 958
 959         acpi_processor_ppc_init();
 960
 961         return_VALUE(0);
 962 }
 963
 964
 965 static void __exit
 966 acpi_processor_exit (void)
 967 {
 968         ACPI_FUNCTION_TRACE("acpi_processor_exit");
 969
 970         acpi_processor_ppc_exit();
 971
 972         acpi_thermal_cpufreq_exit();
 973
 974         acpi_processor_uninstall_hotplug_notify();
 975
 976         acpi_bus_unregister_driver(&acpi_processor_driver);
 977
 978         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
 979
 980         return_VOID;
 981 }
 982
 983
 984 module_init(acpi_processor_init);
 985 module_exit(acpi_processor_exit);
 986
 987 EXPORT_SYMBOL(acpi_processor_set_thermal_limit);
 988
 989 MODULE_ALIAS("processor");