litmus-rt.git - The LITMUS^RT kernel.

diff options

author	David Howells <dhowells@redhat.com>	2012-12-20 12:14:26 -0500
committer	David Howells <dhowells@redhat.com>	2012-12-20 12:14:26 -0500
commit	b889fcf63cb62e7fdb7816565e28f44dbe4a76a5 (patch)
tree	ca4519929e432fa4b4f2f61274d551648245565a /include/linux/kernel_stat.h
parent	1800098549fc310cffffefdcb3722adaad0edda8 (diff)

UAPI: (Scripted) Disintegrate include/video

Signed-off-by: David Howells <dhowells@redhat.com> Acked-by: Arnd Bergmann <arnd@arndb.de> Acked-by: Thomas Gleixner <tglx@linutronix.de> Acked-by: Michael Kerrisk <mtk.manpages@gmail.com> Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com> Acked-by: Dave Jones <davej@redhat.com>

Diffstat (limited to 'include/linux/kernel_stat.h')

0 files changed, 0 insertions, 0 deletions

/* * bios-less APM driver for ARM Linux * Jamey Hicks <jamey@crl.dec.com> * adapted from the APM BIOS driver for Linux by Stephen Rothwell (sfr@linuxcare.com) * * APM 1.2 Reference: * Intel Corporation, Microsoft Corporation. Advanced Power Management * (APM) BIOS Interface Specification, Revision 1.2, February 1996. * * This document is available from Microsoft at: * http://www.microsoft.com/whdc/archive/amp_12.mspx */ #include <linux/module.h> #include <linux/poll.h> #include <linux/slab.h> #include <linux/mutex.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/miscdevice.h> #include <linux/apm_bios.h> #include <linux/capability.h> #include <linux/sched.h> #include <linux/suspend.h> #include <linux/apm-emulation.h> #include <linux/freezer.h> #include <linux/device.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/init.h> #include <linux/completion.h> #include <linux/kthread.h> #include <linux/delay.h> /* * The apm_bios device is one of the misc char devices. * This is its minor number. */ #define APM_MINOR_DEV 134 /* * One option can be changed at boot time as follows: * apm=on/off enable/disable APM */ /* * Maximum number of events stored */ #define APM_MAX_EVENTS 16 struct apm_queue { unsigned int event_head; unsigned int event_tail; apm_event_t events[APM_MAX_EVENTS]; }; /* * thread states (for threads using a writable /dev/apm_bios fd): * * SUSPEND_NONE: nothing happening * SUSPEND_PENDING: suspend event queued for thread and pending to be read * SUSPEND_READ: suspend event read, pending acknowledgement * SUSPEND_ACKED: acknowledgement received from thread (via ioctl), * waiting for resume * SUSPEND_ACKTO: acknowledgement timeout * SUSPEND_DONE: thread had acked suspend and is now notified of * resume * * SUSPEND_WAIT: this thread invoked suspend and is waiting for resume * * A thread migrates in one of three paths: * NONE -1-> PENDING -2-> READ -3-> ACKED -4-> DONE -5-> NONE * -6-> ACKTO -7-> NONE * NONE -8-> WAIT -9-> NONE * * While in PENDING or READ, the thread is accounted for in the * suspend_acks_pending counter. * * The transitions are invoked as follows: * 1: suspend event is signalled from the core PM code * 2: the suspend event is read from the fd by the userspace thread * 3: userspace thread issues the APM_IOC_SUSPEND ioctl (as ack) * 4: core PM code signals that we have resumed * 5: APM_IOC_SUSPEND ioctl returns * * 6: the notifier invoked from the core PM code timed out waiting * for all relevant threds to enter ACKED state and puts those * that haven't into ACKTO * 7: those threads issue APM_IOC_SUSPEND ioctl too late, * get an error * * 8: userspace thread issues the APM_IOC_SUSPEND ioctl (to suspend), * ioctl code invokes pm_suspend() * 9: pm_suspend() returns indicating resume */ enum apm_suspend_state { SUSPEND_NONE, SUSPEND_PENDING, SUSPEND_READ, SUSPEND_ACKED, SUSPEND_ACKTO, SUSPEND_WAIT, SUSPEND_DONE, }; /* * The per-file APM data */ struct apm_user { struct list_head list; unsigned int suser: 1; unsigned int writer: 1; unsigned int reader: 1; int suspend_result; enum apm_suspend_state suspend_state; struct apm_queue queue; }; /* * Local variables */ static atomic_t suspend_acks_pending = ATOMIC_INIT(0); static atomic_t userspace_notification_inhibit = ATOMIC_INIT(0); static int apm_disabled; static struct task_struct *kapmd_tsk; static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue); static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue); /* * This is a list of everyone who has opened /dev/apm_bios */ static DECLARE_RWSEM(user_list_lock); static LIST_HEAD(apm_user_list); /* * kapmd info. kapmd provides us a process context to handle * "APM" events within - specifically necessary if we're going * to be suspending the system. */ static DECLARE_WAIT_QUEUE_HEAD(kapmd_wait); static DEFINE_SPINLOCK(kapmd_queue_lock); static struct apm_queue kapmd_queue; static DEFINE_MUTEX(state_lock); static const char driver_version[] = "1.13"; /* no spaces */ /* * Compatibility cruft until the IPAQ people move over to the new * interface. */ static void __apm_get_power_status(struct apm_power_info *info) { } /* * This allows machines to provide their own "apm get power status" function. */ void (*apm_get_power_status)(struct apm_power_info *) = __apm_get_power_status; EXPORT_SYMBOL(apm_get_power_status); /* * APM event queue management. */ static inline int queue_empty(struct apm_queue *q) { return q->event_head == q->event_tail; } static inline apm_event_t queue_get_event(struct apm_queue *q) { q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS; return q->events[q->event_tail]; } static void queue_add_event(struct apm_queue *q, apm_event_t event) { q->event_head = (q->event_head + 1) % APM_MAX_EVENTS; if (q->event_head == q->event_tail) { static int notified; if (notified++ == 0) printk(KERN_ERR "apm: an event queue overflowed\n"); q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS; } q->events[q->event_head] = event; } static void queue_event(apm_event_t event) { struct apm_user *as; down_read(&user_list_lock); list_for_each_entry(as, &apm_user_list, list) { if (as->reader) queue_add_event(&as->queue, event); } up_read(&user_list_lock); wake_up_interruptible(&apm_waitqueue); } static ssize_t apm_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) { struct apm_user *as = fp->private_data; apm_event_t event; int i = count, ret = 0; if (count < sizeof(apm_event_t)) return -EINVAL; if (queue_empty(&as->queue) && fp->f_flags & O_NONBLOCK) return -EAGAIN; wait_event_interruptible(apm_waitqueue, !queue_empty(&as->queue)); while ((i >= sizeof(event)) && !queue_empty(&as->queue)) { event = queue_get_event(&as->queue); ret = -EFAULT; if (copy_to_user(buf, &event, sizeof(event))) break; mutex_lock(&state_lock); if (as->suspend_state == SUSPEND_PENDING && (event == APM_SYS_SUSPEND || event == APM_USER_SUSPEND)) as->suspend_state = SUSPEND_READ; mutex_unlock(&state_lock); buf += sizeof(event); i -= sizeof(event); } if (i < count) ret = count - i; return ret; } static unsigned int apm_poll(struct file *fp, poll_table * wait) { struct apm_user *as = fp->private_data; poll_wait(fp, &apm_waitqueue, wait); return queue_empty(&as->queue) ? 0 : POLLIN | POLLRDNORM; } /* * apm_ioctl - handle APM ioctl * * APM_IOC_SUSPEND * This IOCTL is overloaded, and performs two functions. It is used to: * - initiate a suspend * - acknowledge a suspend read from /dev/apm_bios. * Only when everyone who has opened /dev/apm_bios with write permission * has acknowledge does the actual suspend happen. */ static long apm_ioctl(struct file *filp, u_int cmd, u_long arg) { struct apm_user *as = filp->private_data; int err = -EINVAL; if (!as->suser || !as->writer) return -EPERM; switch (cmd) { case APM_IOC_SUSPEND: mutex_lock(&state_lock); as->suspend_result = -EINTR; switch (as->suspend_state) { case SUSPEND_READ: /* * If we read a suspend command from /dev/apm_bios, * then the corresponding APM_IOC_SUSPEND ioctl is * interpreted as an acknowledge. */ as->suspend_state = SUSPEND_ACKED; atomic_dec(&suspend_acks_pending); mutex_unlock(&state_lock); /* * suspend_acks_pending changed, the notifier needs to * be woken up for this */ wake_up(&apm_suspend_waitqueue); /* * Wait for the suspend/resume to complete. If there * are pending acknowledges, we wait here for them. * wait_event_freezable() is interruptible and pending * signal can cause busy looping. We aren't doing * anything critical, chill a bit on each iteration. */ while (wait_event_freezable(apm_suspend_waitqueue, as->suspend_state != SUSPEND_ACKED)) msleep(10);


context:
space:
mode: