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  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/slab.h>
  25 #include <linux/init.h>
  26 #include <linux/types.h>
  27 #include <linux/dmi.h>
  28 #include <linux/delay.h>
  29 #ifdef CONFIG_ACPI_PROCFS_POWER
  30 #include <linux/proc_fs.h>
  31 #include <linux/seq_file.h>
  32 #endif
  33 #include <linux/platform_device.h>
  34 #include <linux/power_supply.h>
  35 #include <linux/acpi.h>
  36 #include <acpi/battery.h>
  37
  38 #define PREFIX "ACPI: "
  39
  40 #define ACPI_AC_CLASS                   "ac_adapter"
  41 #define ACPI_AC_DEVICE_NAME             "AC Adapter"
  42 #define ACPI_AC_FILE_STATE              "state"
  43 #define ACPI_AC_NOTIFY_STATUS           0x80
  44 #define ACPI_AC_STATUS_OFFLINE          0x00
  45 #define ACPI_AC_STATUS_ONLINE           0x01
  46 #define ACPI_AC_STATUS_UNKNOWN          0xFF
  47
  48 #define _COMPONENT              ACPI_AC_COMPONENT
  49 ACPI_MODULE_NAME("ac");
  50
  51 MODULE_AUTHOR("Paul Diefenbaugh");
  52 MODULE_DESCRIPTION("ACPI AC Adapter Driver");
  53 MODULE_LICENSE("GPL");
  54
  55
  56 static int acpi_ac_add(struct acpi_device *device);
  57 static int acpi_ac_remove(struct acpi_device *device);
  58 static void acpi_ac_notify(struct acpi_device *device, u32 event);
  59
  60 struct acpi_ac_bl {
  61         const char *hid;
  62         int hrv;
  63 };
  64
  65 static const struct acpi_device_id ac_device_ids[] = {
  66         {"ACPI0003", 0},
  67         {"", 0},
  68 };
  69 MODULE_DEVICE_TABLE(acpi, ac_device_ids);
  70
  71 /* Lists of PMIC ACPI HIDs with an (often better) native charger driver */
  72 static const struct acpi_ac_bl acpi_ac_blacklist[] = {
  73         { "INT33F4", -1 }, /* X-Powers AXP288 PMIC */
  74         { "INT34D3",  3 }, /* Intel Cherrytrail Whiskey Cove PMIC */
  75 };
  76
  77 #ifdef CONFIG_PM_SLEEP
  78 static int acpi_ac_resume(struct device *dev);
  79 #endif
  80 static SIMPLE_DEV_PM_OPS(acpi_ac_pm, NULL, acpi_ac_resume);
  81
  82 #ifdef CONFIG_ACPI_PROCFS_POWER
  83 extern struct proc_dir_entry *acpi_lock_ac_dir(void);
  84 extern void *acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
  85 #endif
  86
  87
  88 static int ac_sleep_before_get_state_ms;
  89 static int ac_check_pmic = 1;
  90
  91 static struct acpi_driver acpi_ac_driver = {
  92         .name = "ac",
  93         .class = ACPI_AC_CLASS,
  94         .ids = ac_device_ids,
  95         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
  96         .ops = {
  97                 .add = acpi_ac_add,
  98                 .remove = acpi_ac_remove,
  99                 .notify = acpi_ac_notify,
 100                 },
 101         .drv.pm = &acpi_ac_pm,
 102 };
 103
 104 struct acpi_ac {
 105         struct power_supply *charger;
 106         struct power_supply_desc charger_desc;
 107         struct acpi_device * device;
 108         unsigned long long state;
 109         struct notifier_block battery_nb;
 110 };
 111
 112 #define to_acpi_ac(x) power_supply_get_drvdata(x)
 113
 114 /* --------------------------------------------------------------------------
 115                                AC Adapter Management
 116    -------------------------------------------------------------------------- */
 117
 118 static int acpi_ac_get_state(struct acpi_ac *ac)
 119 {
 120         acpi_status status = AE_OK;
 121
 122         if (!ac)
 123                 return -EINVAL;
 124
 125         status = acpi_evaluate_integer(ac->device->handle, "_PSR", NULL,
 126                                        &ac->state);
 127         if (ACPI_FAILURE(status)) {
 128                 ACPI_EXCEPTION((AE_INFO, status,
 129                                 "Error reading AC Adapter state"));
 130                 ac->state = ACPI_AC_STATUS_UNKNOWN;
 131                 return -ENODEV;
 132         }
 133
 134         return 0;
 135 }
 136
 137 /* --------------------------------------------------------------------------
 138                             sysfs I/F
 139    -------------------------------------------------------------------------- */
 140 static int get_ac_property(struct power_supply *psy,
 141                            enum power_supply_property psp,
 142                            union power_supply_propval *val)
 143 {
 144         struct acpi_ac *ac = to_acpi_ac(psy);
 145
 146         if (!ac)
 147                 return -ENODEV;
 148
 149         if (acpi_ac_get_state(ac))
 150                 return -ENODEV;
 151
 152         switch (psp) {
 153         case POWER_SUPPLY_PROP_ONLINE:
 154                 val->intval = ac->state;
 155                 break;
 156         default:
 157                 return -EINVAL;
 158         }
 159         return 0;
 160 }
 161
 162 static enum power_supply_property ac_props[] = {
 163         POWER_SUPPLY_PROP_ONLINE,
 164 };
 165
 166 #ifdef CONFIG_ACPI_PROCFS_POWER
 167 /* --------------------------------------------------------------------------
 168                               FS Interface (/proc)
 169    -------------------------------------------------------------------------- */
 170
 171 static struct proc_dir_entry *acpi_ac_dir;
 172
 173 static int acpi_ac_seq_show(struct seq_file *seq, void *offset)
 174 {
 175         struct acpi_ac *ac = seq->private;
 176
 177
 178         if (!ac)
 179                 return 0;
 180
 181         if (acpi_ac_get_state(ac)) {
 182                 seq_puts(seq, "ERROR: Unable to read AC Adapter state\n");
 183                 return 0;
 184         }
 185
 186         seq_puts(seq, "state:                   ");
 187         switch (ac->state) {
 188         case ACPI_AC_STATUS_OFFLINE:
 189                 seq_puts(seq, "off-line\n");
 190                 break;
 191         case ACPI_AC_STATUS_ONLINE:
 192                 seq_puts(seq, "on-line\n");
 193                 break;
 194         default:
 195                 seq_puts(seq, "unknown\n");
 196                 break;
 197         }
 198
 199         return 0;
 200 }
 201
 202 static int acpi_ac_add_fs(struct acpi_ac *ac)
 203 {
 204         struct proc_dir_entry *entry = NULL;
 205
 206         printk(KERN_WARNING PREFIX "Deprecated procfs I/F for AC is loaded,"
 207                         " please retry with CONFIG_ACPI_PROCFS_POWER cleared\n");
 208         if (!acpi_device_dir(ac->device)) {
 209                 acpi_device_dir(ac->device) =
 210                         proc_mkdir(acpi_device_bid(ac->device), acpi_ac_dir);
 211                 if (!acpi_device_dir(ac->device))
 212                         return -ENODEV;
 213         }
 214
 215         /* 'state' [R] */
 216         entry = proc_create_single_data(ACPI_AC_FILE_STATE, S_IRUGO,
 217                         acpi_device_dir(ac->device), acpi_ac_seq_show, ac);
 218         if (!entry)
 219                 return -ENODEV;
 220         return 0;
 221 }
 222
 223 static int acpi_ac_remove_fs(struct acpi_ac *ac)
 224 {
 225
 226         if (acpi_device_dir(ac->device)) {
 227                 remove_proc_entry(ACPI_AC_FILE_STATE,
 228                                   acpi_device_dir(ac->device));
 229                 remove_proc_entry(acpi_device_bid(ac->device), acpi_ac_dir);
 230                 acpi_device_dir(ac->device) = NULL;
 231         }
 232
 233         return 0;
 234 }
 235 #endif
 236
 237 /* --------------------------------------------------------------------------
 238                                    Driver Model
 239    -------------------------------------------------------------------------- */
 240
 241 static void acpi_ac_notify(struct acpi_device *device, u32 event)
 242 {
 243         struct acpi_ac *ac = acpi_driver_data(device);
 244
 245         if (!ac)
 246                 return;
 247
 248         switch (event) {
 249         default:
 250                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 251                                   "Unsupported event [0x%x]\n", event));
 252         /* fall through */
 253         case ACPI_AC_NOTIFY_STATUS:
 254         case ACPI_NOTIFY_BUS_CHECK:
 255         case ACPI_NOTIFY_DEVICE_CHECK:
 256                 /*
 257                  * A buggy BIOS may notify AC first and then sleep for
 258                  * a specific time before doing actual operations in the
 259                  * EC event handler (_Qxx). This will cause the AC state
 260                  * reported by the ACPI event to be incorrect, so wait for a
 261                  * specific time for the EC event handler to make progress.
 262                  */
 263                 if (ac_sleep_before_get_state_ms > 0)
 264                         msleep(ac_sleep_before_get_state_ms);
 265
 266                 acpi_ac_get_state(ac);
 267                 acpi_bus_generate_netlink_event(device->pnp.device_class,
 268                                                   dev_name(&device->dev), event,
 269                                                   (u32) ac->state);
 270                 acpi_notifier_call_chain(device, event, (u32) ac->state);
 271                 kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
 272         }
 273
 274         return;
 275 }
 276
 277 static int acpi_ac_battery_notify(struct notifier_block *nb,
 278                                   unsigned long action, void *data)
 279 {
 280         struct acpi_ac *ac = container_of(nb, struct acpi_ac, battery_nb);
 281         struct acpi_bus_event *event = (struct acpi_bus_event *)data;
 282
 283         /*
 284          * On HP Pavilion dv6-6179er AC status notifications aren't triggered
 285          * when adapter is plugged/unplugged. However, battery status
 286          * notifcations are triggered when battery starts charging or
 287          * discharging. Re-reading AC status triggers lost AC notifications,
 288          * if AC status has changed.
 289          */
 290         if (strcmp(event->device_class, ACPI_BATTERY_CLASS) == 0 &&
 291             event->type == ACPI_BATTERY_NOTIFY_STATUS)
 292                 acpi_ac_get_state(ac);
 293
 294         return NOTIFY_OK;
 295 }
 296
 297 static int __init thinkpad_e530_quirk(const struct dmi_system_id *d)
 298 {
 299         ac_sleep_before_get_state_ms = 1000;
 300         return 0;
 301 }
 302
 303 static int __init ac_do_not_check_pmic_quirk(const struct dmi_system_id *d)
 304 {
 305         ac_check_pmic = 0;
 306         return 0;
 307 }
 308
 309 static const struct dmi_system_id ac_dmi_table[]  __initconst = {
 310         {
 311         /* Thinkpad e530 */
 312         .callback = thinkpad_e530_quirk,
 313         .matches = {
 314                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 315                 DMI_MATCH(DMI_PRODUCT_NAME, "32597CG"),
 316                 },
 317         },
 318         {
 319                 /* ECS EF20EA */
 320                 .callback = ac_do_not_check_pmic_quirk,
 321                 .matches = {
 322                         DMI_MATCH(DMI_PRODUCT_NAME, "EF20EA"),
 323                 },
 324         },
 325         {
 326                 /* Lenovo Ideapad Miix 320 */
 327                 .callback = ac_do_not_check_pmic_quirk,
 328                 .matches = {
 329                   DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 330                   DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "80XF"),
 331                   DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "Lenovo MIIX 320-10ICR"),
 332                 },
 333         },
 334         {},
 335 };
 336
 337 static int acpi_ac_add(struct acpi_device *device)
 338 {
 339         struct power_supply_config psy_cfg = {};
 340         int result = 0;
 341         struct acpi_ac *ac = NULL;
 342
 343
 344         if (!device)
 345                 return -EINVAL;
 346
 347         ac = kzalloc(sizeof(struct acpi_ac), GFP_KERNEL);
 348         if (!ac)
 349                 return -ENOMEM;
 350
 351         ac->device = device;
 352         strcpy(acpi_device_name(device), ACPI_AC_DEVICE_NAME);
 353         strcpy(acpi_device_class(device), ACPI_AC_CLASS);
 354         device->driver_data = ac;
 355
 356         result = acpi_ac_get_state(ac);
 357         if (result)
 358                 goto end;
 359
 360         psy_cfg.drv_data = ac;
 361
 362         ac->charger_desc.name = acpi_device_bid(device);
 363 #ifdef CONFIG_ACPI_PROCFS_POWER
 364         result = acpi_ac_add_fs(ac);
 365         if (result)
 366                 goto end;
 367 #endif
 368         ac->charger_desc.type = POWER_SUPPLY_TYPE_MAINS;
 369         ac->charger_desc.properties = ac_props;
 370         ac->charger_desc.num_properties = ARRAY_SIZE(ac_props);
 371         ac->charger_desc.get_property = get_ac_property;
 372         ac->charger = power_supply_register(&ac->device->dev,
 373                                             &ac->charger_desc, &psy_cfg);
 374         if (IS_ERR(ac->charger)) {
 375                 result = PTR_ERR(ac->charger);
 376                 goto end;
 377         }
 378
 379         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
 380                acpi_device_name(device), acpi_device_bid(device),
 381                ac->state ? "on-line" : "off-line");
 382
 383         ac->battery_nb.notifier_call = acpi_ac_battery_notify;
 384         register_acpi_notifier(&ac->battery_nb);
 385 end:
 386         if (result) {
 387 #ifdef CONFIG_ACPI_PROCFS_POWER
 388                 acpi_ac_remove_fs(ac);
 389 #endif
 390                 kfree(ac);
 391         }
 392
 393         return result;
 394 }
 395
 396 #ifdef CONFIG_PM_SLEEP
 397 static int acpi_ac_resume(struct device *dev)
 398 {
 399         struct acpi_ac *ac;
 400         unsigned old_state;
 401
 402         if (!dev)
 403                 return -EINVAL;
 404
 405         ac = acpi_driver_data(to_acpi_device(dev));
 406         if (!ac)
 407                 return -EINVAL;
 408
 409         old_state = ac->state;
 410         if (acpi_ac_get_state(ac))
 411                 return 0;
 412         if (old_state != ac->state)
 413                 kobject_uevent(&ac->charger->dev.kobj, KOBJ_CHANGE);
 414         return 0;
 415 }
 416 #else
 417 #define acpi_ac_resume NULL
 418 #endif
 419
 420 static int acpi_ac_remove(struct acpi_device *device)
 421 {
 422         struct acpi_ac *ac = NULL;
 423
 424
 425         if (!device || !acpi_driver_data(device))
 426                 return -EINVAL;
 427
 428         ac = acpi_driver_data(device);
 429
 430         power_supply_unregister(ac->charger);
 431         unregister_acpi_notifier(&ac->battery_nb);
 432
 433 #ifdef CONFIG_ACPI_PROCFS_POWER
 434         acpi_ac_remove_fs(ac);
 435 #endif
 436
 437         kfree(ac);
 438
 439         return 0;
 440 }
 441
 442 static int __init acpi_ac_init(void)
 443 {
 444         unsigned int i;
 445         int result;
 446
 447         if (acpi_disabled)
 448                 return -ENODEV;
 449
 450         dmi_check_system(ac_dmi_table);
 451
 452         if (ac_check_pmic) {
 453                 for (i = 0; i < ARRAY_SIZE(acpi_ac_blacklist); i++)
 454                         if (acpi_dev_present(acpi_ac_blacklist[i].hid, "1",
 455                                              acpi_ac_blacklist[i].hrv)) {
 456                                 pr_info(PREFIX "AC: found native %s PMIC, not loading\n",
 457                                         acpi_ac_blacklist[i].hid);
 458                                 return -ENODEV;
 459                         }
 460         }
 461
 462 #ifdef CONFIG_ACPI_PROCFS_POWER
 463         acpi_ac_dir = acpi_lock_ac_dir();
 464         if (!acpi_ac_dir)
 465                 return -ENODEV;
 466 #endif
 467
 468
 469         result = acpi_bus_register_driver(&acpi_ac_driver);
 470         if (result < 0) {
 471 #ifdef CONFIG_ACPI_PROCFS_POWER
 472                 acpi_unlock_ac_dir(acpi_ac_dir);
 473 #endif
 474                 return -ENODEV;
 475         }
 476
 477         return 0;
 478 }
 479
 480 static void __exit acpi_ac_exit(void)
 481 {
 482         acpi_bus_unregister_driver(&acpi_ac_driver);
 483 #ifdef CONFIG_ACPI_PROCFS_POWER
 484         acpi_unlock_ac_dir(acpi_ac_dir);
 485 #endif
 486 }
 487 module_init(acpi_ac_init);
 488 module_exit(acpi_ac_exit);