proc.c 12.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/suspend.h>
#include <linux/bcd.h>
#include <asm/uaccess.h>

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#ifdef CONFIG_X86
#include <linux/mc146818rtc.h>
#endif

#include "sleep.h"

#define _COMPONENT		ACPI_SYSTEM_COMPONENT
17 18 19 20 21 22 23 24

/*
 * this file provides support for:
 * /proc/acpi/sleep
 * /proc/acpi/alarm
 * /proc/acpi/wakeup
 */

L
Len Brown 已提交
25
ACPI_MODULE_NAME("sleep")
26
#ifdef	CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
27 28
static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
{
L
Len Brown 已提交
29
	int i;
L
Linus Torvalds 已提交
30 31 32

	for (i = 0; i <= ACPI_STATE_S5; i++) {
		if (sleep_states[i]) {
L
Len Brown 已提交
33
			seq_printf(seq, "S%d ", i);
L
Linus Torvalds 已提交
34 35 36 37 38 39 40 41 42 43 44 45 46 47
		}
	}

	seq_puts(seq, "\n");

	return 0;
}

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

static ssize_t
L
Len Brown 已提交
48 49
acpi_system_write_sleep(struct file *file,
			const char __user * buffer, size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
50
{
L
Len Brown 已提交
51 52 53
	char str[12];
	u32 state = 0;
	int error = 0;
L
Linus Torvalds 已提交
54 55 56

	if (count > sizeof(str) - 1)
		goto Done;
L
Len Brown 已提交
57
	memset(str, 0, sizeof(str));
L
Linus Torvalds 已提交
58 59 60 61
	if (copy_from_user(str, buffer, count))
		return -EFAULT;

	/* Check for S4 bios request */
L
Len Brown 已提交
62
	if (!strcmp(str, "4b")) {
L
Linus Torvalds 已提交
63 64 65 66
		error = acpi_suspend(4);
		goto Done;
	}
	state = simple_strtoul(str, NULL, 0);
67
#ifdef CONFIG_HIBERNATION
L
Linus Torvalds 已提交
68
	if (state == 4) {
69
		error = hibernate();
L
Linus Torvalds 已提交
70 71 72 73
		goto Done;
	}
#endif
	error = acpi_suspend(state);
L
Len Brown 已提交
74
      Done:
L
Linus Torvalds 已提交
75 76
	return error ? error : count;
}
77
#endif				/* CONFIG_ACPI_PROCFS */
L
Linus Torvalds 已提交
78

L
Len Brown 已提交
79
#if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) || !defined(CONFIG_X86)
D
David Brownell 已提交
80 81 82 83 84 85 86
/* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
#else
#define	HAVE_ACPI_LEGACY_ALARM
#endif

#ifdef	HAVE_ACPI_LEGACY_ALARM

L
Len Brown 已提交
87 88
static u32 cmos_bcd_read(int offset, int rtc_control);

L
Linus Torvalds 已提交
89 90
static int acpi_system_alarm_seq_show(struct seq_file *seq, void *offset)
{
L
Len Brown 已提交
91
	u32 sec, min, hr;
92
	u32 day, mo, yr, cent = 0;
93
	u32 today = 0;
L
Len Brown 已提交
94 95
	unsigned char rtc_control = 0;
	unsigned long flags;
L
Linus Torvalds 已提交
96 97 98 99

	spin_lock_irqsave(&rtc_lock, flags);

	rtc_control = CMOS_READ(RTC_CONTROL);
100 101 102
	sec = cmos_bcd_read(RTC_SECONDS_ALARM, rtc_control);
	min = cmos_bcd_read(RTC_MINUTES_ALARM, rtc_control);
	hr = cmos_bcd_read(RTC_HOURS_ALARM, rtc_control);
L
Linus Torvalds 已提交
103 104

	/* If we ever get an FACP with proper values... */
105
	if (acpi_gbl_FADT.day_alarm) {
L
Linus Torvalds 已提交
106
		/* ACPI spec: only low 6 its should be cared */
107
		day = CMOS_READ(acpi_gbl_FADT.day_alarm) & 0x3F;
108 109 110 111
		if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
			day = bcd2bin(day);
	} else
		day = cmos_bcd_read(RTC_DAY_OF_MONTH, rtc_control);
112
	if (acpi_gbl_FADT.month_alarm)
113 114 115 116 117
		mo = cmos_bcd_read(acpi_gbl_FADT.month_alarm, rtc_control);
	else {
		mo = cmos_bcd_read(RTC_MONTH, rtc_control);
		today = cmos_bcd_read(RTC_DAY_OF_MONTH, rtc_control);
	}
118
	if (acpi_gbl_FADT.century)
119
		cent = cmos_bcd_read(acpi_gbl_FADT.century, rtc_control);
120

121
	yr = cmos_bcd_read(RTC_YEAR, rtc_control);
L
Linus Torvalds 已提交
122 123 124

	spin_unlock_irqrestore(&rtc_lock, flags);

L
Len Brown 已提交
125
	/* we're trusting the FADT (see above) */
126
	if (!acpi_gbl_FADT.century)
L
Len Brown 已提交
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
		/* If we're not trusting the FADT, we should at least make it
		 * right for _this_ century... ehm, what is _this_ century?
		 *
		 * TBD:
		 *  ASAP: find piece of code in the kernel, e.g. star tracker driver,
		 *        which we can trust to determine the century correctly. Atom
		 *        watch driver would be nice, too...
		 *
		 *  if that has not happened, change for first release in 2050:
		 *        if (yr<50)
		 *                yr += 2100;
		 *        else
		 *                yr += 2000;   // current line of code
		 *
		 *  if that has not happened either, please do on 2099/12/31:23:59:59
		 *        s/2000/2100
		 *
		 */
L
Linus Torvalds 已提交
145
		yr += 2000;
146 147
	else
		yr += cent * 100;
L
Linus Torvalds 已提交
148

149 150 151 152 153 154 155 156 157 158 159 160 161 162
	/*
	 * Show correct dates for alarms up to a month into the future.
	 * This solves issues for nearly all situations with the common
	 * 30-day alarm clocks in PC hardware.
	 */
	if (day < today) {
		if (mo < 12) {
			mo += 1;
		} else {
			mo = 1;
			yr += 1;
		}
	}

L
Len Brown 已提交
163 164 165 166 167
	seq_printf(seq, "%4.4u-", yr);
	(mo > 12) ? seq_puts(seq, "**-") : seq_printf(seq, "%2.2u-", mo);
	(day > 31) ? seq_puts(seq, "** ") : seq_printf(seq, "%2.2u ", day);
	(hr > 23) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", hr);
	(min > 59) ? seq_puts(seq, "**:") : seq_printf(seq, "%2.2u:", min);
L
Linus Torvalds 已提交
168 169 170 171 172 173 174 175 176 177
	(sec > 59) ? seq_puts(seq, "**\n") : seq_printf(seq, "%2.2u\n", sec);

	return 0;
}

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

