system.c 16.0 KB
Newer Older
L
Linus Torvalds 已提交
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
/*
 *  acpi_system.c - ACPI System Driver ($Revision: 63 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
29
#include <linux/string.h>
L
Linus Torvalds 已提交
30 31 32 33 34
#include <asm/uaccess.h>

#include <acpi/acpi_drivers.h>

#define _COMPONENT		ACPI_SYSTEM_COMPONENT
35
ACPI_MODULE_NAME("system");
Z
Zhang Rui 已提交
36 37 38 39 40
#ifdef MODULE_PARAM_PREFIX
#undef MODULE_PARAM_PREFIX
#endif
#define MODULE_PARAM_PREFIX "acpi."

L
Linus Torvalds 已提交
41 42 43
#define ACPI_SYSTEM_CLASS		"system"
#define ACPI_SYSTEM_DEVICE_NAME		"System"

44 45
u32 acpi_irq_handled;

Z
Zhang Rui 已提交
46 47 48
/*
 * Make ACPICA version work as module param
 */
49 50
static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
{
Z
Zhang Rui 已提交
51 52 53 54 55 56 57 58 59
	int result;

	result = sprintf(buffer, "%x", ACPI_CA_VERSION);

	return result;
}

module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);

60 61 62 63
/* --------------------------------------------------------------------------
                              FS Interface (/sys)
   -------------------------------------------------------------------------- */
static LIST_HEAD(acpi_table_attr_list);
64
static struct kobject *tables_kobj;
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

struct acpi_table_attr {
	struct bin_attribute attr;
	char name[8];
	int instance;
	struct list_head node;
};

static ssize_t acpi_table_show(struct kobject *kobj,
			       struct bin_attribute *bin_attr, char *buf,
			       loff_t offset, size_t count)
{
	struct acpi_table_attr *table_attr =
	    container_of(bin_attr, struct acpi_table_attr, attr);
	struct acpi_table_header *table_header = NULL;
	acpi_status status;

	status =
	    acpi_get_table(table_attr->name, table_attr->instance,
			   &table_header);
	if (ACPI_FAILURE(status))
		return -ENODEV;

88 89
	return memory_read_from_buffer(buf, count, &offset,
					table_header, table_header->length);
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
}

static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
				 struct acpi_table_header *table_header)
{
	struct acpi_table_header *header = NULL;
	struct acpi_table_attr *attr = NULL;

	memcpy(table_attr->name, table_header->signature, ACPI_NAME_SIZE);

	list_for_each_entry(attr, &acpi_table_attr_list, node) {
		if (!memcmp(table_header->signature, attr->name,
			    ACPI_NAME_SIZE))
			if (table_attr->instance < attr->instance)
				table_attr->instance = attr->instance;
	}
	table_attr->instance++;

	if (table_attr->instance > 1 || (table_attr->instance == 1 &&
					 !acpi_get_table(table_header->
							 signature, 2,
							 &header)))
		sprintf(table_attr->name + 4, "%d", table_attr->instance);

	table_attr->attr.size = 0;
	table_attr->attr.read = acpi_table_show;
	table_attr->attr.attr.name = table_attr->name;
	table_attr->attr.attr.mode = 0444;

	return;
}

static int acpi_system_sysfs_init(void)
{
	struct acpi_table_attr *table_attr;
	struct acpi_table_header *table_header = NULL;
	int table_index = 0;
	int result;

129 130 131
	tables_kobj = kobject_create_and_add("tables", acpi_kobj);
	if (!tables_kobj)
		return -ENOMEM;
132 133 134 135 136 137 138 139 140 141 142 143 144

	do {
		result = acpi_get_table_by_index(table_index, &table_header);
		if (!result) {
			table_index++;
			table_attr = NULL;
			table_attr =
			    kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
			if (!table_attr)
				return -ENOMEM;

			acpi_table_attr_init(table_attr, table_header);
			result =
145
			    sysfs_create_bin_file(tables_kobj,
146 147 148 149 150 151 152 153 154
						  &table_attr->attr);
			if (result) {
				kfree(table_attr);
				return result;
			} else
				list_add_tail(&table_attr->node,
					      &acpi_table_attr_list);
		}
	} while (!result);
155
	kobject_uevent(tables_kobj, KOBJ_ADD);
156 157 158 159

	return 0;
}

160 161 162 163 164 165 166 167 168 169
/*
 * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
 * See Documentation/ABI/testing/sysfs-firmware-acpi
 */

#define COUNT_GPE 0
#define COUNT_SCI 1	/* acpi_irq_handled */
#define COUNT_ERROR 2	/* other */
#define NUM_COUNTERS_EXTRA 3

170 171 172 173 174 175 176
#define ACPI_EVENT_VALID	0x01
struct event_counter {
	u32 count;
	u32 flags;
};

