drivers/acpi/ac.c

   1 /*
   2  *  acpi_ac.c - ACPI AC Adapter Driver ($Revision: 27 $)
   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  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or (at
  12  *  your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful, but
  15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License along
  20  *  with this program; if not, write to the Free Software Foundation, Inc.,
  21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  22  *
  23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/slab.h>
  29 #include <linux/init.h>
  30 #include <linux/types.h>
  31 #ifdef CONFIG_ACPI_PROCFS_POWER
  32 #include <linux/proc_fs.h>
  33 #include <linux/seq_file.h>
  34 #endif
  35 #include <linux/power_supply.h>
  36 #include <acpi/acpi_bus.h>
  37 #include <acpi/acpi_drivers.h>
  38
  39 #define PREFIX "ACPI: "
  40
  41 #define ACPI_AC_CLASS                   "ac_adapter"
  42 #define ACPI_AC_DEVICE_NAME             "AC Adapter"
  43 #define ACPI_AC_FILE_STATE              "state"
  44 #define ACPI_AC_NOTIFY_STATUS           0x80
  45 #define ACPI_AC_STATUS_OFFLINE          0x00
  46 #define ACPI_AC_STATUS_ONLINE           0x01
  47 #define ACPI_AC_STATUS_UNKNOWN          0xFF
  48
  49 #define _COMPONENT              ACPI_AC_COMPONENT
  50 ACPI_MODULE_NAME("ac");
  51
  52 MODULE_AUTHOR("Paul Diefenbaugh");
  53 MODULE_DESCRIPTION("ACPI AC Adapter Driver");
  54 MODULE_LICENSE("GPL");
  55
  56 #ifdef CONFIG_ACPI_PROCFS_POWER
  57 extern struct proc_dir_entry *acpi_lock_ac_dir(void);
  58 extern void *acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
  59 static int acpi_ac_open_fs(struct inode *inode, struct file *file);
  60 #endif
  61
  62 static int acpi_ac_add(struct acpi_device *device);
  63 static int acpi_ac_remove(struct acpi_device *device, int type);
  64 static void acpi_ac_notify(struct acpi_device *device, u32 event);
  65
  66 static const struct acpi_device_id ac_device_ids[] = {
  67         {"ACPI0003", 0},
  68         {"", 0},
  69 };
  70 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
  71
  72 static int acpi_ac_resume(struct device *dev);
  73 static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
  74
  75 static struct acpi_driver acpi_ac_driver = {
  76         .name = "ac",
  77         .class = ACPI_AC_CLASS,
  78         .ids = ac_device_ids,
  79         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
  80         .ops = {
  81                 .add = acpi_ac_add,
  82                 .remove = acpi_ac_remove,
  83                 .notify = acpi_ac_notify,
  84                 },
  85         .drv.pm = &acpi_ac_pm,
  86 };
  87
  88 struct acpi_ac {
  89         struct power_supply charger;
  90         struct acpi_device * device;
  91         unsigned long long state;
  92 };
  93
  94 #define to_acpi_ac(x) container_of(x, struct acpi_ac, charger)
  95
  96 #ifdef CONFIG_ACPI_PROCFS_POWER
  97 static const struct file_operations acpi_ac_fops = {
  98         .owner = THIS_MODULE,
  99         .open = acpi_ac_open_fs,
 100         .read = seq_read,
 101         .llseek = seq_lseek,
 102         .release = single_release,
 103 };
 104 #endif
 105
 106 /* --------------------------------------------------------------------------
 107                                AC Adapter Management
 108    -------------------------------------------------------------------------- */
 109
 110 static int acpi_ac_get_state(struct acpi_ac *ac)
 111 {
 112         acpi_status status = AE_OK;
 113
 114
 115         if (!ac)
 116                 return -EINVAL;
 117
 118         status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL, &ac->state);
 119         if (ACPI_FAILURE(status)) {
 120                 ACPI_EXCEPTION((AE_INFO, status, "Error reading AC Adapter state"));
 121                 ac->state = ACPI_AC_STATUS_UNKNOWN;
 122                 return -ENODEV;
 123         }
 124
 125         return 0;
 126 }
 127
 128 /* --------------------------------------------------------------------------
 129                             sysfs I/F
 130    -------------------------------------------------------------------------- */
 131 static int get_ac_property(struct power_supply *psy,
 132                            enum power_supply_property psp,
 133                            union power_supply_propval *val)
 134 {
 135         struct acpi_ac *ac = to_acpi_ac(psy);
 136
 137         if (!ac)
 138                 return -ENODEV;
 139
 140         if (acpi_ac_get_state(ac))
 141                 return -ENODEV;
 142
 143         switch (psp) {
 144         case POWER_SUPPLY_PROP_ONLINE:
 145                 val->intval = ac->state;
 146                 break;
 147         default:
 148                 return -EINVAL;
 149         }
 150         return 0;
 151 }
 152
 153 static enum power_supply_property ac_props[] = {
 154         POWER_SUPPLY_PROP_ONLINE,
 155 };
 156
 157 #ifdef CONFIG_ACPI_PROCFS_POWER
 158 /* --------------------------------------------------------------------------
 159                               FS Interface (/proc)
 160    -------------------------------------------------------------------------- */
 161
 162 static struct proc_dir_entry *acpi_ac_dir;
 163
 164 static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
 165 {
 166         struct acpi_ac *ac = seq->private;
 167
 168
 169         if (!ac)
 170                 return 0;
 171
 172         if (acpi_ac_get_state(ac)) {
 173                 seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");
 174                 return 0;
 175         }
 176
 177         seq_puts(seq, "state:                   ");
 178         switch (ac->state) {
 179         case ACPI_AC_STATUS_OFFLINE:
 180                 seq_puts(seq, "off-line\n");
 181                 break;
 182         case ACPI_AC_STATUS_ONLINE:
 183                 seq_puts(seq, "on-line\n");
 184                 break;
 185         default:
 186                 seq_puts(seq, "unknown\n");
 187                 break;
 188         }
 189
 190         return 0;
 191 }
 192
 193 static int acpi_ac_open_fs(struct inode *inode, struct file *file)
 194 {
 195         return single_open(file, acpi_ac_seq_show, PDE(inode)->data);
 196 }
 197
 198 static int acpi_ac_add_fs(struct acpi_device *device)
 199 {
 200         struct proc_dir_entry *entry = NULL;
 201
 202         printk(KERN_WARNING PREFIX "Deprecated procfs I/F for AC is loaded,"
 203                         " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
 204         if (!acpi_device_dir(device)) {
 205                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 206                                                      acpi_ac_dir);
 207                 if (!acpi_device_dir(device))
 208                         return -ENODEV;
 209         }
 210
 211         /* 'state' [R] */
 212         entry = proc_create_data(ACPI_AC_FILE_STATE,
 213                                  S_IRUGO, acpi_device_dir(device),
 214                                  &acpi_ac_fops, acpi_driver_data(device));
 215         if (!entry)
 216                 return -ENODEV;
 217         return 0;
 218 }
 219
 220 static int acpi_ac_remove_fs(struct acpi_device *device)
 221 {
 222
 223         if (acpi_device_dir(device)) {
 224                 remove_proc_entry(ACPI_AC_FILE_STATE, acpi_device_dir(device));
 225
 226                 remove_proc_entry(acpi_device_bid(device), acpi_ac_dir);
 227                 acpi_device_dir(device) = NULL;
 228         }
 229
 230         return 0;
 231 }
 232 #endif
 233
 234 /* --------------------------------------------------------------------------
 235                                    Driver Model
 236    -------------------------------------------------------------------------- */
 237
 238 static void acpi_ac_notify(struct acpi_device *device, u32 event)
 239 {
 240         struct acpi_ac *ac = acpi_driver_data(device);
 241
 242
 243         if (!ac)
 244                 return;
 245
 246         switch (event) {
 247         default:
 248                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 249                                   "Unsupported event [0x%x]\n", event));
 250         case ACPI_AC_NOTIFY_STATUS:
 251         case ACPI_NOTIFY_BUS_CHECK:
 252         case ACPI_NOTIFY_DEVICE_CHECK:
 253                 acpi_ac_get_state(ac);
 254                 acpi_bus_generate_proc_event(device, event, (u32) ac->state);
 255                 acpi_bus_generate_netlink_event(device->pnp.device_class,
 256                                                   dev_name(&device->dev), event,
 257                                                   (u32) ac->state);
 258                 acpi_notifier_call_chain(device, event, (u32) ac->state);
 259                 kobject_uevent(&ac->charger.dev->kobj, KOBJ_CHANGE);
 260         }
 261
 262         return;
 263 }
 264
 265 static int acpi_ac_add(struct acpi_device *device)
 266 {
 267         int result = 0;
 268         struct acpi_ac *ac = NULL;
 269
 270
 271         if (!device)
 272                 return -EINVAL;
 273
 274         ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
 275         if (!ac)
 276                 return -ENOMEM;
 277
 278         ac->device = device;
 279         strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
 280         strcpy(acpi_device_class(device), ACPI_AC_CLASS);
 281         device->driver_data = ac;
 282
 283         result = acpi_ac_get_state(ac);
 284         if (result)
 285                 goto end;
 286
 287 #ifdef CONFIG_ACPI_PROCFS_POWER
 288         result = acpi_ac_add_fs(device);
 289 #endif
 290         if (result)
 291                 goto end;
 292         ac->charger.name = acpi_device_bid(device);
 293         ac->charger.type = POWER_SUPPLY_TYPE_MAINS;
 294         ac->charger.properties = ac_props;
 295         ac->charger.num_properties = ARRAY_SIZE(ac_props);
 296         ac->charger.get_property = get_ac_property;
 297         power_supply_register(&ac->device->dev, &ac->charger);
 298
 299         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
 300                acpi_device_name(device), acpi_device_bid(device),
 301                ac->state ? "on-line" : "off-line");
 302
 303       end:
 304         if (result) {
 305 #ifdef CONFIG_ACPI_PROCFS_POWER
 306                 acpi_ac_remove_fs(device);
 307 #endif
 308                 kfree(ac);
 309         }
 310
 311         return result;
 312 }
 313
 314 static int acpi_ac_resume(struct device *dev)
 315 {
 316         struct acpi_ac *ac;
 317         unsigned old_state;
 318
 319         if (!dev)
 320                 return -EINVAL;
 321
 322         ac = acpi_driver_data(to_acpi_device(dev));
 323         if (!ac)
 324                 return -EINVAL;
 325
 326         old_state = ac->state;
 327         if (acpi_ac_get_state(ac))
 328                 return 0;
 329         if (old_state != ac->state)
 330                 kobject_uevent(&ac->charger.dev->kobj, KOBJ_CHANGE);
 331         return 0;
 332 }
 333
 334 static int acpi_ac_remove(struct acpi_device *device, int type)
 335 {
 336         struct acpi_ac *ac = NULL;
 337
 338
 339         if (!device || !acpi_driver_data(device))
 340                 return -EINVAL;
 341
 342         ac = acpi_driver_data(device);
 343
 344         if (ac->charger.dev)
 345                 power_supply_unregister(&ac->charger);
 346 #ifdef CONFIG_ACPI_PROCFS_POWER
 347         acpi_ac_remove_fs(device);
 348 #endif
 349
 350         kfree(ac);
 351
 352         return 0;
 353 }
 354
 355 static int __init acpi_ac_init(void)
 356 {
 357         int result;
 358
 359         if (acpi_disabled)
 360                 return -ENODEV;
 361
 362 #ifdef CONFIG_ACPI_PROCFS_POWER
 363         acpi_ac_dir = acpi_lock_ac_dir();
 364         if (!acpi_ac_dir)
 365                 return -ENODEV;
 366 #endif
 367
 368         result = acpi_bus_register_driver(&acpi_ac_driver);
 369         if (result < 0) {
 370 #ifdef CONFIG_ACPI_PROCFS_POWER
 371                 acpi_unlock_ac_dir(acpi_ac_dir);
 372 #endif
 373                 return -ENODEV;
 374         }
 375
 376         return 0;
 377 }
 378
 379 static void __exit acpi_ac_exit(void)
 380 {
 381
 382         acpi_bus_unregister_driver(&acpi_ac_driver);
 383
 384 #ifdef CONFIG_ACPI_PROCFS_POWER
 385         acpi_unlock_ac_dir(acpi_ac_dir);
 386 #endif
 387
 388         return;
 389 }
 390
 391 module_init(acpi_ac_init);
 392 module_exit(acpi_ac_exit);