1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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#include <linux/cpuidle.h>
48
49#include <asm/io.h>
50#include <asm/system.h>
51#include <asm/cpu.h>
52#include <asm/delay.h>
53#include <asm/uaccess.h>
54#include <asm/processor.h>
55#include <asm/smp.h>
56#include <asm/acpi.h>
57
58#include <acpi/acpi_bus.h>
59#include <acpi/acpi_drivers.h>
60#include <acpi/processor.h>
61
62#define PREFIX "ACPI: "
63
64#define ACPI_PROCESSOR_CLASS "processor"
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#define ACPI_PROCESSOR_NOTIFY_THROTTLING 0x82
72
73#define ACPI_PROCESSOR_LIMIT_USER 0
74#define ACPI_PROCESSOR_LIMIT_THERMAL 1
75
76#define _COMPONENT ACPI_PROCESSOR_COMPONENT
77ACPI_MODULE_NAME("processor_core");
78
79MODULE_AUTHOR("Paul Diefenbaugh");
80MODULE_DESCRIPTION("ACPI Processor Driver");
81MODULE_LICENSE("GPL");
82
83static int acpi_processor_add(struct acpi_device *device);
84static int acpi_processor_remove(struct acpi_device *device, int type);
85#ifdef CONFIG_ACPI_PROCFS
86static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
87#endif
88static void acpi_processor_notify(struct acpi_device *device, u32 event);
89static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
90static int acpi_processor_handle_eject(struct acpi_processor *pr);
91
92
93static const struct acpi_device_id processor_device_ids[] = {
94 {ACPI_PROCESSOR_OBJECT_HID, 0},
95 {"ACPI0007", 0},
96 {"", 0},
97};
98MODULE_DEVICE_TABLE(acpi, processor_device_ids);
99
100static struct acpi_driver acpi_processor_driver = {
101 .name = "processor",
102 .class = ACPI_PROCESSOR_CLASS,
103 .ids = processor_device_ids,
104 .ops = {
105 .add = acpi_processor_add,
106 .remove = acpi_processor_remove,
107 .suspend = acpi_processor_suspend,
108 .resume = acpi_processor_resume,
109 .notify = acpi_processor_notify,
110 },
111};
112
113#define INSTALL_NOTIFY_HANDLER 1
114#define UNINSTALL_NOTIFY_HANDLER 2
115#ifdef CONFIG_ACPI_PROCFS
116static const struct file_operations acpi_processor_info_fops = {
117 .owner = THIS_MODULE,
118 .open = acpi_processor_info_open_fs,
119 .read = seq_read,
120 .llseek = seq_lseek,
121 .release = single_release,
122};
123#endif
124
125DEFINE_PER_CPU(struct acpi_processor *, processors);
126struct acpi_processor_errata errata __read_mostly;
127static int set_no_mwait(const struct dmi_system_id *id)
128{
129 printk(KERN_NOTICE PREFIX "%s detected - "
130 "disabling mwait for CPU C-states\n", id->ident);
131 idle_nomwait = 1;
132 return 0;
133}
134
135static struct dmi_system_id __cpuinitdata processor_idle_dmi_table[] = {
136 {
137 set_no_mwait, "IFL91 board", {
138 DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
139 DMI_MATCH(DMI_SYS_VENDOR, "ZEPTO"),
140 DMI_MATCH(DMI_PRODUCT_VERSION, "3215W"),
141 DMI_MATCH(DMI_BOARD_NAME, "IFL91") }, NULL},
142 {
143 set_no_mwait, "Extensa 5220", {
144 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
145 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
146 DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
147 DMI_MATCH(DMI_BOARD_NAME, "Columbia") }, NULL},
148 {},
149};
150
151
152
153
154
155static int acpi_processor_errata_piix4(struct pci_dev *dev)
156{
157 u8 value1 = 0;
158 u8 value2 = 0;
159
160
161 if (!dev)
162 return -EINVAL;
163
164
165
166
167
168 switch (dev->revision) {
169 case 0:
170 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
171 break;
172 case 1:
173 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
174 break;
175 case 2:
176 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
177 break;
178 case 3:
179 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
180 break;
181 default:
182 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
183 break;
184 }
185
186 switch (dev->revision) {
187
188 case 0:
189 case 1:
190
191
192
193
194
195
196
197 errata.piix4.throttle = 1;
198
199 case 2:
200 case 3:
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
216 PCI_DEVICE_ID_INTEL_82371AB,
217 PCI_ANY_ID, PCI_ANY_ID, NULL);
218 if (dev) {
219 errata.piix4.bmisx = pci_resource_start(dev, 4);
220 pci_dev_put(dev);
221 }
222
223
224
225
226
227
228
229
230
231
232 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
233 PCI_DEVICE_ID_INTEL_82371AB_0,
234 PCI_ANY_ID, PCI_ANY_ID, NULL);
235 if (dev) {
236 pci_read_config_byte(dev, 0x76, &value1);
237 pci_read_config_byte(dev, 0x77, &value2);
238 if ((value1 & 0x80) || (value2 & 0x80))
239 errata.piix4.fdma = 1;
240 pci_dev_put(dev);
241 }
242
243 break;
244 }
245
246 if (errata.piix4.bmisx)
247 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
248 "Bus master activity detection (BM-IDE) erratum enabled\n"));
249 if (errata.piix4.fdma)
250 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
251 "Type-F DMA livelock erratum (C3 disabled)\n"));
252
253 return 0;
254}
255
256static int acpi_processor_errata(struct acpi_processor *pr)
257{
258 int result = 0;
259 struct pci_dev *dev = NULL;
260
261
262 if (!pr)
263 return -EINVAL;
264
265
266
267
268 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
269 PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
270 PCI_ANY_ID, NULL);
271 if (dev) {
272 result = acpi_processor_errata_piix4(dev);
273 pci_dev_put(dev);
274 }
275
276 return result;
277}
278
279
280
281
282
283
284
285
286
287static int acpi_processor_set_pdc(struct acpi_processor *pr)
288{
289 struct acpi_object_list *pdc_in = pr->pdc;
290 acpi_status status = AE_OK;
291
292
293 if (!pdc_in)
294 return status;
295 if (idle_nomwait) {
296
297
298
299
300
301 union acpi_object *obj;
302 u32 *buffer = NULL;
303
304 obj = pdc_in->pointer;
305 buffer = (u32 *)(obj->buffer.pointer);
306 buffer[2] &= ~(ACPI_PDC_C_C2C3_FFH | ACPI_PDC_C_C1_FFH);
307
308 }
309 status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL);
310
311 if (ACPI_FAILURE(status))
312 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
313 "Could not evaluate _PDC, using legacy perf. control...\n"));
314
315 return status;
316}
317
318
319
320
321
322#ifdef CONFIG_ACPI_PROCFS
323static struct proc_dir_entry *acpi_processor_dir = NULL;
324
325static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
326{
327 struct acpi_processor *pr = seq->private;
328
329
330 if (!pr)
331 goto end;
332
333 seq_printf(seq, "processor id: %d\n"
334 "acpi id: %d\n"
335 "bus mastering control: %s\n"
336 "power management: %s\n"
337 "throttling control: %s\n"
338 "limit interface: %s\n",
339 pr->id,
340 pr->acpi_id,
341 pr->flags.bm_control ? "yes" : "no",
342 pr->flags.power ? "yes" : "no",
343 pr->flags.throttling ? "yes" : "no",
344 pr->flags.limit ? "yes" : "no");
345
346 end:
347 return 0;
348}
349
350static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
351{
352 return single_open(file, acpi_processor_info_seq_show,
353 PDE(inode)->data);
354}
355
356static int acpi_processor_add_fs(struct acpi_device *device)
357{
358 struct proc_dir_entry *entry = NULL;
359
360
361 if (!acpi_device_dir(device)) {
362 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
363 acpi_processor_dir);
364 if (!acpi_device_dir(device))
365 return -ENODEV;
366 }
367
368
369 entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,
370 S_IRUGO, acpi_device_dir(device),
371 &acpi_processor_info_fops,
372 acpi_driver_data(device));
373 if (!entry)
374 return -EIO;
375
376
377 entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,
378 S_IFREG | S_IRUGO | S_IWUSR,
379 acpi_device_dir(device),
380 &acpi_processor_throttling_fops,
381 acpi_driver_data(device));
382 if (!entry)
383 return -EIO;
384
385
386 entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,
387 S_IFREG | S_IRUGO | S_IWUSR,
388 acpi_device_dir(device),
389 &acpi_processor_limit_fops,
390 acpi_driver_data(device));
391 if (!entry)
392 return -EIO;
393 return 0;
394}
395static int acpi_processor_remove_fs(struct acpi_device *device)
396{
397
398 if (acpi_device_dir(device)) {
399 remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
400 acpi_device_dir(device));
401 remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
402 acpi_device_dir(device));
403 remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
404 acpi_device_dir(device));
405 remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
406 acpi_device_dir(device) = NULL;
407 }
408
409 return 0;
410}
411#else
412static inline int acpi_processor_add_fs(struct acpi_device *device)
413{
414 return 0;
415}
416static inline int acpi_processor_remove_fs(struct acpi_device *device)
417{
418 return 0;
419}
420#endif
421
422
423
424#ifndef CONFIG_SMP
425static int get_cpu_id(acpi_handle handle, int type, u32 acpi_id) { return -1; }
426#else
427
428static struct acpi_table_madt *madt;
429
430static int map_lapic_id(struct acpi_subtable_header *entry,
431 u32 acpi_id, int *apic_id)
432{
433 struct acpi_madt_local_apic *lapic =
434 (struct acpi_madt_local_apic *)entry;
435 if ((lapic->lapic_flags & ACPI_MADT_ENABLED) &&
436 lapic->processor_id == acpi_id) {
437 *apic_id = lapic->id;
438 return 1;
439 }
440 return 0;
441}
442
443static int map_x2apic_id(struct acpi_subtable_header *entry,
444 int device_declaration, u32 acpi_id, int *apic_id)
445{
446 struct acpi_madt_local_x2apic *apic =
447 (struct acpi_madt_local_x2apic *)entry;
448 u32 tmp = apic->local_apic_id;
449
450
451 if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
452 return 0;
453
454
455 if (device_declaration) {
456 if (apic->uid == acpi_id)
457 goto found;
458 }
459
460 return 0;
461found:
462 *apic_id = tmp;
463 return 1;
464}
465
466static int map_lsapic_id(struct acpi_subtable_header *entry,
467 int device_declaration, u32 acpi_id, int *apic_id)
468{
469 struct acpi_madt_local_sapic *lsapic =
470 (struct acpi_madt_local_sapic *)entry;
471 u32 tmp = (lsapic->id << 8) | lsapic->eid;
472
473
474 if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))
475 return 0;
476
477
478 if (device_declaration) {
479 if (entry->length < 16)
480 printk(KERN_ERR PREFIX
481 "Invalid LSAPIC with Device type processor (SAPIC ID %#x)\n",
482 tmp);
483 else if (lsapic->uid == acpi_id)
484 goto found;
485
486 } else if (lsapic->processor_id == acpi_id)
487 goto found;
488
489 return 0;
490found:
491 *apic_id = tmp;
492 return 1;
493}
494
495static int map_madt_entry(int type, u32 acpi_id)
496{
497 unsigned long madt_end, entry;
498 int apic_id = -1;
499
500 if (!madt)
501 return apic_id;
502
503 entry = (unsigned long)madt;
504 madt_end = entry + madt->header.length;
505
506
507
508 entry += sizeof(struct acpi_table_madt);
509 while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
510 struct acpi_subtable_header *header =
511 (struct acpi_subtable_header *)entry;
512 if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
513 if (map_lapic_id(header, acpi_id, &apic_id))
514 break;
515 } else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
516 if (map_x2apic_id(header, type, acpi_id, &apic_id))
517 break;
518 } else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
519 if (map_lsapic_id(header, type, acpi_id, &apic_id))
520 break;
521 }
522 entry += header->length;
523 }
524 return apic_id;
525}
526
527static int map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
528{
529 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
530 union acpi_object *obj;
531 struct acpi_subtable_header *header;
532 int apic_id = -1;
533
534 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
535 goto exit;
536
537 if (!buffer.length || !buffer.pointer)
538 goto exit;
539
540 obj = buffer.pointer;
541 if (obj->type != ACPI_TYPE_BUFFER ||
542 obj->buffer.length < sizeof(struct acpi_subtable_header)) {
543 goto exit;
544 }
545
546 header = (struct acpi_subtable_header *)obj->buffer.pointer;
547 if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
548 map_lapic_id(header, acpi_id, &apic_id);
549 } else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
550 map_lsapic_id(header, type, acpi_id, &apic_id);
551 }
552
553exit:
554 if (buffer.pointer)
555 kfree(buffer.pointer);
556 return apic_id;
557}
558
559static int get_cpu_id(acpi_handle handle, int type, u32 acpi_id)
560{
561 int i;
562 int apic_id = -1;
563
564 apic_id = map_mat_entry(handle, type, acpi_id);
565 if (apic_id == -1)
566 apic_id = map_madt_entry(type, acpi_id);
567 if (apic_id == -1)
568 return apic_id;
569
570 for_each_possible_cpu(i) {
571 if (cpu_physical_id(i) == apic_id)
572 return i;
573 }
574 return -1;
575}
576#endif
577
578
579
580
581
582static int acpi_processor_get_info(struct acpi_device *device)
583{
584 acpi_status status = 0;
585 union acpi_object object = { 0 };
586 struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
587 struct acpi_processor *pr;
588 int cpu_index, device_declaration = 0;
589 static int cpu0_initialized;
590
591 pr = acpi_driver_data(device);
592 if (!pr)
593 return -EINVAL;
594
595 if (num_online_cpus() > 1)
596 errata.smp = TRUE;
597
598 acpi_processor_errata(pr);
599
600
601
602
603
604 if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
605 pr->flags.bm_control = 1;
606 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
607 "Bus mastering arbitration control present\n"));
608 } else
609 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
610 "No bus mastering arbitration control\n"));
611
612 if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
613
614 status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
615 if (ACPI_FAILURE(status)) {
616 printk(KERN_ERR PREFIX "Evaluating processor object\n");
617 return -ENODEV;
618 }
619
620
621
622
623
624
625 pr->acpi_id = object.processor.proc_id;
626 } else {
627
628
629
630
631 unsigned long long value;
632 status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
633 NULL, &value);
634 if (ACPI_FAILURE(status)) {
635 printk(KERN_ERR PREFIX
636 "Evaluating processor _UID [%#x]\n", status);
637 return -ENODEV;
638 }
639 device_declaration = 1;
640 pr->acpi_id = value;
641 }
642 cpu_index = get_cpu_id(pr->handle, device_declaration, pr->acpi_id);
643
644
645 if (!cpu0_initialized && (cpu_index == -1) &&
646 (num_online_cpus() == 1)) {
647 cpu_index = 0;
648 }
649
650 cpu0_initialized = 1;
651
652 pr->id = cpu_index;
653
654
655
656
657
658
659 if (pr->id == -1) {
660 if (ACPI_FAILURE
661 (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
662 return -ENODEV;
663 }
664 }
665
666
667
668
669
670
671
672
673
674 sprintf(acpi_device_bid(device), "CPU%X", pr->id);
675 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
676 pr->acpi_id));
677
678 if (!object.processor.pblk_address)
679 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
680 else if (object.processor.pblk_length != 6)
681 printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
682 object.processor.pblk_length);
683 else {
684 pr->throttling.address = object.processor.pblk_address;
685 pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
686 pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
687
688 pr->pblk = object.processor.pblk_address;
689
690
691
692
693
694
695
696
697 request_region(pr->throttling.address, 6, "ACPI CPU throttle");
698 }
699
700
701
702
703
704
705 status = acpi_evaluate_object(pr->handle, "_SUN", NULL, &buffer);
706 if (ACPI_SUCCESS(status))
707 arch_fix_phys_package_id(pr->id, object.integer.value);
708
709 return 0;
710}
711
712static DEFINE_PER_CPU(void *, processor_device_array);
713
714static void acpi_processor_notify(struct acpi_device *device, u32 event)
715{
716 struct acpi_processor *pr = acpi_driver_data(device);
717 int saved;
718
719 if (!pr)
720 return;
721
722 switch (event) {
723 case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
724 saved = pr->performance_platform_limit;
725 acpi_processor_ppc_has_changed(pr);
726 if (saved == pr->performance_platform_limit)
727 break;
728 acpi_bus_generate_proc_event(device, event,
729 pr->performance_platform_limit);
730 acpi_bus_generate_netlink_event(device->pnp.device_class,
731 dev_name(&device->dev), event,
732 pr->performance_platform_limit);
733 break;
734 case ACPI_PROCESSOR_NOTIFY_POWER:
735 acpi_processor_cst_has_changed(pr);
736 acpi_bus_generate_proc_event(device, event, 0);
737 acpi_bus_generate_netlink_event(device->pnp.device_class,
738 dev_name(&device->dev), event, 0);
739 break;
740 case ACPI_PROCESSOR_NOTIFY_THROTTLING:
741 acpi_processor_tstate_has_changed(pr);
742 acpi_bus_generate_proc_event(device, event, 0);
743 acpi_bus_generate_netlink_event(device->pnp.device_class,
744 dev_name(&device->dev), event, 0);
745 default:
746 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
747 "Unsupported event [0x%x]\n", event));
748 break;
749 }
750
751 return;
752}
753
754static int acpi_cpu_soft_notify(struct notifier_block *nfb,
755 unsigned long action, void *hcpu)
756{
757 unsigned int cpu = (unsigned long)hcpu;
758 struct acpi_processor *pr = per_cpu(processors, cpu);
759
760 if (action == CPU_ONLINE && pr) {
761 acpi_processor_ppc_has_changed(pr);
762 acpi_processor_cst_has_changed(pr);
763 acpi_processor_tstate_has_changed(pr);
764 }
765 return NOTIFY_OK;
766}
767
768static struct notifier_block acpi_cpu_notifier =
769{
770 .notifier_call = acpi_cpu_soft_notify,
771};
772
773static int __cpuinit acpi_processor_add(struct acpi_device *device)
774{
775 struct acpi_processor *pr = NULL;
776 int result = 0;
777 struct sys_device *sysdev;
778
779 pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
780 if (!pr)
781 return -ENOMEM;
782
783 if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
784 kfree(pr);
785 return -ENOMEM;
786 }
787
788 pr->handle = device->handle;
789 strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
790 strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
791 device->driver_data = pr;
792
793 result = acpi_processor_get_info(device);
794 if (result) {
795
796 return 0;
797 }
798
799 BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
800
801
802
803
804
805
806 if (per_cpu(processor_device_array, pr->id) != NULL &&
807 per_cpu(processor_device_array, pr->id) != device) {
808 printk(KERN_WARNING "BIOS reported wrong ACPI id "
809 "for the processor\n");
810 result = -ENODEV;
811 goto err_free_cpumask;
812 }
813 per_cpu(processor_device_array, pr->id) = device;
814
815 per_cpu(processors, pr->id) = pr;
816
817 result = acpi_processor_add_fs(device);
818 if (result)
819 goto err_free_cpumask;
820
821 sysdev = get_cpu_sysdev(pr->id);
822 if (sysfs_create_link(&device->dev.kobj, &sysdev->kobj, "sysdev")) {
823 result = -EFAULT;
824 goto err_remove_fs;
825 }
826
827
828 arch_acpi_processor_init_pdc(pr);
829 acpi_processor_set_pdc(pr);
830 arch_acpi_processor_cleanup_pdc(pr);
831
832#ifdef CONFIG_CPU_FREQ
833 acpi_processor_ppc_has_changed(pr);
834#endif
835 acpi_processor_get_throttling_info(pr);
836 acpi_processor_get_limit_info(pr);
837
838
839 acpi_processor_power_init(pr, device);
840
841 pr->cdev = thermal_cooling_device_register("Processor", device,
842 &processor_cooling_ops);
843 if (IS_ERR(pr->cdev)) {
844 result = PTR_ERR(pr->cdev);
845 goto err_power_exit;
846 }
847
848 dev_info(&device->dev, "registered as cooling_device%d\n",
849 pr->cdev->id);
850
851 result = sysfs_create_link(&device->dev.kobj,
852 &pr->cdev->device.kobj,
853 "thermal_cooling");
854 if (result) {
855 printk(KERN_ERR PREFIX "Create sysfs link\n");
856 goto err_thermal_unregister;
857 }
858 result = sysfs_create_link(&pr->cdev->device.kobj,
859 &device->dev.kobj,
860 "device");
861 if (result) {
862 printk(KERN_ERR PREFIX "Create sysfs link\n");
863 goto err_remove_sysfs;
864 }
865
866 return 0;
867
868err_remove_sysfs:
869 sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
870err_thermal_unregister:
871 thermal_cooling_device_unregister(pr->cdev);
872err_power_exit:
873 acpi_processor_power_exit(pr, device);
874err_remove_fs:
875 acpi_processor_remove_fs(device);
876err_free_cpumask:
877 free_cpumask_var(pr->throttling.shared_cpu_map);
878
879 return result;
880}
881
882static int acpi_processor_remove(struct acpi_device *device, int type)
883{
884 struct acpi_processor *pr = NULL;
885
886
887 if (!device || !acpi_driver_data(device))
888 return -EINVAL;
889
890 pr = acpi_driver_data(device);
891
892 if (pr->id >= nr_cpu_ids)
893 goto free;
894
895 if (type == ACPI_BUS_REMOVAL_EJECT) {
896 if (acpi_processor_handle_eject(pr))
897 return -EINVAL;
898 }
899
900 acpi_processor_power_exit(pr, device);
901
902 sysfs_remove_link(&device->dev.kobj, "sysdev");
903
904 acpi_processor_remove_fs(device);
905
906 if (pr->cdev) {
907 sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
908 sysfs_remove_link(&pr->cdev->device.kobj, "device");
909 thermal_cooling_device_unregister(pr->cdev);
910 pr->cdev = NULL;
911 }
912
913 per_cpu(processors, pr->id) = NULL;
914 per_cpu(processor_device_array, pr->id) = NULL;
915
916free:
917 free_cpumask_var(pr->throttling.shared_cpu_map);
918 kfree(pr);
919
920 return 0;
921}
922
923#ifdef CONFIG_ACPI_HOTPLUG_CPU
924
925
926
927
928static int is_processor_present(acpi_handle handle)
929{
930 acpi_status status;
931 unsigned long long sta = 0;
932
933
934 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
935
936 if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_PRESENT))
937 return 1;
938
939
940
941
942 if (status == AE_NOT_FOUND)
943 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
944 "Processor does not support hot plug\n"));
945 else
946 ACPI_EXCEPTION((AE_INFO, status,
947 "Processor Device is not present"));
948 return 0;
949}
950
951static
952int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
953{
954 acpi_handle phandle;
955 struct acpi_device *pdev;
956
957
958 if (acpi_get_parent(handle, &phandle)) {
959 return -ENODEV;
960 }
961
962 if (acpi_bus_get_device(phandle, &pdev)) {
963 return -ENODEV;
964 }
965
966 if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
967 return -ENODEV;
968 }
969
970 return 0;
971}
972
973static void __ref acpi_processor_hotplug_notify(acpi_handle handle,
974 u32 event, void *data)
975{
976 struct acpi_processor *pr;
977 struct acpi_device *device = NULL;
978 int result;
979
980
981 switch (event) {
982 case ACPI_NOTIFY_BUS_CHECK:
983 case ACPI_NOTIFY_DEVICE_CHECK:
984 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
985 "Processor driver received %s event\n",
986 (event == ACPI_NOTIFY_BUS_CHECK) ?
987 "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
988
989 if (!is_processor_present(handle))
990 break;
991
992 if (acpi_bus_get_device(handle, &device)) {
993 result = acpi_processor_device_add(handle, &device);
994 if (result)
995 printk(KERN_ERR PREFIX
996 "Unable to add the device\n");
997 break;
998 }
999 break;
1000 case ACPI_NOTIFY_EJECT_REQUEST:
1001 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1002 "received ACPI_NOTIFY_EJECT_REQUEST\n"));
1003
1004 if (acpi_bus_get_device(handle, &device)) {
1005 printk(KERN_ERR PREFIX
1006 "Device don't exist, dropping EJECT\n");
1007 break;
1008 }
1009 pr = acpi_driver_data(device);
1010 if (!pr) {
1011 printk(KERN_ERR PREFIX
1012 "Driver data is NULL, dropping EJECT\n");
1013 return;
1014 }
1015 break;
1016 default:
1017 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1018 "Unsupported event [0x%x]\n", event));
1019 break;
1020 }
1021
1022 return;
1023}
1024
1025static acpi_status
1026processor_walk_namespace_cb(acpi_handle handle,
1027 u32 lvl, void *context, void **rv)
1028{
1029 acpi_status status;
1030 int *action = context;
1031 acpi_object_type type = 0;
1032
1033 status = acpi_get_type(handle, &type);
1034 if (ACPI_FAILURE(status))
1035 return (AE_OK);
1036
1037 if (type != ACPI_TYPE_PROCESSOR)
1038 return (AE_OK);
1039
1040 switch (*action) {
1041 case INSTALL_NOTIFY_HANDLER:
1042 acpi_install_notify_handler(handle,
1043 ACPI_SYSTEM_NOTIFY,
1044 acpi_processor_hotplug_notify,
1045 NULL);
1046 break;
1047 case UNINSTALL_NOTIFY_HANDLER:
1048 acpi_remove_notify_handler(handle,
1049 ACPI_SYSTEM_NOTIFY,
1050 acpi_processor_hotplug_notify);
1051 break;
1052 default:
1053 break;
1054 }
1055
1056 return (AE_OK);
1057}
1058
1059static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
1060{
1061
1062 if (!is_processor_present(handle)) {
1063 return AE_ERROR;
1064 }
1065
1066 if (acpi_map_lsapic(handle, p_cpu))
1067 return AE_ERROR;
1068
1069 if (arch_register_cpu(*p_cpu)) {
1070 acpi_unmap_lsapic(*p_cpu);
1071 return AE_ERROR;
1072 }
1073
1074 return AE_OK;
1075}
1076
1077static int acpi_processor_handle_eject(struct acpi_processor *pr)
1078{
1079 if (cpu_online(pr->id))
1080 cpu_down(pr->id);
1081
1082 arch_unregister_cpu(pr->id);
1083 acpi_unmap_lsapic(pr->id);
1084 return (0);
1085}
1086#else
1087static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
1088{
1089 return AE_ERROR;
1090}
1091static int acpi_processor_handle_eject(struct acpi_processor *pr)
1092{
1093 return (-EINVAL);
1094}
1095#endif
1096
1097static
1098void acpi_processor_install_hotplug_notify(void)
1099{
1100#ifdef CONFIG_ACPI_HOTPLUG_CPU
1101 int action = INSTALL_NOTIFY_HANDLER;
1102 acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
1103 ACPI_ROOT_OBJECT,
1104 ACPI_UINT32_MAX,
1105 processor_walk_namespace_cb, &action, NULL);
1106#endif
1107 register_hotcpu_notifier(&acpi_cpu_notifier);
1108}
1109
1110static
1111void acpi_processor_uninstall_hotplug_notify(void)
1112{
1113#ifdef CONFIG_ACPI_HOTPLUG_CPU
1114 int action = UNINSTALL_NOTIFY_HANDLER;
1115 acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
1116 ACPI_ROOT_OBJECT,
1117 ACPI_UINT32_MAX,
1118 processor_walk_namespace_cb, &action, NULL);
1119#endif
1120 unregister_hotcpu_notifier(&acpi_cpu_notifier);
1121}
1122
1123
1124
1125
1126
1127
1128
1129static int __init acpi_processor_init(void)
1130{
1131 int result = 0;
1132
1133 if (acpi_disabled)
1134 return 0;
1135
1136 memset(&errata, 0, sizeof(errata));
1137
1138#ifdef CONFIG_SMP
1139 if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
1140 (struct acpi_table_header **)&madt)))
1141 madt = NULL;
1142#endif
1143#ifdef CONFIG_ACPI_PROCFS
1144 acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
1145 if (!acpi_processor_dir)
1146 return -ENOMEM;
1147#endif
1148
1149
1150
1151
1152 dmi_check_system(processor_idle_dmi_table);
1153 result = cpuidle_register_driver(&acpi_idle_driver);
1154 if (result < 0)
1155 goto out_proc;
1156
1157 result = acpi_bus_register_driver(&acpi_processor_driver);
1158 if (result < 0)
1159 goto out_cpuidle;
1160
1161 acpi_processor_install_hotplug_notify();
1162
1163 acpi_thermal_cpufreq_init();
1164
1165 acpi_processor_ppc_init();
1166
1167 acpi_processor_throttling_init();
1168
1169 return 0;
1170
1171out_cpuidle:
1172 cpuidle_unregister_driver(&acpi_idle_driver);
1173
1174out_proc:
1175#ifdef CONFIG_ACPI_PROCFS
1176 remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
1177#endif
1178
1179 return result;
1180}
1181
1182static void __exit acpi_processor_exit(void)
1183{
1184 if (acpi_disabled)
1185 return;
1186
1187 acpi_processor_ppc_exit();
1188
1189 acpi_thermal_cpufreq_exit();
1190
1191 acpi_processor_uninstall_hotplug_notify();
1192
1193 acpi_bus_unregister_driver(&acpi_processor_driver);
1194
1195 cpuidle_unregister_driver(&acpi_idle_driver);
1196
1197#ifdef CONFIG_ACPI_PROCFS
1198 remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
1199#endif
1200
1201 return;
1202}
1203
1204module_init(acpi_processor_init);
1205module_exit(acpi_processor_exit);
1206
1207EXPORT_SYMBOL(acpi_processor_set_thermal_limit);
1208
1209MODULE_ALIAS("processor");
1210