static struct event_counter *all_counters;
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
static u32 num_gpes;
static u32 num_counters;
static struct attribute **all_attrs;
static u32 acpi_gpe_count;

static struct attribute_group interrupt_stats_attr_group = {
	.name = "interrupts",
};
static struct kobj_attribute *counter_attrs;

static int count_num_gpes(void)
{
	int count = 0;
	struct acpi_gpe_xrupt_info *gpe_xrupt_info;
	struct acpi_gpe_block_info *gpe_block;
	acpi_cpu_flags flags;

	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);

	gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
	while (gpe_xrupt_info) {
		gpe_block = gpe_xrupt_info->gpe_block_list_head;
		while (gpe_block) {
			count += gpe_block->register_count *
			    ACPI_GPE_REGISTER_WIDTH;
			gpe_block = gpe_block->next;
		}
		gpe_xrupt_info = gpe_xrupt_info->next;
	}
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return count;
}

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
static int get_gpe_device(int index, acpi_handle *handle)
{
	struct acpi_gpe_xrupt_info *gpe_xrupt_info;
	struct acpi_gpe_block_info *gpe_block;
	acpi_cpu_flags flags;
	struct acpi_namespace_node *node;

	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);

	gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
	while (gpe_xrupt_info) {
		gpe_block = gpe_xrupt_info->gpe_block_list_head;
		node = gpe_block->node;
		while (gpe_block) {
			index -= gpe_block->register_count *
			    ACPI_GPE_REGISTER_WIDTH;
			if (index < 0) {
				acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
				/* return NULL if it's FADT GPE */
				if (node->type != ACPI_TYPE_DEVICE)
					*handle = NULL;
				else
					*handle = node;
				return 0;
			}
			node = gpe_block->node;
			gpe_block = gpe_block->next;
		}
		gpe_xrupt_info = gpe_xrupt_info->next;
	}
	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);

	return -ENODEV;
}

246 247
static void delete_gpe_attr_array(void)
{
248
	struct event_counter *tmp = all_counters;
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273

	all_counters = NULL;
	kfree(tmp);

	if (counter_attrs) {
		int i;

		for (i = 0; i < num_gpes; i++)
			kfree(counter_attrs[i].attr.name);

		kfree(counter_attrs);
	}
	kfree(all_attrs);

	return;
}

void acpi_os_gpe_count(u32 gpe_number)
{
	acpi_gpe_count++;

	if (!all_counters)
		return;

	if (gpe_number < num_gpes)
274
		all_counters[gpe_number].count++;
275
	else
276 277
		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
					count++;
278 279 280 281 282 283 284 285 286 287

	return;
}

void acpi_os_fixed_event_count(u32 event_number)
{
	if (!all_counters)
		return;

	if (event_number < ACPI_NUM_FIXED_EVENTS)
288
		all_counters[num_gpes + event_number].count++;
289
	else
290 291
		all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
				count++;
292 293 294 295

	return;
}

296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
{
	int result = 0;

	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
		goto end;

	if (index < num_gpes) {
		result = get_gpe_device(index, handle);
		if (result) {
			ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
				"Invalid GPE 0x%x\n", index));
			goto end;
		}
		result = acpi_get_gpe_status(*handle, index,
						ACPI_NOT_ISR, status);
	} else if (index < (num_gpes + ACPI_NUM_FIXED_EVENTS))
		result = acpi_get_event_status(index - num_gpes, status);

	/*
	 * sleep/power button GPE/Fixed Event is enabled after acpi_system_init,
	 * check the status at runtime and mark it as valid once it's enabled
	 */
	if (!result && (*status & ACPI_EVENT_FLAG_ENABLED))
		all_counters[index].flags |= ACPI_EVENT_VALID;
end:
	return result;
}

325 326 327
static ssize_t counter_show(struct kobject *kobj,
	struct kobj_attribute *attr, char *buf)
{
328 329 330 331 332 333 334
	int index = attr - counter_attrs;
	int size;
	acpi_handle handle;
	acpi_event_status status;
	int result = 0;

	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
335
		acpi_irq_handled;
336
	all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
337 338
		acpi_gpe_count;

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
	size = sprintf(buf, "%8d", all_counters[index].count);

	/* "gpe_all" or "sci" */
	if (index >= num_gpes + ACPI_NUM_FIXED_EVENTS)
		goto end;

	result = get_status(index, &status, &handle);
	if (result)
		goto end;

	if (!(all_counters[index].flags & ACPI_EVENT_VALID))
		size += sprintf(buf + size, "  invalid");
	else if (status & ACPI_EVENT_FLAG_ENABLED)
		size += sprintf(buf + size, "	enable");
	else
		size += sprintf(buf + size, "  disable");

end:
	size += sprintf(buf + size, "\n");
	return result ? result : size;
359 360 361 362 363
}

