drivers/acpi/ec_sys.c

   1 /*
   2  * ec_sys.c
   3  *
   4  * Copyright (C) 2010 SUSE Products GmbH/Novell
   5  * Author:
   6  *      Thomas Renninger <trenn@suse.de>
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/acpi.h>
  13 #include <linux/debugfs.h>
  14 #include <linux/module.h>
  15 #include <linux/uaccess.h>
  16 #include "internal.h"
  17
  18 MODULE_AUTHOR("Thomas Renninger <trenn@suse.de>");
  19 MODULE_DESCRIPTION("ACPI EC sysfs access driver");
  20 MODULE_LICENSE("GPL");
  21
  22 static bool write_support;
  23 module_param(write_support, bool, 0644);
  24 MODULE_PARM_DESC(write_support, "Dangerous, reboot and removal of battery may "
  25                  "be needed.");
  26
  27 #define EC_SPACE_SIZE 256
  28
  29 static struct dentry *acpi_ec_debugfs_dir;
  30
  31 static int acpi_ec_open_io(struct inode *i, struct file *f)
  32 {
  33         f->private_data = i->i_private;
  34         return 0;
  35 }
  36
  37 static ssize_t acpi_ec_read_io(struct file *f, char __user *buf,
  38                                size_t count, loff_t *off)
  39 {
  40         /* Use this if support reading/writing multiple ECs exists in ec.c:
  41          * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  42          */
  43         unsigned int size = EC_SPACE_SIZE;
  44         loff_t init_off = *off;
  45         int err = 0;
  46
  47         if (*off >= size)
  48                 return 0;
  49         if (*off + count >= size) {
  50                 size -= *off;
  51                 count = size;
  52         } else
  53                 size = count;
  54
  55         while (size) {
  56                 u8 byte_read;
  57                 err = ec_read(*off, &byte_read);
  58                 if (err)
  59                         return err;
  60                 if (put_user(byte_read, buf + *off - init_off)) {
  61                         if (*off - init_off)
  62                                 return *off - init_off; /* partial read */
  63                         return -EFAULT;
  64                 }
  65                 *off += 1;
  66                 size--;
  67         }
  68         return count;
  69 }
  70
  71 static ssize_t acpi_ec_write_io(struct file *f, const char __user *buf,
  72                                 size_t count, loff_t *off)
  73 {
  74         /* Use this if support reading/writing multiple ECs exists in ec.c:
  75          * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  76          */
  77
  78         unsigned int size = count;
  79         loff_t init_off = *off;
  80         int err = 0;
  81
  82         if (*off >= EC_SPACE_SIZE)
  83                 return 0;
  84         if (*off + count >= EC_SPACE_SIZE) {
  85                 size = EC_SPACE_SIZE - *off;
  86                 count = size;
  87         }
  88
  89         while (size) {
  90                 u8 byte_write;
  91                 if (get_user(byte_write, buf + *off - init_off)) {
  92                         if (*off - init_off)
  93                                 return *off - init_off; /* partial write */
  94                         return -EFAULT;
  95                 }
  96                 err = ec_write(*off, byte_write);
  97                 if (err)
  98                         return err;
  99
 100                 *off += 1;
 101                 size--;
 102         }
 103         return count;
 104 }
 105
 106 static const struct file_operations acpi_ec_io_ops = {
 107         .owner = THIS_MODULE,
 108         .open  = acpi_ec_open_io,
 109         .read  = acpi_ec_read_io,
 110         .write = acpi_ec_write_io,
 111         .llseek = default_llseek,
 112 };
 113
 114 int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
 115 {
 116         struct dentry *dev_dir;
 117         char name[64];
 118         umode_t mode = 0400;
 119
 120         if (ec_device_count == 0) {
 121                 acpi_ec_debugfs_dir = debugfs_create_dir("ec", NULL);
 122                 if (!acpi_ec_debugfs_dir)
 123                         return -ENOMEM;
 124         }
 125
 126         sprintf(name, "ec%u", ec_device_count);
 127         dev_dir = debugfs_create_dir(name, acpi_ec_debugfs_dir);
 128         if (!dev_dir) {
 129                 if (ec_device_count != 0)
 130                         goto error;
 131                 return -ENOMEM;
 132         }
 133
 134         if (!debugfs_create_x32("gpe", 0444, dev_dir, (u32 *)&first_ec->gpe))
 135                 goto error;
 136         if (!debugfs_create_bool("use_global_lock", 0444, dev_dir,
 137                                  (u32 *)&first_ec->global_lock))
 138                 goto error;
 139
 140         if (write_support)
 141                 mode = 0600;
 142         if (!debugfs_create_file("io", mode, dev_dir, ec, &acpi_ec_io_ops))
 143                 goto error;
 144
 145         return 0;
 146
 147 error:
 148         debugfs_remove_recursive(acpi_ec_debugfs_dir);
 149         return -ENOMEM;
 150 }
 151
 152 static int __init acpi_ec_sys_init(void)
 153 {
 154         int err = 0;
 155         if (first_ec)
 156                 err = acpi_ec_add_debugfs(first_ec, 0);
 157         else
 158                 err = -ENODEV;
 159         return err;
 160 }
 161
 162 static void __exit acpi_ec_sys_exit(void)
 163 {
 164         debugfs_remove_recursive(acpi_ec_debugfs_dir);
 165 }
 166
 167 module_init(acpi_ec_sys_init);
 168 module_exit(acpi_ec_sys_exit);