L
Len Brown 已提交
178
static int get_date_field(char **p, u32 * value)
L
Linus Torvalds 已提交
179
{
L
Len Brown 已提交
180 181 182
	char *next = NULL;
	char *string_end = NULL;
	int result = -EINVAL;
L
Linus Torvalds 已提交
183 184 185 186 187

	/*
	 * Try to find delimeter, only to insert null.  The end of the
	 * string won't have one, but is still valid.
	 */
188 189 190
	if (*p == NULL)
		return result;

L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200 201 202
	next = strpbrk(*p, "- :");
	if (next)
		*next++ = '\0';

	*value = simple_strtoul(*p, &string_end, 10);

	/* Signal success if we got a good digit */
	if (string_end != *p)
		result = 0;

	if (next)
		*p = next;
203 204
	else
		*p = NULL;
L
Linus Torvalds 已提交
205 206 207 208

	return result;
}

209 210 211 212 213
/* Read a possibly BCD register, always return binary */
static u32 cmos_bcd_read(int offset, int rtc_control)
{
	u32 val = CMOS_READ(offset);
	if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
A
Adrian Bunk 已提交
214
		val = bcd2bin(val);
215 216 217 218 219 220 221
	return val;
}

/* Write binary value into possibly BCD register */
static void cmos_bcd_write(u32 val, int offset, int rtc_control)
{
	if (!(rtc_control & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
A
Adrian Bunk 已提交
222
		val = bin2bcd(val);
223 224 225
	CMOS_WRITE(val, offset);
}

L
Linus Torvalds 已提交
226
static ssize_t
L
Len Brown 已提交
227 228
acpi_system_write_alarm(struct file *file,
			const char __user * buffer, size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
229
{
L
Len Brown 已提交
230 231 232 233 234 235
	int result = 0;
	char alarm_string[30] = { '\0' };
	char *p = alarm_string;
	u32 sec, min, hr, day, mo, yr;
	int adjust = 0;
	unsigned char rtc_control = 0;
L
Linus Torvalds 已提交
236 237

	if (count > sizeof(alarm_string) - 1)
238
		return -EINVAL;
L
Len Brown 已提交
239

L
Linus Torvalds 已提交
240
	if (copy_from_user(alarm_string, buffer, count))
241
		return -EFAULT;
L
Linus Torvalds 已提交
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268

	alarm_string[count] = '\0';

	/* check for time adjustment */
	if (alarm_string[0] == '+') {
		p++;
		adjust = 1;
	}

	if ((result = get_date_field(&p, &yr)))
		goto end;
	if ((result = get_date_field(&p, &mo)))
		goto end;
	if ((result = get_date_field(&p, &day)))
		goto end;
	if ((result = get_date_field(&p, &hr)))
		goto end;
	if ((result = get_date_field(&p, &min)))
		goto end;
	if ((result = get_date_field(&p, &sec)))
		goto end;

	spin_lock_irq(&rtc_lock);

	rtc_control = CMOS_READ(RTC_CONTROL);

	if (adjust) {
269 270 271 272 273 274
		yr += cmos_bcd_read(RTC_YEAR, rtc_control);
		mo += cmos_bcd_read(RTC_MONTH, rtc_control);
		day += cmos_bcd_read(RTC_DAY_OF_MONTH, rtc_control);
		hr += cmos_bcd_read(RTC_HOURS, rtc_control);
		min += cmos_bcd_read(RTC_MINUTES, rtc_control);
		sec += cmos_bcd_read(RTC_SECONDS, rtc_control);
L
Linus Torvalds 已提交
275 276 277 278 279
	}

	spin_unlock_irq(&rtc_lock);

	if (sec > 59) {
280 281
		min += sec/60;
		sec = sec%60;
L
Linus Torvalds 已提交
282 283
	}
	if (min > 59) {
284 285
		hr += min/60;
		min = min%60;
L
Linus Torvalds 已提交
286 287
	}
	if (hr > 23) {
288 289
		day += hr/24;
		hr = hr%24;
L
Linus Torvalds 已提交
290 291
	}
	if (day > 31) {
292 293
		mo += day/32;
		day = day%32;
L
Linus Torvalds 已提交
294 295
	}
	if (mo > 12) {
296 297
		yr += mo/13;
		mo = mo%13;
L
Linus Torvalds 已提交
298 299 300 301 302 303 304 305 306 307 308 309
	}

	spin_lock_irq(&rtc_lock);
	/*
	 * Disable alarm interrupt before setting alarm timer or else
	 * when ACPI_EVENT_RTC is enabled, a spurious ACPI interrupt occurs
	 */
	rtc_control &= ~RTC_AIE;
	CMOS_WRITE(rtc_control, RTC_CONTROL);
	CMOS_READ(RTC_INTR_FLAGS);

	/* write the fields the rtc knows about */
310 311 312
	cmos_bcd_write(hr, RTC_HOURS_ALARM, rtc_control);
	cmos_bcd_write(min, RTC_MINUTES_ALARM, rtc_control);
	cmos_bcd_write(sec, RTC_SECONDS_ALARM, rtc_control);
L
Linus Torvalds 已提交
313 314 315 316 317 318

	/*
	 * If the system supports an enhanced alarm it will have non-zero
	 * offsets into the CMOS RAM here -- which for some reason are pointing
	 * to the RTC area of memory.
	 */
319
	if (acpi_gbl_FADT.day_alarm)
320
		cmos_bcd_write(day, acpi_gbl_FADT.day_alarm, rtc_control);
321
	if (acpi_gbl_FADT.month_alarm)
322
		cmos_bcd_write(mo, acpi_gbl_FADT.month_alarm, rtc_control);
323 324 325
	if (acpi_gbl_FADT.century) {
		if (adjust)
			yr += cmos_bcd_read(acpi_gbl_FADT.century, rtc_control) * 100;
326
		cmos_bcd_write(yr / 100, acpi_gbl_FADT.century, rtc_control);
327
	}
L
Linus Torvalds 已提交
328 329 330 331 332 333 334 335 336 337 338 339 340
	/* enable the rtc alarm interrupt */
	rtc_control |= RTC_AIE;
	CMOS_WRITE(rtc_control, RTC_CONTROL);
	CMOS_READ(RTC_INTR_FLAGS);

	spin_unlock_irq(&rtc_lock);

	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_enable_event(ACPI_EVENT_RTC, 0);

	*ppos += count;

	result = 0;
L
Len Brown 已提交
341
      end:
342
	return result ? result : count;
L
Linus Torvalds 已提交
343
}
L
Len Brown 已提交
344
#endif				/* HAVE_ACPI_LEGACY_ALARM */
L
Linus Torvalds 已提交
345 346 347 348

static int
acpi_system_wakeup_device_seq_show(struct seq_file *seq, void *offset)
{
L
Len Brown 已提交
349
	struct list_head *node, *next;
L
Linus Torvalds 已提交
350

351
	seq_printf(seq, "Device\tS-state\t  Status   Sysfs node\n");
L
Linus Torvalds 已提交
352

353
	mutex_lock(&acpi_device_lock);
L
Linus Torvalds 已提交
354
	list_for_each_safe(node, next, &acpi_wakeup_device_list) {
L
Len Brown 已提交
355 356
		struct acpi_device *dev =
		    container_of(node, struct acpi_device, wakeup_list);
357
		struct device *ldev;
L
Linus Torvalds 已提交
358 359 360

		if (!dev->wakeup.flags.valid)
			continue;
361 362 363

		ldev = acpi_get_physical_device(dev->handle);
		seq_printf(seq, "%s\t  S%d\t%c%-8s  ",
L
Len Brown 已提交
364 365
			   dev->pnp.bus_id,
			   (u32) dev->wakeup.sleep_state,
366
			   dev->wakeup.flags.run_wake ? '*' : ' ',
P
Pavel Machek 已提交
367
			   dev->wakeup.state.enabled ? "enabled" : "disabled");
368 369
		if (ldev)
			seq_printf(seq, "%s:%s",
370
				   ldev->bus ? ldev->bus->name : "no-bus",
371
				   dev_name(ldev));
372 373 374
		seq_printf(seq, "\n");
		put_device(ldev);

L
Linus Torvalds 已提交
375
	}
376
	mutex_unlock(&acpi_device_lock);
L
Linus Torvalds 已提交
377 378 379
	return 0;
}

380 381 382 383 384 385 386 387
static void physical_device_enable_wakeup(struct acpi_device *adev)
{
	struct device *dev = acpi_get_physical_device(adev->handle);

	if (dev && device_can_wakeup(dev))
		device_set_wakeup_enable(dev, adev->wakeup.state.enabled);
}

L
Linus Torvalds 已提交
388
static ssize_t
L
Len Brown 已提交
389 390 391
acpi_system_write_wakeup_device(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
392
{
L
Len Brown 已提交
393 394 395 396
	struct list_head *node, *next;
	char strbuf[5];
	char str[5] = "";
	int len = count;
L
Linus Torvalds 已提交
397 398
	struct acpi_device *found_dev = NULL;

L
Len Brown 已提交
399 400
	if (len > 4)
		len = 4;
L
Linus Torvalds 已提交
401 402 403 404 405 406

	if (copy_from_user(strbuf, buffer, len))
		return -EFAULT;
	strbuf[len] = '\0';
	sscanf(strbuf, "%s", str);

407
	mutex_lock(&acpi_device_lock);
L
Linus Torvalds 已提交
408
	list_for_each_safe(node, next, &acpi_wakeup_device_list) {
L
Len Brown 已提交
409 410
		struct acpi_device *dev =
		    container_of(node, struct acpi_device, wakeup_list);
L
Linus Torvalds 已提交
411 412 413 414
		if (!dev->wakeup.flags.valid)
			continue;

		if (!strncmp(dev->pnp.bus_id, str, 4)) {
L
Len Brown 已提交
415 416
			dev->wakeup.state.enabled =
			    dev->wakeup.state.enabled ? 0 : 1;
L
Linus Torvalds 已提交
417 418 419 420 421
			found_dev = dev;
			break;
		}
	}
	if (found_dev) {
422
		physical_device_enable_wakeup(found_dev);
L
Linus Torvalds 已提交
423
		list_for_each_safe(node, next, &acpi_wakeup_device_list) {
L
Len Brown 已提交
424 425 426 427
			struct acpi_device *dev = container_of(node,
							       struct
							       acpi_device,
							       wakeup_list);
L
Linus Torvalds 已提交
428 429

			if ((dev != found_dev) &&
L
Len Brown 已提交
430 431 432 433 434 435 436 437 438 439
			    (dev->wakeup.gpe_number ==
			     found_dev->wakeup.gpe_number)
			    && (dev->wakeup.gpe_device ==
				found_dev->wakeup.gpe_device)) {
				printk(KERN_WARNING
				       "ACPI: '%s' and '%s' have the same GPE, "
				       "can't disable/enable one seperately\n",
				       dev->pnp.bus_id, found_dev->pnp.bus_id);
				dev->wakeup.state.enabled =
				    found_dev->wakeup.state.enabled;
440
				physical_device_enable_wakeup(dev);
L
Linus Torvalds 已提交
441 442 443
			}
		}
	}
444
	mutex_unlock(&acpi_device_lock);
L
Linus Torvalds 已提交
445 446 447 448 449 450
	return count;
}

static int
acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
{
L
Len Brown 已提交
451 452
	return single_open(file, acpi_system_wakeup_device_seq_show,
			   PDE(inode)->data);
L
Linus Torvalds 已提交
453 454
}

455
static const struct file_operations acpi_system_wakeup_device_fops = {
456
	.owner = THIS_MODULE,
L
Len Brown 已提交
457 458 459 460 461
	.open = acpi_system_wakeup_device_open_fs,
	.read = seq_read,
	.write = acpi_system_write_wakeup_device,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
462 463
};

464
#ifdef	CONFIG_ACPI_PROCFS
465
static const struct file_operations acpi_system_sleep_fops = {
466
	.owner = THIS_MODULE,
L
Len Brown 已提交
467 468 469 470 471
	.open = acpi_system_sleep_open_fs,
	.read = seq_read,
	.write = acpi_system_write_sleep,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
472
};
473
#endif				/* CONFIG_ACPI_PROCFS */
L
Linus Torvalds 已提交
474

D
David Brownell 已提交
475
#ifdef	HAVE_ACPI_LEGACY_ALARM
476
static const struct file_operations acpi_system_alarm_fops = {
477
	.owner = THIS_MODULE,
L
Len Brown 已提交
478 479 480 481 482
	.open = acpi_system_alarm_open_fs,
	.read = seq_read,
	.write = acpi_system_write_alarm,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
483 484
};

L
Len Brown 已提交
485
static u32 rtc_handler(void *context)
L
Linus Torvalds 已提交
486 487 488 489 490 491
{
	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_disable_event(ACPI_EVENT_RTC, 0);

	return ACPI_INTERRUPT_HANDLED;
}
L
Len Brown 已提交
492
#endif				/* HAVE_ACPI_LEGACY_ALARM */
L
Linus Torvalds 已提交
493

494
int __init acpi_sleep_proc_init(void)
L
Linus Torvalds 已提交
495
{
496
#ifdef	CONFIG_ACPI_PROCFS
P
Pavel Machek 已提交
497
	/* 'sleep' [R/W] */
498 499
	proc_create("sleep", S_IFREG | S_IRUGO | S_IWUSR,
		    acpi_root_dir, &acpi_system_sleep_fops);
500
#endif				/* CONFIG_ACPI_PROCFS */
L
Linus Torvalds 已提交
501

D
David Brownell 已提交
502
#ifdef	HAVE_ACPI_LEGACY_ALARM
L
Linus Torvalds 已提交
503
	/* 'alarm' [R/W] */
504 505
	proc_create("alarm", S_IFREG | S_IRUGO | S_IWUSR,
		    acpi_root_dir, &acpi_system_alarm_fops);
L
Linus Torvalds 已提交
506

D
David Brownell 已提交
507
	acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
508 509 510 511 512 513
	/*
	 * Disable the RTC event after installing RTC handler.
	 * Only when RTC alarm is set will it be enabled.
	 */
	acpi_clear_event(ACPI_EVENT_RTC);
	acpi_disable_event(ACPI_EVENT_RTC, 0);
L
Len Brown 已提交
514
#endif				/* HAVE_ACPI_LEGACY_ALARM */
D
David Brownell 已提交
515

P
Pavel Machek 已提交
516
	/* 'wakeup device' [R/W] */
517 518
	proc_create("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
		    acpi_root_dir, &acpi_system_wakeup_device_fops);
L
Linus Torvalds 已提交
519 520 521

	return 0;
}