xref: /linux/drivers/acpi/bus.c (revision 00a6d7b6762c27d441e9ac8faff36384bc0fc180)
1 /*
2  *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
3  *
4  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5  *
6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or (at
11  *  your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful, but
14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License along
19  *  with this program; if not, write to the Free Software Foundation, Inc.,
20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21  *
22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23  */
24 
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/ioport.h>
28 #include <linux/kernel.h>
29 #include <linux/list.h>
30 #include <linux/sched.h>
31 #include <linux/pm.h>
32 #include <linux/device.h>
33 #include <linux/proc_fs.h>
34 #include <linux/acpi.h>
35 #include <linux/slab.h>
36 #include <linux/regulator/machine.h>
37 #ifdef CONFIG_X86
38 #include <asm/mpspec.h>
39 #endif
40 #include <linux/pci.h>
41 #include <acpi/apei.h>
42 #include <linux/dmi.h>
43 #include <linux/suspend.h>
44 
45 #include "internal.h"
46 
47 #define _COMPONENT		ACPI_BUS_COMPONENT
48 ACPI_MODULE_NAME("bus");
49 
50 struct acpi_device *acpi_root;
51 struct proc_dir_entry *acpi_root_dir;
52 EXPORT_SYMBOL(acpi_root_dir);
53 
54 #ifdef CONFIG_X86
55 static int set_copy_dsdt(const struct dmi_system_id *id)
56 {
57 	printk(KERN_NOTICE "%s detected - "
58 		"force copy of DSDT to local memory\n", id->ident);
59 	acpi_gbl_copy_dsdt_locally = 1;
60 	return 0;
61 }
62 
63 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
64 	/*
65 	 * Invoke DSDT corruption work-around on all Toshiba Satellite.
66 	 * https://bugzilla.kernel.org/show_bug.cgi?id=14679
67 	 */
68 	{
69 	 .callback = set_copy_dsdt,
70 	 .ident = "TOSHIBA Satellite",
71 	 .matches = {
72 		DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
73 		DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
74 		},
75 	},
76 	{}
77 };
78 #else
79 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
80 	{}
81 };
82 #endif
83 
84 /* --------------------------------------------------------------------------
85                                 Device Management
86    -------------------------------------------------------------------------- */
87 
88 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
89 				       unsigned long long *sta)
90 {
91 	acpi_status status;
92 
93 	status = acpi_evaluate_integer(handle, "_STA", NULL, sta);
94 	if (ACPI_SUCCESS(status))
95 		return AE_OK;
96 
97 	if (status == AE_NOT_FOUND) {
98 		*sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
99 		       ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
100 		return AE_OK;
101 	}
102 	return status;
103 }
104 
105 int acpi_bus_get_status(struct acpi_device *device)
106 {
107 	acpi_status status;
108 	unsigned long long sta;
109 
110 	status = acpi_bus_get_status_handle(device->handle, &sta);
111 	if (ACPI_FAILURE(status))
112 		return -ENODEV;
113 
114 	acpi_set_device_status(device, sta);
115 
116 	if (device->status.functional && !device->status.present) {
117 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: "
118 		       "functional but not present;\n",
119 			device->pnp.bus_id, (u32)sta));
120 	}
121 
122 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
123 			  device->pnp.bus_id, (u32)sta));
124 	return 0;
125 }
126 EXPORT_SYMBOL(acpi_bus_get_status);
127 
128 void acpi_bus_private_data_handler(acpi_handle handle,
129 				   void *context)
130 {
131 	return;
132 }
133 EXPORT_SYMBOL(acpi_bus_private_data_handler);
134 
135 int acpi_bus_get_private_data(acpi_handle handle, void **data)
136 {
137 	acpi_status status;
138 
139 	if (!*data)
140 		return -EINVAL;
141 
142 	status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
143 	if (ACPI_FAILURE(status) || !*data) {
144 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
145 				handle));
146 		return -ENODEV;
147 	}
148 
149 	return 0;
150 }
151 EXPORT_SYMBOL(acpi_bus_get_private_data);
152 
153 void acpi_bus_no_hotplug(acpi_handle handle)
154 {
155 	struct acpi_device *adev = NULL;
156 
157 	acpi_bus_get_device(handle, &adev);
158 	if (adev)
159 		adev->flags.no_hotplug = true;
160 }
161 EXPORT_SYMBOL_GPL(acpi_bus_no_hotplug);
162 
163 static void acpi_print_osc_error(acpi_handle handle,
164 	struct acpi_osc_context *context, char *error)
165 {
166 	struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
167 	int i;
168 
169 	if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
170 		printk(KERN_DEBUG "%s\n", error);
171 	else {
172 		printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error);
173 		kfree(buffer.pointer);
174 	}
175 	printk(KERN_DEBUG"_OSC request data:");
176 	for (i = 0; i < context->cap.length; i += sizeof(u32))
177 		printk("%x ", *((u32 *)(context->cap.pointer + i)));
178 	printk("\n");
179 }
180 
181 acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
182 {
183 	int i;
184 	static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21,
185 		24, 26, 28, 30, 32, 34};
186 
187 	if (strlen(str) != 36)
188 		return AE_BAD_PARAMETER;
189 	for (i = 0; i < 36; i++) {
190 		if (i == 8 || i == 13 || i == 18 || i == 23) {
191 			if (str[i] != '-')
192 				return AE_BAD_PARAMETER;
193 		} else if (!isxdigit(str[i]))
194 			return AE_BAD_PARAMETER;
195 	}
196 	for (i = 0; i < 16; i++) {
197 		uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4;
198 		uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]);
199 	}
200 	return AE_OK;
201 }
202 EXPORT_SYMBOL_GPL(acpi_str_to_uuid);
203 
204 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context)
205 {
206 	acpi_status status;
207 	struct acpi_object_list input;
208 	union acpi_object in_params[4];
209 	union acpi_object *out_obj;
210 	u8 uuid[16];
211 	u32 errors;
212 	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
213 
214 	if (!context)
215 		return AE_ERROR;
216 	if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid)))
217 		return AE_ERROR;
218 	context->ret.length = ACPI_ALLOCATE_BUFFER;
219 	context->ret.pointer = NULL;
220 
221 	/* Setting up input parameters */
222 	input.count = 4;
223 	input.pointer = in_params;
224 	in_params[0].type 		= ACPI_TYPE_BUFFER;
225 	in_params[0].buffer.length 	= 16;
226 	in_params[0].buffer.pointer	= uuid;
227 	in_params[1].type 		= ACPI_TYPE_INTEGER;
228 	in_params[1].integer.value 	= context->rev;
229 	in_params[2].type 		= ACPI_TYPE_INTEGER;
230 	in_params[2].integer.value	= context->cap.length/sizeof(u32);
231 	in_params[3].type		= ACPI_TYPE_BUFFER;
232 	in_params[3].buffer.length 	= context->cap.length;
233 	in_params[3].buffer.pointer 	= context->cap.pointer;
234 
235 	status = acpi_evaluate_object(handle, "_OSC", &input, &output);
236 	if (ACPI_FAILURE(status))
237 		return status;
238 
239 	if (!output.length)
240 		return AE_NULL_OBJECT;
241 
242 	out_obj = output.pointer;
243 	if (out_obj->type != ACPI_TYPE_BUFFER
244 		|| out_obj->buffer.length != context->cap.length) {
245 		acpi_print_osc_error(handle, context,
246 			"_OSC evaluation returned wrong type");
247 		status = AE_TYPE;
248 		goto out_kfree;
249 	}
250 	/* Need to ignore the bit0 in result code */
251 	errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
252 	if (errors) {
253 		if (errors & OSC_REQUEST_ERROR)
254 			acpi_print_osc_error(handle, context,
255 				"_OSC request failed");
256 		if (errors & OSC_INVALID_UUID_ERROR)
257 			acpi_print_osc_error(handle, context,
258 				"_OSC invalid UUID");
259 		if (errors & OSC_INVALID_REVISION_ERROR)
260 			acpi_print_osc_error(handle, context,
261 				"_OSC invalid revision");
262 		if (errors & OSC_CAPABILITIES_MASK_ERROR) {
263 			if (((u32 *)context->cap.pointer)[OSC_QUERY_DWORD]
264 			    & OSC_QUERY_ENABLE)
265 				goto out_success;
266 			status = AE_SUPPORT;
267 			goto out_kfree;
268 		}
269 		status = AE_ERROR;
270 		goto out_kfree;
271 	}
272 out_success:
273 	context->ret.length = out_obj->buffer.length;
274 	context->ret.pointer = kmemdup(out_obj->buffer.pointer,
275 				       context->ret.length, GFP_KERNEL);
276 	if (!context->ret.pointer) {
277 		status =  AE_NO_MEMORY;
278 		goto out_kfree;
279 	}
280 	status =  AE_OK;
281 
282 out_kfree:
283 	kfree(output.pointer);
284 	if (status != AE_OK)
285 		context->ret.pointer = NULL;
286 	return status;
287 }
288 EXPORT_SYMBOL(acpi_run_osc);
289 
290 bool osc_sb_apei_support_acked;
291 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
292 static void acpi_bus_osc_support(void)
293 {
294 	u32 capbuf[2];
295 	struct acpi_osc_context context = {
296 		.uuid_str = sb_uuid_str,
297 		.rev = 1,
298 		.cap.length = 8,
299 		.cap.pointer = capbuf,
300 	};
301 	acpi_handle handle;
302 
303 	capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE;
304 	capbuf[OSC_SUPPORT_DWORD] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */
305 #if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\
306 			defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE)
307 	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PAD_SUPPORT;
308 #endif
309 
310 #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
311 	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
312 #endif
313 
314 	capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
315 
316 	if (!ghes_disable)
317 		capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
318 	if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
319 		return;
320 	if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
321 		u32 *capbuf_ret = context.ret.pointer;
322 		if (context.ret.length > OSC_SUPPORT_DWORD)
323 			osc_sb_apei_support_acked =
324 				capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
325 		kfree(context.ret.pointer);
326 	}
327 	/* do we need to check other returned cap? Sounds no */
328 }
329 
330 /* --------------------------------------------------------------------------
331                              Notification Handling
332    -------------------------------------------------------------------------- */
333 
334 /**
335  * acpi_bus_notify
336  * ---------------
337  * Callback for all 'system-level' device notifications (values 0x00-0x7F).
338  */
339 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
340 {
341 	struct acpi_device *adev;
342 	struct acpi_driver *driver;
343 	acpi_status status;
344 	u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
345 
346 	switch (type) {
347 	case ACPI_NOTIFY_BUS_CHECK:
348 		acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
349 		break;
350 
351 	case ACPI_NOTIFY_DEVICE_CHECK:
352 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
353 		break;
354 
355 	case ACPI_NOTIFY_DEVICE_WAKE:
356 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_WAKE event\n");
357 		break;
358 
359 	case ACPI_NOTIFY_EJECT_REQUEST:
360 		acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
361 		break;
362 
363 	case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
364 		acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK_LIGHT event\n");
365 		/* TBD: Exactly what does 'light' mean? */
366 		break;
367 
368 	case ACPI_NOTIFY_FREQUENCY_MISMATCH:
369 		acpi_handle_err(handle, "Device cannot be configured due "
370 				"to a frequency mismatch\n");
371 		break;
372 
373 	case ACPI_NOTIFY_BUS_MODE_MISMATCH:
374 		acpi_handle_err(handle, "Device cannot be configured due "
375 				"to a bus mode mismatch\n");
376 		break;
377 
378 	case ACPI_NOTIFY_POWER_FAULT:
379 		acpi_handle_err(handle, "Device has suffered a power fault\n");
380 		break;
381 
382 	default:
383 		acpi_handle_debug(handle, "Unknown event type 0x%x\n", type);
384 		break;
385 	}
386 
387 	adev = acpi_bus_get_acpi_device(handle);
388 	if (!adev)
389 		goto err;
390 
391 	driver = adev->driver;
392 	if (driver && driver->ops.notify &&
393 	    (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
394 		driver->ops.notify(adev, type);
395 
396 	switch (type) {
397 	case ACPI_NOTIFY_BUS_CHECK:
398 	case ACPI_NOTIFY_DEVICE_CHECK:
399 	case ACPI_NOTIFY_EJECT_REQUEST:
400 		status = acpi_hotplug_schedule(adev, type);
401 		if (ACPI_SUCCESS(status))
402 			return;
403 	default:
404 		break;
405 	}
406 	acpi_bus_put_acpi_device(adev);
407 	return;
408 
409  err:
410 	acpi_evaluate_ost(handle, type, ost_code, NULL);
411 }
412 
413 /* --------------------------------------------------------------------------
414                              Initialization/Cleanup
415    -------------------------------------------------------------------------- */
416 
417 static int __init acpi_bus_init_irq(void)
418 {
419 	acpi_status status;
420 	char *message = NULL;
421 
422 
423 	/*
424 	 * Let the system know what interrupt model we are using by
425 	 * evaluating the \_PIC object, if exists.
426 	 */
427 
428 	switch (acpi_irq_model) {
429 	case ACPI_IRQ_MODEL_PIC:
430 		message = "PIC";
431 		break;
432 	case ACPI_IRQ_MODEL_IOAPIC:
433 		message = "IOAPIC";
434 		break;
435 	case ACPI_IRQ_MODEL_IOSAPIC:
436 		message = "IOSAPIC";
437 		break;
438 	case ACPI_IRQ_MODEL_PLATFORM:
439 		message = "platform specific model";
440 		break;
441 	default:
442 		printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
443 		return -ENODEV;
444 	}
445 
446 	printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
447 
448 	status = acpi_execute_simple_method(NULL, "\\_PIC", acpi_irq_model);
449 	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
450 		ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
451 		return -ENODEV;
452 	}
453 
454 	return 0;
455 }
456 
457 u8 acpi_gbl_permanent_mmap;
458 
459 
460 void __init acpi_early_init(void)
461 {
462 	acpi_status status;
463 
464 	if (acpi_disabled)
465 		return;
466 
467 	printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
468 
469 	/* enable workarounds, unless strict ACPI spec. compliance */
470 	if (!acpi_strict)
471 		acpi_gbl_enable_interpreter_slack = TRUE;
472 
473 	acpi_gbl_permanent_mmap = 1;
474 
475 	/*
476 	 * If the machine falls into the DMI check table,
477 	 * DSDT will be copied to memory
478 	 */
479 	dmi_check_system(dsdt_dmi_table);
480 
481 	status = acpi_reallocate_root_table();
482 	if (ACPI_FAILURE(status)) {
483 		printk(KERN_ERR PREFIX
484 		       "Unable to reallocate ACPI tables\n");
485 		goto error0;
486 	}
487 
488 	status = acpi_initialize_subsystem();
489 	if (ACPI_FAILURE(status)) {
490 		printk(KERN_ERR PREFIX
491 		       "Unable to initialize the ACPI Interpreter\n");
492 		goto error0;
493 	}
494 
495 	status = acpi_load_tables();
496 	if (ACPI_FAILURE(status)) {
497 		printk(KERN_ERR PREFIX
498 		       "Unable to load the System Description Tables\n");
499 		goto error0;
500 	}
501 
502 #ifdef CONFIG_X86
503 	if (!acpi_ioapic) {
504 		/* compatible (0) means level (3) */
505 		if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) {
506 			acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK;
507 			acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL;
508 		}
509 		/* Set PIC-mode SCI trigger type */
510 		acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt,
511 					 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2);
512 	} else {
513 		/*
514 		 * now that acpi_gbl_FADT is initialized,
515 		 * update it with result from INT_SRC_OVR parsing
516 		 */
517 		acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi;
518 	}
519 #endif
520 
521 	status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE);
522 	if (ACPI_FAILURE(status)) {
523 		printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
524 		goto error0;
525 	}
526 
527 	/*
528 	 * If the system is using ACPI then we can be reasonably
529 	 * confident that any regulators are managed by the firmware
530 	 * so tell the regulator core it has everything it needs to
531 	 * know.
532 	 */
533 	regulator_has_full_constraints();
534 
535 	return;
536 
537       error0:
538 	disable_acpi();
539 	return;
540 }
541 
542 static int __init acpi_bus_init(void)
543 {
544 	int result;
545 	acpi_status status;
546 
547 	acpi_os_initialize1();
548 
549 	status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
550 	if (ACPI_FAILURE(status)) {
551 		printk(KERN_ERR PREFIX
552 		       "Unable to start the ACPI Interpreter\n");
553 		goto error1;
554 	}
555 
556 	/*
557 	 * ACPI 2.0 requires the EC driver to be loaded and work before
558 	 * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
559 	 * is called).
560 	 *
561 	 * This is accomplished by looking for the ECDT table, and getting
562 	 * the EC parameters out of that.
563 	 */
564 	status = acpi_ec_ecdt_probe();
565 	/* Ignore result. Not having an ECDT is not fatal. */
566 
567 	status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
568 	if (ACPI_FAILURE(status)) {
569 		printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
570 		goto error1;
571 	}
572 
573 	/*
574 	 * _OSC method may exist in module level code,
575 	 * so it must be run after ACPI_FULL_INITIALIZATION
576 	 */
577 	acpi_bus_osc_support();
578 
579 	/*
580 	 * _PDC control method may load dynamic SSDT tables,
581 	 * and we need to install the table handler before that.
582 	 */
583 	acpi_sysfs_init();
584 
585 	acpi_early_processor_set_pdc();
586 
587 	/*
588 	 * Maybe EC region is required at bus_scan/acpi_get_devices. So it
589 	 * is necessary to enable it as early as possible.
590 	 */
591 	acpi_boot_ec_enable();
592 
593 	printk(KERN_INFO PREFIX "Interpreter enabled\n");
594 
595 	/* Initialize sleep structures */
596 	acpi_sleep_init();
597 
598 	/*
599 	 * Get the system interrupt model and evaluate \_PIC.
600 	 */
601 	result = acpi_bus_init_irq();
602 	if (result)
603 		goto error1;
604 
605 	/*
606 	 * Register the for all standard device notifications.
607 	 */
608 	status =
609 	    acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
610 					&acpi_bus_notify, NULL);
611 	if (ACPI_FAILURE(status)) {
612 		printk(KERN_ERR PREFIX
613 		       "Unable to register for device notifications\n");
614 		goto error1;
615 	}
616 
617 	/*
618 	 * Create the top ACPI proc directory
619 	 */
620 	acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
621 
622 	return 0;
623 
624 	/* Mimic structured exception handling */
625       error1:
626 	acpi_terminate();
627 	return -ENODEV;
628 }
629 
630 struct kobject *acpi_kobj;
631 EXPORT_SYMBOL_GPL(acpi_kobj);
632 
633 static int __init acpi_init(void)
634 {
635 	int result;
636 
637 	if (acpi_disabled) {
638 		printk(KERN_INFO PREFIX "Interpreter disabled.\n");
639 		return -ENODEV;
640 	}
641 
642 	acpi_kobj = kobject_create_and_add("acpi", firmware_kobj);
643 	if (!acpi_kobj) {
644 		printk(KERN_WARNING "%s: kset create error\n", __func__);
645 		acpi_kobj = NULL;
646 	}
647 
648 	init_acpi_device_notify();
649 	result = acpi_bus_init();
650 	if (result) {
651 		disable_acpi();
652 		return result;
653 	}
654 
655 	pci_mmcfg_late_init();
656 	acpi_scan_init();
657 	acpi_ec_init();
658 	acpi_debugfs_init();
659 	acpi_sleep_proc_init();
660 	acpi_wakeup_device_init();
661 	return 0;
662 }
663 
664 subsys_initcall(acpi_init);
665