SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/acpi/event.c

   1 /*
   2  * event.c - exporting ACPI events via procfs
   3  *
   4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   6  *
   7  */
   8
   9 #include <linux/spinlock.h>
  10 #include <linux/proc_fs.h>
  11 #include <linux/init.h>
  12 #include <linux/poll.h>
  13 #include <acpi/acpi_drivers.h>
  14 #include <net/netlink.h>
  15 #include <net/genetlink.h>
  16
  17 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
  18 ACPI_MODULE_NAME("event");
  19
  20 /* Global vars for handling event proc entry */
  21 static DEFINE_SPINLOCK(acpi_system_event_lock);
  22 int event_is_open = 0;
  23 extern struct list_head acpi_bus_event_list;
  24 extern wait_queue_head_t acpi_bus_event_queue;
  25
  26 static int acpi_system_open_event(struct inode *inode, struct file *file)
  27 {
  28         spin_lock_irq(&acpi_system_event_lock);
  29
  30         if (event_is_open)
  31                 goto out_busy;
  32
  33         event_is_open = 1;
  34
  35         spin_unlock_irq(&acpi_system_event_lock);
  36         return 0;
  37
  38       out_busy:
  39         spin_unlock_irq(&acpi_system_event_lock);
  40         return -EBUSY;
  41 }
  42
  43 static ssize_t
  44 acpi_system_read_event(struct file *file, char __user * buffer, size_t count,
  45                        loff_t * ppos)
  46 {
  47         int result = 0;
  48         struct acpi_bus_event event;
  49         static char str[ACPI_MAX_STRING];
  50         static int chars_remaining = 0;
  51         static char *ptr;
  52
  53         if (!chars_remaining) {
  54                 memset(&event, 0, sizeof(struct acpi_bus_event));
  55
  56                 if ((file->f_flags & O_NONBLOCK)
  57                     && (list_empty(&acpi_bus_event_list)))
  58                         return -EAGAIN;
  59
  60                 result = acpi_bus_receive_event(&event);
  61                 if (result)
  62                         return result;
  63
  64                 chars_remaining = sprintf(str, "%s %s %08x %08x\n",
  65                                           event.device_class ? event.
  66                                           device_class : "<unknown>",
  67                                           event.bus_id ? event.
  68                                           bus_id : "<unknown>", event.type,
  69                                           event.data);
  70                 ptr = str;
  71         }
  72
  73         if (chars_remaining < count) {
  74                 count = chars_remaining;
  75         }
  76
  77         if (copy_to_user(buffer, ptr, count))
  78                 return -EFAULT;
  79
  80         *ppos += count;
  81         chars_remaining -= count;
  82         ptr += count;
  83
  84         return count;
  85 }
  86
  87 static int acpi_system_close_event(struct inode *inode, struct file *file)
  88 {
  89         spin_lock_irq(&acpi_system_event_lock);
  90         event_is_open = 0;
  91         spin_unlock_irq(&acpi_system_event_lock);
  92         return 0;
  93 }
  94
  95 static unsigned int acpi_system_poll_event(struct file *file, poll_table * wait)
  96 {
  97         poll_wait(file, &acpi_bus_event_queue, wait);
  98         if (!list_empty(&acpi_bus_event_list))
  99                 return POLLIN | POLLRDNORM;
 100         return 0;
 101 }
 102
 103 static const struct file_operations acpi_system_event_ops = {
 104         .open = acpi_system_open_event,
 105         .read = acpi_system_read_event,
 106         .release = acpi_system_close_event,
 107         .poll = acpi_system_poll_event,
 108 };
 109
 110 #ifdef CONFIG_NET
 111 unsigned int acpi_event_seqnum;
 112 struct acpi_genl_event {
 113         acpi_device_class device_class;
 114         char bus_id[15];
 115         u32 type;
 116         u32 data;
 117 };
 118
 119 /* attributes of acpi_genl_family */
 120 enum {
 121         ACPI_GENL_ATTR_UNSPEC,
 122         ACPI_GENL_ATTR_EVENT,   /* ACPI event info needed by user space */
 123         __ACPI_GENL_ATTR_MAX,
 124 };
 125 #define ACPI_GENL_ATTR_MAX (__ACPI_GENL_ATTR_MAX - 1)
 126
 127 /* commands supported by the acpi_genl_family */
 128 enum {
 129         ACPI_GENL_CMD_UNSPEC,
 130         ACPI_GENL_CMD_EVENT,    /* kernel->user notifications for ACPI events */
 131         __ACPI_GENL_CMD_MAX,
 132 };
 133 #define ACPI_GENL_CMD_MAX (__ACPI_GENL_CMD_MAX - 1)
 134
 135 #define ACPI_GENL_NAME          "acpi_event"
 136 #define ACPI_GENL_VERSION       0x01
 137
 138 static struct genl_family acpi_event_genl_family = {
 139         .id = GENL_ID_GENERATE,
 140         .name = ACPI_GENL_NAME,
 141         .version = ACPI_GENL_VERSION,
 142         .maxattr = ACPI_GENL_ATTR_MAX,
 143 };
 144
 145 /* .doit: standard command callback */
 146 static int acpi_genl_cmd_event(struct sk_buff *skb, struct genl_info *info)
 147 {
 148         struct acpi_genl_event *event = info->userhdr;
 149
 150         if (!event)
 151                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "ACPI event: NULL\n"));
 152
 153         return 0;
 154 }
 155
 156 static struct genl_ops acpi_event_genl_ops = {
 157         .cmd = ACPI_GENL_CMD_EVENT,
 158         .doit = acpi_genl_cmd_event,
 159 };
 160
 161 int acpi_bus_generate_genetlink_event(struct acpi_device *device,
 162                                       u8 type, int data)
 163 {
 164         struct sk_buff *skb;
 165         struct nlattr *attr;
 166         struct acpi_genl_event *event;
 167         void *msg_header;
 168         int size;
 169         int result;
 170
 171         /* allocate memory */
 172         size = nla_total_size(sizeof(struct acpi_genl_event)) +
 173             nla_total_size(0);
 174
 175         skb = genlmsg_new(size, GFP_ATOMIC);
 176         if (!skb)
 177                 return -ENOMEM;
 178
 179         /* add the genetlink message header */
 180         msg_header = genlmsg_put(skb, 0, acpi_event_seqnum++,
 181                                  &acpi_event_genl_family, 0,
 182                                  ACPI_GENL_CMD_EVENT);
 183         if (!msg_header) {
 184                 nlmsg_free(skb);
 185                 return -ENOMEM;
 186         }
 187
 188         /* fill the data */
 189         attr =
 190             nla_reserve(skb, ACPI_GENL_ATTR_EVENT,
 191                         sizeof(struct acpi_genl_event));
 192         if (!attr) {
 193                 nlmsg_free(skb);
 194                 return -EINVAL;
 195         }
 196
 197         event = nla_data(attr);
 198         if (!event) {
 199                 nlmsg_free(skb);
 200                 return -EINVAL;
 201         }
 202
 203         memset(event, 0, sizeof(struct acpi_genl_event));
 204
 205         strcpy(event->device_class, device->pnp.device_class);
 206         strcpy(event->bus_id, device->dev.bus_id);
 207         event->type = type;
 208         event->data = data;
 209
 210         /* send multicast genetlink message */
 211         result = genlmsg_end(skb, msg_header);
 212         if (result < 0) {
 213                 nlmsg_free(skb);
 214                 return result;
 215         }
 216
 217         result =
 218             genlmsg_multicast(skb, 0, acpi_event_genl_family.id, GFP_ATOMIC);
 219         if (result)
 220                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 221                                   "Failed to send a Genetlink message!\n"));
 222         return 0;
 223 }
 224
 225 static int acpi_event_genetlink_init(void)
 226 {
 227         int result;
 228
 229         result = genl_register_family(&acpi_event_genl_family);
 230         if (result)
 231                 return result;
 232
 233         result =
 234             genl_register_ops(&acpi_event_genl_family, &acpi_event_genl_ops);
 235         if (result)
 236                 genl_unregister_family(&acpi_event_genl_family);
 237
 238         return result;
 239 }
 240
 241 #else
 242 int acpi_bus_generate_genetlink_event(struct acpi_device *device, u8 type,
 243                                       int data)
 244 {
 245         return 0;
 246 }
 247
 248 static int acpi_event_genetlink_init(void)
 249 {
 250         return -ENODEV;
 251 }
 252 #endif
 253
 254 static int __init acpi_event_init(void)
 255 {
 256         struct proc_dir_entry *entry;
 257         int error = 0;
 258
 259         if (acpi_disabled)
 260                 return 0;
 261
 262         /* create genetlink for acpi event */
 263         error = acpi_event_genetlink_init();
 264         if (error)
 265                 printk(KERN_WARNING PREFIX
 266                        "Failed to create genetlink family for ACPI event\n");
 267
 268         /* 'event' [R] */
 269         entry = create_proc_entry("event", S_IRUSR, acpi_root_dir);
 270         if (entry)
 271                 entry->proc_fops = &acpi_system_event_ops;
 272         else
 273                 return -ENODEV;
 274
 275         return 0;
 276 }
 277
 278 fs_initcall(acpi_event_init);