/*
 * counter_set() sets the specified counter.
 * setting the total "sci" file to any value clears all counters.
364
 * enable/disable/clear a gpe/fixed event in user space.
365 366 367 368 369
 */
static ssize_t counter_set(struct kobject *kobj,
	struct kobj_attribute *attr, const char *buf, size_t size)
{
	int index = attr - counter_attrs;
370 371 372
	acpi_event_status status;
	acpi_handle handle;
	int result = 0;
373 374 375 376

	if (index == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI) {
		int i;
		for (i = 0; i < num_counters; ++i)
377
			all_counters[i].count = 0;
378 379
		acpi_gpe_count = 0;
		acpi_irq_handled = 0;
380 381 382 383 384 385 386 387 388
		goto end;
	}

	/* show the event status for both GPEs and Fixed Events */
	result = get_status(index, &status, &handle);
	if (result)
		goto end;

	if (!(all_counters[index].flags & ACPI_EVENT_VALID)) {
389 390
		printk(KERN_WARNING PREFIX
			"Can not change Invalid GPE/Fixed Event status\n");
391 392
		return -EINVAL;
	}
393

394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
	if (index < num_gpes) {
		if (!strcmp(buf, "disable\n") &&
				(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_disable_gpe(handle, index, ACPI_NOT_ISR);
		else if (!strcmp(buf, "enable\n") &&
				!(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_enable_gpe(handle, index, ACPI_NOT_ISR);
		else if (!strcmp(buf, "clear\n") &&
				(status & ACPI_EVENT_FLAG_SET))
			result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
		else
			all_counters[index].count = strtoul(buf, NULL, 0);
	} else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
		int event = index - num_gpes;
		if (!strcmp(buf, "disable\n") &&
				(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_disable_event(event, ACPI_NOT_ISR);
		else if (!strcmp(buf, "enable\n") &&
				!(status & ACPI_EVENT_FLAG_ENABLED))
			result = acpi_enable_event(event, ACPI_NOT_ISR);
		else if (!strcmp(buf, "clear\n") &&
				(status & ACPI_EVENT_FLAG_SET))
			result = acpi_clear_event(event);
		else
			all_counters[index].count = strtoul(buf, NULL, 0);
419
	} else
420
		all_counters[index].count = strtoul(buf, NULL, 0);
421

422 423 424 425
	if (ACPI_FAILURE(result))
		result = -EINVAL;
end:
	return result ? result : size;
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
}

void acpi_irq_stats_init(void)
{
	int i;

	if (all_counters)
		return;

	num_gpes = count_num_gpes();
	num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;

	all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
			GFP_KERNEL);
	if (all_attrs == NULL)
		return;

443 444
	all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
				GFP_KERNEL);
445 446 447 448 449 450 451 452 453
	if (all_counters == NULL)
		goto fail;

	counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
			GFP_KERNEL);
	if (counter_attrs == NULL)
		goto fail;

	for (i = 0; i < num_counters; ++i) {
454
		char buffer[12];
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
		char *name;

		if (i < num_gpes)
			sprintf(buffer, "gpe%02X", i);
		else if (i == num_gpes + ACPI_EVENT_PMTIMER)
			sprintf(buffer, "ff_pmtimer");
		else if (i == num_gpes + ACPI_EVENT_GLOBAL)
			sprintf(buffer, "ff_gbl_lock");
		else if (i == num_gpes + ACPI_EVENT_POWER_BUTTON)
			sprintf(buffer, "ff_pwr_btn");
		else if (i == num_gpes + ACPI_EVENT_SLEEP_BUTTON)
			sprintf(buffer, "ff_slp_btn");
		else if (i == num_gpes + ACPI_EVENT_RTC)
			sprintf(buffer, "ff_rt_clk");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE)
			sprintf(buffer, "gpe_all");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI)
			sprintf(buffer, "sci");
		else if (i == num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR)
			sprintf(buffer, "error");
		else
			sprintf(buffer, "bug%02X", i);

		name = kzalloc(strlen(buffer) + 1, GFP_KERNEL);
		if (name == NULL)
			goto fail;
		strncpy(name, buffer, strlen(buffer) + 1);

		counter_attrs[i].attr.name = name;
		counter_attrs[i].attr.mode = 0644;
		counter_attrs[i].show = counter_show;
		counter_attrs[i].store = counter_set;

		all_attrs[i] = &counter_attrs[i].attr;
	}

	interrupt_stats_attr_group.attrs = all_attrs;
L
Len Brown 已提交
492 493
	if (!sysfs_create_group(acpi_kobj, &interrupt_stats_attr_group))
		return;
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

fail:
	delete_gpe_attr_array();
	return;
}

static void __exit interrupt_stats_exit(void)
{
	sysfs_remove_group(acpi_kobj, &interrupt_stats_attr_group);

	delete_gpe_attr_array();

	return;
}

L
Linus Torvalds 已提交
509 510 511
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */
Z
Zhang Rui 已提交
512
#ifdef CONFIG_ACPI_PROCFS
513 514 515 516
#define ACPI_SYSTEM_FILE_INFO		"info"
#define ACPI_SYSTEM_FILE_EVENT		"event"
#define ACPI_SYSTEM_FILE_DSDT		"dsdt"
#define ACPI_SYSTEM_FILE_FADT		"fadt"
L
Linus Torvalds 已提交
517

L
Len Brown 已提交
518
static int acpi_system_read_info(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
519 520 521
{

	seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
522
	return 0;
L
Linus Torvalds 已提交
523 524 525 526 527 528 529
}

static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_system_read_info, PDE(inode)->data);
}

530
static const struct file_operations acpi_system_info_ops = {
531
	.owner = THIS_MODULE,
L
Len Brown 已提交
532 533 534 535
	.open = acpi_system_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
536 537
};

L
Len Brown 已提交
538 539
static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
				     loff_t *);
L
Linus Torvalds 已提交
540

541
static const struct file_operations acpi_system_dsdt_ops = {
542
	.owner = THIS_MODULE,
L
Len Brown 已提交
543
	.read = acpi_system_read_dsdt,
L
Linus Torvalds 已提交
544 545 546
};

static ssize_t
L
Len Brown 已提交
547 548
acpi_system_read_dsdt(struct file *file,
		      char __user * buffer, size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
549
{
L
Len Brown 已提交
550
	acpi_status status = AE_OK;
551
	struct acpi_table_header *dsdt = NULL;
L
Len Brown 已提交
552
	ssize_t res;
L
Linus Torvalds 已提交
553

554
	status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
L
Linus Torvalds 已提交
555
	if (ACPI_FAILURE(status))
556
		return -ENODEV;
L
Linus Torvalds 已提交
557

558
	res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
L
Linus Torvalds 已提交
559

560
	return res;
L
Linus Torvalds 已提交
561 562
}

L
Len Brown 已提交
563 564
static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
				     loff_t *);
L
Linus Torvalds 已提交
565

566
static const struct file_operations acpi_system_fadt_ops = {
567
	.owner = THIS_MODULE,
L
Len Brown 已提交
568
	.read = acpi_system_read_fadt,
L
Linus Torvalds 已提交
569 570 571
};

static ssize_t
L
Len Brown 已提交
572 573
acpi_system_read_fadt(struct file *file,
		      char __user * buffer, size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
574
{
L
Len Brown 已提交
575
	acpi_status status = AE_OK;
576
	struct acpi_table_header *fadt = NULL;
L
Len Brown 已提交
577
	ssize_t res;
L
Linus Torvalds 已提交
578

579
	status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
L
Linus Torvalds 已提交
580
	if (ACPI_FAILURE(status))
581
		return -ENODEV;
L
Linus Torvalds 已提交
582

583
	res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
L
Linus Torvalds 已提交
584

585
	return res;
L
Linus Torvalds 已提交
586 587
}

588
static int acpi_system_procfs_init(void)
L
Linus Torvalds 已提交
589
{
L
Len Brown 已提交
590
	struct proc_dir_entry *entry;
L
Linus Torvalds 已提交
591 592 593
	int error = 0;

	/* 'info' [R] */
594 595
	entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
			    &acpi_system_info_ops);
L
Linus Torvalds 已提交
596 597 598 599
	if (!entry)
		goto Error;

	/* 'dsdt' [R] */
600 601 602
	entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
			    &acpi_system_dsdt_ops);
	if (!entry)
L
Linus Torvalds 已提交
603 604 605
		goto Error;

	/* 'fadt' [R] */
606 607 608
	entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
			    &acpi_system_fadt_ops);
	if (!entry)
L
Linus Torvalds 已提交
609 610
		goto Error;

L
Len Brown 已提交
611
      Done:
612
	return error;
L
Linus Torvalds 已提交
613

L
Len Brown 已提交
614
      Error:
L
Linus Torvalds 已提交
615 616 617 618 619 620 621
	remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
	remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
	remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);

	error = -EFAULT;
	goto Done;
}
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
#else
static int acpi_system_procfs_init(void)
{
	return 0;
}
#endif

static int __init acpi_system_init(void)
{
	int result = 0;

	if (acpi_disabled)
		return 0;

	result = acpi_system_procfs_init();
	if (result)
		return result;

	result = acpi_system_sysfs_init();

	return result;
}
L
Linus Torvalds 已提交
644 645

subsys_initcall(acpi_system_init);