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 Common ACPI processor fucntions 260 -------------------------------------------------------------------------- */ 261 262 /* 263 * _PDC is required for a BIOS-OS handshake for most of the newer 264 * ACPI processor features. 265 */ 266 267 int acpi_processor_set_pdc(struct acpi_processor *pr, 268 struct acpi_object_list *pdc_in) 269 { 270 acpi_status status = AE_OK; 271 u32 arg0_buf[3]; 272 union acpi_object arg0 = {ACPI_TYPE_BUFFER}; 273 struct acpi_object_list no_object = {1, &arg0}; 274 struct acpi_object_list *pdc; 275 276 ACPI_FUNCTION_TRACE("acpi_processor_set_pdc"); 277 278 arg0.buffer.length = 12; 279 arg0.buffer.pointer = (u8 *) arg0_buf; 280 arg0_buf[0] = ACPI_PDC_REVISION_ID; 281 arg0_buf[1] = 0; 282 arg0_buf[2] = 0; 283 284 pdc = (pdc_in) ? pdc_in : &no_object; 285 286 status = acpi_evaluate_object(pr->handle, "_PDC", pdc, NULL); 287 288 if ((ACPI_FAILURE(status)) && (pdc_in)) 289 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Error evaluating _PDC, using legacy perf. control...\n")); 290 291 return_VALUE(status); 292 } 293 294 295 /* -------------------------------------------------------------------------- 296 FS Interface (/proc) 297 -------------------------------------------------------------------------- */ 298 299 static struct proc_dir_entry *acpi_processor_dir = NULL; 300 301 static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset) 302 { 303 struct acpi_processor *pr = (struct acpi_processor *)seq->private; 304 305 ACPI_FUNCTION_TRACE("acpi_processor_info_seq_show"); 306 307 if (!pr) 308 goto end; 309 310 seq_printf(seq, "processor id: %d\n" 311 "acpi id: %d\n" 312 "bus mastering control: %s\n" 313 "power management: %s\n" 314 "throttling control: %s\n" 315 "limit interface: %s\n", 316 pr->id, 317 pr->acpi_id, 318 pr->flags.bm_control ? "yes" : "no", 319 pr->flags.power ? "yes" : "no", 320 pr->flags.throttling ? "yes" : "no", 321 pr->flags.limit ? "yes" : "no"); 322 323 end: 324 return_VALUE(0); 325 } 326 327 static int acpi_processor_info_open_fs(struct inode *inode, struct file *file) 328 { 329 return single_open(file, acpi_processor_info_seq_show, 330 PDE(inode)->data); 331 } 332 333 334 static int 335 acpi_processor_add_fs ( 336 struct acpi_device *device) 337 { 338 struct proc_dir_entry *entry = NULL; 339 340 ACPI_FUNCTION_TRACE("acpi_processor_add_fs"); 341 342 if (!acpi_device_dir(device)) { 343 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), 344 acpi_processor_dir); 345 if (!acpi_device_dir(device)) 346 return_VALUE(-ENODEV); 347 } 348 acpi_device_dir(device)->owner = THIS_MODULE; 349 350 /* 'info' [R] */ 351 entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO, 352 S_IRUGO, acpi_device_dir(device)); 353 if (!entry) 354 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 355 "Unable to create '%s' fs entry\n", 356 ACPI_PROCESSOR_FILE_INFO)); 357 else { 358 entry->proc_fops = &acpi_processor_info_fops; 359 entry->data = acpi_driver_data(device); 360 entry->owner = THIS_MODULE; 361 } 362 363 /* 'throttling' [R/W] */ 364 entry = create_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING, 365 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device)); 366 if (!entry) 367 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 368 "Unable to create '%s' fs entry\n", 369 ACPI_PROCESSOR_FILE_THROTTLING)); 370 else { 371 entry->proc_fops = &acpi_processor_throttling_fops; 372 entry->proc_fops->write = acpi_processor_write_throttling; 373 entry->data = acpi_driver_data(device); 374 entry->owner = THIS_MODULE; 375 } 376 377 /* 'limit' [R/W] */ 378 entry = create_proc_entry(ACPI_PROCESSOR_FILE_LIMIT, 379 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device)); 380 if (!entry) 381 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 382 "Unable to create '%s' fs entry\n", 383 ACPI_PROCESSOR_FILE_LIMIT)); 384 else { 385 entry->proc_fops = &acpi_processor_limit_fops; 386 entry->proc_fops->write = acpi_processor_write_limit; 387 entry->data = acpi_driver_data(device); 388 entry->owner = THIS_MODULE; 389 } 390 391 return_VALUE(0); 392 } 393 394 395 static int 396 acpi_processor_remove_fs ( 397 struct acpi_device *device) 398 { 399 ACPI_FUNCTION_TRACE("acpi_processor_remove_fs"); 400 401 if (acpi_device_dir(device)) { 402 remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,acpi_device_dir(device)); 403 remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING, 404 acpi_device_dir(device)); 405 remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,acpi_device_dir(device)); 406 remove_proc_entry(acpi_device_bid(device), acpi_processor_dir); 407 acpi_device_dir(device) = NULL; 408 } 409 410 return_VALUE(0); 411 } 412 413 /* Use the acpiid in MADT to map cpus in case of SMP */ 414 #ifndef CONFIG_SMP 415 #define convert_acpiid_to_cpu(acpi_id) (0xff) 416 #else 417 418 #ifdef CONFIG_IA64 419 #define arch_acpiid_to_apicid ia64_acpiid_to_sapicid 420 #define arch_cpu_to_apicid ia64_cpu_to_sapicid 421 #define ARCH_BAD_APICID (0xffff) 422 #else 423 #define arch_acpiid_to_apicid x86_acpiid_to_apicid 424 #define arch_cpu_to_apicid x86_cpu_to_apicid 425 #define ARCH_BAD_APICID (0xff) 426 #endif 427 428 static u8 convert_acpiid_to_cpu(u8 acpi_id) 429 { 430 u16 apic_id; 431 int i; 432 433 apic_id = arch_acpiid_to_apicid[acpi_id]; 434 if (apic_id == ARCH_BAD_APICID) 435 return -1; 436 437 for (i = 0; i < NR_CPUS; i++) { 438 if (arch_cpu_to_apicid[i] == apic_id) 439 return i; 440 } 441 return -1; 442 } 443 #endif 444 445 /* -------------------------------------------------------------------------- 446 Driver Interface 447 -------------------------------------------------------------------------- */ 448 449 static int 450 acpi_processor_get_info ( 451 struct acpi_processor *pr) 452 { 453 acpi_status status = 0; 454 union acpi_object object = {0}; 455 struct acpi_buffer buffer = {sizeof(union acpi_object), &object}; 456 u8 cpu_index; 457 static int cpu0_initialized; 458 459 ACPI_FUNCTION_TRACE("acpi_processor_get_info"); 460 461 if (!pr) 462 return_VALUE(-EINVAL); 463 464 if (num_online_cpus() > 1) 465 errata.smp = TRUE; 466 467 acpi_processor_errata(pr); 468 469 /* 470 * Check to see if we have bus mastering arbitration control. This 471 * is required for proper C3 usage (to maintain cache coherency). 472 */ 473 if (acpi_fadt.V1_pm2_cnt_blk && acpi_fadt.pm2_cnt_len) { 474 pr->flags.bm_control = 1; 475 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 476 "Bus mastering arbitration control present\n")); 477 } 478 else 479 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 480 "No bus mastering arbitration control\n")); 481 482 /* 483 * Evalute the processor object. Note that it is common on SMP to 484 * have the first (boot) processor with a valid PBLK address while 485 * all others have a NULL address. 486 */ 487 status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer); 488 if (ACPI_FAILURE(status)) { 489 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 490 "Error evaluating processor object\n")); 491 return_VALUE(-ENODEV); 492 } 493 494 /* 495 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP. 496 * >>> 'acpi_get_processor_id(acpi_id, &id)' in arch/xxx/acpi.c 497 */ 498 pr->acpi_id = object.processor.proc_id; 499 500 cpu_index = convert_acpiid_to_cpu(pr->acpi_id); 501 502 /* Handle UP system running SMP kernel, with no LAPIC in MADT */ 503 if ( !cpu0_initialized && (cpu_index == 0xff) && 504 (num_online_cpus() == 1)) { 505 cpu_index = 0; 506 } 507 508 cpu0_initialized = 1; 509 510 pr->id = cpu_index; 511 512 /* 513 * Extra Processor objects may be enumerated on MP systems with 514 * less than the max # of CPUs. They should be ignored _iff 515 * they are physically not present. 516 */ 517 if (cpu_index >= NR_CPUS) { 518 if (ACPI_FAILURE(acpi_processor_hotadd_init(pr->handle, &pr->id))) { 519 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 520 "Error getting cpuindex for acpiid 0x%x\n", 521 pr->acpi_id)); 522 return_VALUE(-ENODEV); 523 } 524 } 525 526 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id, 527 pr->acpi_id)); 528 529 if (!object.processor.pblk_address) 530 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n")); 531 else if (object.processor.pblk_length != 6) 532 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid PBLK length [%d]\n", 533 object.processor.pblk_length)); 534 else { 535 pr->throttling.address = object.processor.pblk_address; 536 pr->throttling.duty_offset = acpi_fadt.duty_offset; 537 pr->throttling.duty_width = acpi_fadt.duty_width; 538 539 pr->pblk = object.processor.pblk_address; 540 541 /* 542 * We don't care about error returns - we just try to mark 543 * these reserved so that nobody else is confused into thinking 544 * that this region might be unused.. 545 * 546 * (In particular, allocating the IO range for Cardbus) 547 */ 548 request_region(pr->throttling.address, 6, "ACPI CPU throttle"); 549 } 550 551 #ifdef CONFIG_CPU_FREQ 552 acpi_processor_ppc_has_changed(pr); 553 #endif 554 acpi_processor_get_throttling_info(pr); 555 acpi_processor_get_limit_info(pr); 556 557 return_VALUE(0); 558 } 559 560 static int 561 acpi_processor_start( 562 struct acpi_device *device) 563 { 564 int result = 0; 565 acpi_status status = AE_OK; 566 struct acpi_processor *pr; 567 568 ACPI_FUNCTION_TRACE("acpi_processor_start"); 569 570 pr = acpi_driver_data(device); 571 572 result = acpi_processor_get_info(pr); 573 if (result) { 574 /* Processor is physically not present */ 575 return_VALUE(0); 576 } 577 578 BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0)); 579 580 processors[pr->id] = pr; 581 582 result = acpi_processor_add_fs(device); 583 if (result) 584 goto end; 585 586 status = acpi_install_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY, 587 acpi_processor_notify, pr); 588 if (ACPI_FAILURE(status)) { 589 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 590 "Error installing device notify handler\n")); 591 } 592 593 acpi_processor_power_init(pr, device); 594 595 if (pr->flags.throttling) { 596 printk(KERN_INFO PREFIX "%s [%s] (supports", 597 acpi_device_name(device), acpi_device_bid(device)); 598 printk(" %d throttling states", pr->throttling.state_count); 599 printk(")\n"); 600 } 601 602 end: 603 604 return_VALUE(result); 605 } 606 607 608 609 static void 610 acpi_processor_notify ( 611 acpi_handle handle, 612 u32 event, 613 void *data) 614 { 615 struct acpi_processor *pr = (struct acpi_processor *) data; 616 struct acpi_device *device = NULL; 617 618 ACPI_FUNCTION_TRACE("acpi_processor_notify"); 619 620 if (!pr) 621 return_VOID; 622 623 if (acpi_bus_get_device(pr->handle, &device)) 624 return_VOID; 625 626 switch (event) { 627 case ACPI_PROCESSOR_NOTIFY_PERFORMANCE: 628 acpi_processor_ppc_has_changed(pr); 629 acpi_bus_generate_event(device, event, 630 pr->performance_platform_limit); 631 break; 632 case ACPI_PROCESSOR_NOTIFY_POWER: 633 acpi_processor_cst_has_changed(pr); 634 acpi_bus_generate_event(device, event, 0); 635 break; 636 default: 637 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 638 "Unsupported event [0x%x]\n", event)); 639 break; 640 } 641 642 return_VOID; 643 } 644 645 646 static int 647 acpi_processor_add ( 648 struct acpi_device *device) 649 { 650 struct acpi_processor *pr = NULL; 651 652 ACPI_FUNCTION_TRACE("acpi_processor_add"); 653 654 if (!device) 655 return_VALUE(-EINVAL); 656 657 pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL); 658 if (!pr) 659 return_VALUE(-ENOMEM); 660 memset(pr, 0, sizeof(struct acpi_processor)); 661 662 pr->handle = device->handle; 663 strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME); 664 strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS); 665 acpi_driver_data(device) = pr; 666 667 return_VALUE(0); 668 } 669 670 671 static int 672 acpi_processor_remove ( 673 struct acpi_device *device, 674 int type) 675 { 676 acpi_status status = AE_OK; 677 struct acpi_processor *pr = NULL; 678 679 ACPI_FUNCTION_TRACE("acpi_processor_remove"); 680 681 if (!device || !acpi_driver_data(device)) 682 return_VALUE(-EINVAL); 683 684 pr = (struct acpi_processor *) acpi_driver_data(device); 685 686 if (pr->id >= NR_CPUS) { 687 kfree(pr); 688 return_VALUE(0); 689 } 690 691 if (type == ACPI_BUS_REMOVAL_EJECT) { 692 if (acpi_processor_handle_eject(pr)) 693 return_VALUE(-EINVAL); 694 } 695 696 acpi_processor_power_exit(pr, device); 697 698 status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY, 699 acpi_processor_notify); 700 if (ACPI_FAILURE(status)) { 701 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 702 "Error removing notify handler\n")); 703 } 704 705 acpi_processor_remove_fs(device); 706 707 processors[pr->id] = NULL; 708 709 kfree(pr); 710 711 return_VALUE(0); 712 } 713 714 #ifdef CONFIG_ACPI_HOTPLUG_CPU 715 /**************************************************************************** 716 * Acpi processor hotplug support * 717 ****************************************************************************/ 718 719 static int is_processor_present(acpi_handle handle); 720 721 static int 722 is_processor_present( 723 acpi_handle handle) 724 { 725 acpi_status status; 726 unsigned long sta = 0; 727 728 ACPI_FUNCTION_TRACE("is_processor_present"); 729 730 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 731 if (ACPI_FAILURE(status) || !(sta & ACPI_STA_PRESENT)) { 732 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 733 "Processor Device is not present\n")); 734 return_VALUE(0); 735 } 736 return_VALUE(1); 737 } 738 739 740 static 741 int acpi_processor_device_add( 742 acpi_handle handle, 743 struct acpi_device **device) 744 { 745 acpi_handle phandle; 746 struct acpi_device *pdev; 747 struct acpi_processor *pr; 748 749 ACPI_FUNCTION_TRACE("acpi_processor_device_add"); 750 751 if (acpi_get_parent(handle, &phandle)) { 752 return_VALUE(-ENODEV); 753 } 754 755 if (acpi_bus_get_device(phandle, &pdev)) { 756 return_VALUE(-ENODEV); 757 } 758 759 if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) { 760 return_VALUE(-ENODEV); 761 } 762 763 acpi_bus_start(*device); 764 765 pr = acpi_driver_data(*device); 766 if (!pr) 767 return_VALUE(-ENODEV); 768 769 if ((pr->id >=0) && (pr->id < NR_CPUS)) { 770 kobject_hotplug(&(*device)->kobj, KOBJ_ONLINE); 771 } 772 return_VALUE(0); 773 } 774 775 776 static void 777 acpi_processor_hotplug_notify ( 778 acpi_handle handle, 779 u32 event, 780 void *data) 781 { 782 struct acpi_processor *pr; 783 struct acpi_device *device = NULL; 784 int result; 785 786 ACPI_FUNCTION_TRACE("acpi_processor_hotplug_notify"); 787 788 switch (event) { 789 case ACPI_NOTIFY_BUS_CHECK: 790 case ACPI_NOTIFY_DEVICE_CHECK: 791 printk("Processor driver received %s event\n", 792 (event==ACPI_NOTIFY_BUS_CHECK)? 793 "ACPI_NOTIFY_BUS_CHECK":"ACPI_NOTIFY_DEVICE_CHECK"); 794 795 if (!is_processor_present(handle)) 796 break; 797 798 if (acpi_bus_get_device(handle, &device)) { 799 result = acpi_processor_device_add(handle, &device); 800 if (result) 801 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 802 "Unable to add the device\n")); 803 break; 804 } 805 806 pr = acpi_driver_data(device); 807 if (!pr) { 808 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 809 "Driver data is NULL\n")); 810 break; 811 } 812 813 if (pr->id >= 0 && (pr->id < NR_CPUS)) { 814 kobject_hotplug(&device->kobj, KOBJ_OFFLINE); 815 break; 816 } 817 818 result = acpi_processor_start(device); 819 if ((!result) && ((pr->id >=0) && (pr->id < NR_CPUS))) { 820 kobject_hotplug(&device->kobj, KOBJ_ONLINE); 821 } else { 822 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 823 "Device [%s] failed to start\n", 824 acpi_device_bid(device))); 825 } 826 break; 827 case ACPI_NOTIFY_EJECT_REQUEST: 828 ACPI_DEBUG_PRINT((ACPI_DB_INFO,"received ACPI_NOTIFY_EJECT_REQUEST\n")); 829 830 if (acpi_bus_get_device(handle, &device)) { 831 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"Device don't exist, dropping EJECT\n")); 832 break; 833 } 834 pr = acpi_driver_data(device); 835 if (!pr) { 836 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,"Driver data is NULL, dropping EJECT\n")); 837 return_VOID; 838 } 839 840 if ((pr->id < NR_CPUS) && (cpu_present(pr->id))) 841 kobject_hotplug(&device->kobj, KOBJ_OFFLINE); 842 break; 843 default: 844 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 845 "Unsupported event [0x%x]\n", event)); 846 break; 847 } 848 849 return_VOID; 850 } 851 852 static acpi_status 853 processor_walk_namespace_cb(acpi_handle handle, 854 u32 lvl, 855 void *context, 856 void **rv) 857 { 858 acpi_status status; 859 int *action = context; 860 acpi_object_type type = 0; 861 862 status = acpi_get_type(handle, &type); 863 if (ACPI_FAILURE(status)) 864 return(AE_OK); 865 866 if (type != ACPI_TYPE_PROCESSOR) 867 return(AE_OK); 868 869 switch(*action) { 870 case INSTALL_NOTIFY_HANDLER: 871 acpi_install_notify_handler(handle, 872 ACPI_SYSTEM_NOTIFY, 873 acpi_processor_hotplug_notify, 874 NULL); 875 break; 876 case UNINSTALL_NOTIFY_HANDLER: 877 acpi_remove_notify_handler(handle, 878 ACPI_SYSTEM_NOTIFY, 879 acpi_processor_hotplug_notify); 880 break; 881 default: 882 break; 883 } 884 885 return(AE_OK); 886 } 887 888 889 static acpi_status 890 acpi_processor_hotadd_init( 891 acpi_handle handle, 892 int *p_cpu) 893 { 894 ACPI_FUNCTION_TRACE("acpi_processor_hotadd_init"); 895 896 if (!is_processor_present(handle)) { 897 return_VALUE(AE_ERROR); 898 } 899 900 if (acpi_map_lsapic(handle, p_cpu)) 901 return_VALUE(AE_ERROR); 902 903 if (arch_register_cpu(*p_cpu)) { 904 acpi_unmap_lsapic(*p_cpu); 905 return_VALUE(AE_ERROR); 906 } 907 908 return_VALUE(AE_OK); 909 } 910 911 912 static int 913 acpi_processor_handle_eject(struct acpi_processor *pr) 914 { 915 if (cpu_online(pr->id)) { 916 return(-EINVAL); 917 } 918 arch_unregister_cpu(pr->id); 919 acpi_unmap_lsapic(pr->id); 920 return(0); 921 } 922 #else 923 static acpi_status 924 acpi_processor_hotadd_init( 925 acpi_handle handle, 926 int *p_cpu) 927 { 928 return AE_ERROR; 929 } 930 static int 931 acpi_processor_handle_eject(struct acpi_processor *pr) 932 { 933 return(-EINVAL); 934 } 935 #endif 936 937 938 static 939 void acpi_processor_install_hotplug_notify(void) 940 { 941 #ifdef CONFIG_ACPI_HOTPLUG_CPU 942 int action = INSTALL_NOTIFY_HANDLER; 943 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, 944 ACPI_ROOT_OBJECT, 945 ACPI_UINT32_MAX, 946 processor_walk_namespace_cb, 947 &action, NULL); 948 #endif 949 } 950 951 952 static 953 void acpi_processor_uninstall_hotplug_notify(void) 954 { 955 #ifdef CONFIG_ACPI_HOTPLUG_CPU 956 int action = UNINSTALL_NOTIFY_HANDLER; 957 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, 958 ACPI_ROOT_OBJECT, 959 ACPI_UINT32_MAX, 960 processor_walk_namespace_cb, 961 &action, NULL); 962 #endif 963 } 964 965 /* 966 * We keep the driver loaded even when ACPI is not running. 967 * This is needed for the powernow-k8 driver, that works even without 968 * ACPI, but needs symbols from this driver 969 */ 970 971 static int __init 972 acpi_processor_init (void) 973 { 974 int result = 0; 975 976 ACPI_FUNCTION_TRACE("acpi_processor_init"); 977 978 memset(&processors, 0, sizeof(processors)); 979 memset(&errata, 0, sizeof(errata)); 980 981 acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir); 982 if (!acpi_processor_dir) 983 return_VALUE(0); 984 acpi_processor_dir->owner = THIS_MODULE; 985 986 result = acpi_bus_register_driver(&acpi_processor_driver); 987 if (result < 0) { 988 remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir); 989 return_VALUE(0); 990 } 991 992 acpi_processor_install_hotplug_notify(); 993 994 acpi_thermal_cpufreq_init(); 995 996 acpi_processor_ppc_init(); 997 998 return_VALUE(0); 999 } 1000 1001 1002 static void __exit 1003 acpi_processor_exit (void) 1004 { 1005 ACPI_FUNCTION_TRACE("acpi_processor_exit"); 1006 1007 acpi_processor_ppc_exit(); 1008 1009 acpi_thermal_cpufreq_exit(); 1010 1011 acpi_processor_uninstall_hotplug_notify(); 1012 1013 acpi_bus_unregister_driver(&acpi_processor_driver); 1014 1015 remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir); 1016 1017 return_VOID; 1018 } 1019 1020 1021 module_init(acpi_processor_init); 1022 module_exit(acpi_processor_exit); 1023 1024 EXPORT_SYMBOL(acpi_processor_set_thermal_limit); 1025 1026 MODULE_ALIAS("processor"); 1027