drivers/platform/x86/eeepc-laptop.c

   1 /*
   2  *  eeepc-laptop.c - Asus Eee PC extras
   3  *
   4  *  Based on asus_acpi.c as patched for the Eee PC by Asus:
   5  *  ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
   6  *  Based on eee.c from eeepc-linux
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  */
  18
  19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/types.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/backlight.h>
  27 #include <linux/fb.h>
  28 #include <linux/hwmon.h>
  29 #include <linux/hwmon-sysfs.h>
  30 #include <linux/slab.h>
  31 #include <acpi/acpi_drivers.h>
  32 #include <acpi/acpi_bus.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/input.h>
  35 #include <linux/input/sparse-keymap.h>
  36 #include <linux/rfkill.h>
  37 #include <linux/pci.h>
  38 #include <linux/pci_hotplug.h>
  39 #include <linux/leds.h>
  40 #include <linux/dmi.h>
  41
  42 #define EEEPC_LAPTOP_VERSION    "0.1"
  43 #define EEEPC_LAPTOP_NAME       "Eee PC Hotkey Driver"
  44 #define EEEPC_LAPTOP_FILE       "eeepc"
  45
  46 #define EEEPC_ACPI_CLASS        "hotkey"
  47 #define EEEPC_ACPI_DEVICE_NAME  "Hotkey"
  48 #define EEEPC_ACPI_HID          "ASUS010"
  49
  50 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
  51 MODULE_DESCRIPTION(EEEPC_LAPTOP_NAME);
  52 MODULE_LICENSE("GPL");
  53
  54 static bool hotplug_disabled;
  55
  56 module_param(hotplug_disabled, bool, 0444);
  57 MODULE_PARM_DESC(hotplug_disabled,
  58                  "Disable hotplug for wireless device. "
  59                  "If your laptop need that, please report to "
  60                  "acpi4asus-user@lists.sourceforge.net.");
  61
  62 /*
  63  * Definitions for Asus EeePC
  64  */
  65 #define NOTIFY_BRN_MIN  0x20
  66 #define NOTIFY_BRN_MAX  0x2f
  67
  68 enum {
  69         DISABLE_ASL_WLAN = 0x0001,
  70         DISABLE_ASL_BLUETOOTH = 0x0002,
  71         DISABLE_ASL_IRDA = 0x0004,
  72         DISABLE_ASL_CAMERA = 0x0008,
  73         DISABLE_ASL_TV = 0x0010,
  74         DISABLE_ASL_GPS = 0x0020,
  75         DISABLE_ASL_DISPLAYSWITCH = 0x0040,
  76         DISABLE_ASL_MODEM = 0x0080,
  77         DISABLE_ASL_CARDREADER = 0x0100,
  78         DISABLE_ASL_3G = 0x0200,
  79         DISABLE_ASL_WIMAX = 0x0400,
  80         DISABLE_ASL_HWCF = 0x0800
  81 };
  82
  83 enum {
  84         CM_ASL_WLAN = 0,
  85         CM_ASL_BLUETOOTH,
  86         CM_ASL_IRDA,
  87         CM_ASL_1394,
  88         CM_ASL_CAMERA,
  89         CM_ASL_TV,
  90         CM_ASL_GPS,
  91         CM_ASL_DVDROM,
  92         CM_ASL_DISPLAYSWITCH,
  93         CM_ASL_PANELBRIGHT,
  94         CM_ASL_BIOSFLASH,
  95         CM_ASL_ACPIFLASH,
  96         CM_ASL_CPUFV,
  97         CM_ASL_CPUTEMPERATURE,
  98         CM_ASL_FANCPU,
  99         CM_ASL_FANCHASSIS,
 100         CM_ASL_USBPORT1,
 101         CM_ASL_USBPORT2,
 102         CM_ASL_USBPORT3,
 103         CM_ASL_MODEM,
 104         CM_ASL_CARDREADER,
 105         CM_ASL_3G,
 106         CM_ASL_WIMAX,
 107         CM_ASL_HWCF,
 108         CM_ASL_LID,
 109         CM_ASL_TYPE,
 110         CM_ASL_PANELPOWER,      /*P901*/
 111         CM_ASL_TPD
 112 };
 113
 114 static const char *cm_getv[] = {
 115         "WLDG", "BTHG", NULL, NULL,
 116         "CAMG", NULL, NULL, NULL,
 117         NULL, "PBLG", NULL, NULL,
 118         "CFVG", NULL, NULL, NULL,
 119         "USBG", NULL, NULL, "MODG",
 120         "CRDG", "M3GG", "WIMG", "HWCF",
 121         "LIDG", "TYPE", "PBPG", "TPDG"
 122 };
 123
 124 static const char *cm_setv[] = {
 125         "WLDS", "BTHS", NULL, NULL,
 126         "CAMS", NULL, NULL, NULL,
 127         "SDSP", "PBLS", "HDPS", NULL,
 128         "CFVS", NULL, NULL, NULL,
 129         "USBG", NULL, NULL, "MODS",
 130         "CRDS", "M3GS", "WIMS", NULL,
 131         NULL, NULL, "PBPS", "TPDS"
 132 };
 133
 134 static const struct key_entry eeepc_keymap[] = {
 135         { KE_KEY, 0x10, { KEY_WLAN } },
 136         { KE_KEY, 0x11, { KEY_WLAN } },
 137         { KE_KEY, 0x12, { KEY_PROG1 } },
 138         { KE_KEY, 0x13, { KEY_MUTE } },
 139         { KE_KEY, 0x14, { KEY_VOLUMEDOWN } },
 140         { KE_KEY, 0x15, { KEY_VOLUMEUP } },
 141         { KE_KEY, 0x16, { KEY_DISPLAY_OFF } },
 142         { KE_KEY, 0x1a, { KEY_COFFEE } },
 143         { KE_KEY, 0x1b, { KEY_ZOOM } },
 144         { KE_KEY, 0x1c, { KEY_PROG2 } },
 145         { KE_KEY, 0x1d, { KEY_PROG3 } },
 146         { KE_KEY, NOTIFY_BRN_MIN, { KEY_BRIGHTNESSDOWN } },
 147         { KE_KEY, NOTIFY_BRN_MAX, { KEY_BRIGHTNESSUP } },
 148         { KE_KEY, 0x30, { KEY_SWITCHVIDEOMODE } },
 149         { KE_KEY, 0x31, { KEY_SWITCHVIDEOMODE } },
 150         { KE_KEY, 0x32, { KEY_SWITCHVIDEOMODE } },
 151         { KE_KEY, 0x37, { KEY_F13 } }, /* Disable Touchpad */
 152         { KE_KEY, 0x38, { KEY_F14 } },
 153         { KE_END, 0 },
 154 };
 155
 156 /*
 157  * This is the main structure, we can use it to store useful information
 158  */
 159 struct eeepc_laptop {
 160         acpi_handle handle;             /* the handle of the acpi device */
 161         u32 cm_supported;               /* the control methods supported
 162                                            by this BIOS */
 163         bool cpufv_disabled;
 164         bool hotplug_disabled;
 165         u16 event_count[128];           /* count for each event */
 166
 167         struct platform_device *platform_device;
 168         struct acpi_device *device;             /* the device we are in */
 169         struct device *hwmon_device;
 170         struct backlight_device *backlight_device;
 171
 172         struct input_dev *inputdev;
 173
 174         struct rfkill *wlan_rfkill;
 175         struct rfkill *bluetooth_rfkill;
 176         struct rfkill *wwan3g_rfkill;
 177         struct rfkill *wimax_rfkill;
 178
 179         struct hotplug_slot *hotplug_slot;
 180         struct mutex hotplug_lock;
 181
 182         struct led_classdev tpd_led;
 183         int tpd_led_wk;
 184         struct workqueue_struct *led_workqueue;
 185         struct work_struct tpd_led_work;
 186 };
 187
 188 /*
 189  * ACPI Helpers
 190  */
 191 static int write_acpi_int(acpi_handle handle, const char *method, int val)
 192 {
 193         struct acpi_object_list params;
 194         union acpi_object in_obj;
 195         acpi_status status;
 196
 197         params.count = 1;
 198         params.pointer = &in_obj;
 199         in_obj.type = ACPI_TYPE_INTEGER;
 200         in_obj.integer.value = val;
 201
 202         status = acpi_evaluate_object(handle, (char *)method, &params, NULL);
 203         return (status == AE_OK ? 0 : -1);
 204 }
 205
 206 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
 207 {
 208         acpi_status status;
 209         unsigned long long result;
 210
 211         status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
 212         if (ACPI_FAILURE(status)) {
 213                 *val = -1;
 214                 return -1;
 215         } else {
 216                 *val = result;
 217                 return 0;
 218         }
 219 }
 220
 221 static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
 222 {
 223         const char *method = cm_setv[cm];
 224
 225         if (method == NULL)
 226                 return -ENODEV;
 227         if ((eeepc->cm_supported & (0x1 << cm)) == 0)
 228                 return -ENODEV;
 229
 230         if (write_acpi_int(eeepc->handle, method, value))
 231                 pr_warning("Error writing %s\n", method);
 232         return 0;
 233 }
 234
 235 static int get_acpi(struct eeepc_laptop *eeepc, int cm)
 236 {
 237         const char *method = cm_getv[cm];
 238         int value;
 239
 240         if (method == NULL)
 241                 return -ENODEV;
 242         if ((eeepc->cm_supported & (0x1 << cm)) == 0)
 243                 return -ENODEV;
 244
 245         if (read_acpi_int(eeepc->handle, method, &value))
 246                 pr_warning("Error reading %s\n", method);
 247         return value;
 248 }
 249
 250 static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
 251                               acpi_handle *handle)
 252 {
 253         const char *method = cm_setv[cm];
 254         acpi_status status;
 255
 256         if (method == NULL)
 257                 return -ENODEV;
 258         if ((eeepc->cm_supported & (0x1 << cm)) == 0)
 259                 return -ENODEV;
 260
 261         status = acpi_get_handle(eeepc->handle, (char *)method,
 262                                  handle);
 263         if (status != AE_OK) {
 264                 pr_warning("Error finding %s\n", method);
 265                 return -ENODEV;
 266         }
 267         return 0;
 268 }
 269
 270
 271 /*
 272  * Sys helpers
 273  */
 274 static int parse_arg(const char *buf, unsigned long count, int *val)
 275 {
 276         if (!count)
 277                 return 0;
 278         if (sscanf(buf, "%i", val) != 1)
 279                 return -EINVAL;
 280         return count;
 281 }
 282
 283 static ssize_t store_sys_acpi(struct device *dev, int cm,
 284                               const char *buf, size_t count)
 285 {
 286         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 287         int rv, value;
 288
 289         rv = parse_arg(buf, count, &value);
 290         if (rv > 0)
 291                 value = set_acpi(eeepc, cm, value);
 292         if (value < 0)
 293                 return -EIO;
 294         return rv;
 295 }
 296
 297 static ssize_t show_sys_acpi(struct device *dev, int cm, char *buf)
 298 {
 299         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 300         int value = get_acpi(eeepc, cm);
 301
 302         if (value < 0)
 303                 return -EIO;
 304         return sprintf(buf, "%d\n", value);
 305 }
 306
 307 #define EEEPC_CREATE_DEVICE_ATTR(_name, _mode, _cm)                     \
 308         static ssize_t show_##_name(struct device *dev,                 \
 309                                     struct device_attribute *attr,      \
 310                                     char *buf)                          \
 311         {                                                               \
 312                 return show_sys_acpi(dev, _cm, buf);                    \
 313         }                                                               \
 314         static ssize_t store_##_name(struct device *dev,                \
 315                                      struct device_attribute *attr,     \
 316                                      const char *buf, size_t count)     \
 317         {                                                               \
 318                 return store_sys_acpi(dev, _cm, buf, count);            \
 319         }                                                               \
 320         static struct device_attribute dev_attr_##_name = {             \
 321                 .attr = {                                               \
 322                         .name = __stringify(_name),                     \
 323                         .mode = _mode },                                \
 324                 .show   = show_##_name,                                 \
 325                 .store  = store_##_name,                                \
 326         }
 327
 328 EEEPC_CREATE_DEVICE_ATTR(camera, 0644, CM_ASL_CAMERA);
 329 EEEPC_CREATE_DEVICE_ATTR(cardr, 0644, CM_ASL_CARDREADER);
 330 EEEPC_CREATE_DEVICE_ATTR(disp, 0200, CM_ASL_DISPLAYSWITCH);
 331
 332 struct eeepc_cpufv {
 333         int num;
 334         int cur;
 335 };
 336
 337 static int get_cpufv(struct eeepc_laptop *eeepc, struct eeepc_cpufv *c)
 338 {
 339         c->cur = get_acpi(eeepc, CM_ASL_CPUFV);
 340         c->num = (c->cur >> 8) & 0xff;
 341         c->cur &= 0xff;
 342         if (c->cur < 0 || c->num <= 0 || c->num > 12)
 343                 return -ENODEV;
 344         return 0;
 345 }
 346
 347 static ssize_t show_available_cpufv(struct device *dev,
 348                                     struct device_attribute *attr,
 349                                     char *buf)
 350 {
 351         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 352         struct eeepc_cpufv c;
 353         int i;
 354         ssize_t len = 0;
 355
 356         if (get_cpufv(eeepc, &c))
 357                 return -ENODEV;
 358         for (i = 0; i < c.num; i++)
 359                 len += sprintf(buf + len, "%d ", i);
 360         len += sprintf(buf + len, "\n");
 361         return len;
 362 }
 363
 364 static ssize_t show_cpufv(struct device *dev,
 365                           struct device_attribute *attr,
 366                           char *buf)
 367 {
 368         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 369         struct eeepc_cpufv c;
 370
 371         if (get_cpufv(eeepc, &c))
 372                 return -ENODEV;
 373         return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
 374 }
 375
 376 static ssize_t store_cpufv(struct device *dev,
 377                            struct device_attribute *attr,
 378                            const char *buf, size_t count)
 379 {
 380         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 381         struct eeepc_cpufv c;
 382         int rv, value;
 383
 384         if (eeepc->cpufv_disabled)
 385                 return -EPERM;
 386         if (get_cpufv(eeepc, &c))
 387                 return -ENODEV;
 388         rv = parse_arg(buf, count, &value);
 389         if (rv < 0)
 390                 return rv;
 391         if (!rv || value < 0 || value >= c.num)
 392                 return -EINVAL;
 393         set_acpi(eeepc, CM_ASL_CPUFV, value);
 394         return rv;
 395 }
 396
 397 static ssize_t show_cpufv_disabled(struct device *dev,
 398                           struct device_attribute *attr,
 399                           char *buf)
 400 {
 401         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 402
 403         return sprintf(buf, "%d\n", eeepc->cpufv_disabled);
 404 }
 405
 406 static ssize_t store_cpufv_disabled(struct device *dev,
 407                            struct device_attribute *attr,
 408                            const char *buf, size_t count)
 409 {
 410         struct eeepc_laptop *eeepc = dev_get_drvdata(dev);
 411         int rv, value;
 412
 413         rv = parse_arg(buf, count, &value);
 414         if (rv < 0)
 415                 return rv;
 416
 417         switch (value) {
 418         case 0:
 419                 if (eeepc->cpufv_disabled)
 420                         pr_warning("cpufv enabled (not officially supported "
 421                                 "on this model)\n");
 422                 eeepc->cpufv_disabled = false;
 423                 return rv;
 424         case 1:
 425                 return -EPERM;
 426         default:
 427                 return -EINVAL;
 428         }
 429 }
 430
 431
 432 static struct device_attribute dev_attr_cpufv = {
 433         .attr = {
 434                 .name = "cpufv",
 435                 .mode = 0644 },
 436         .show   = show_cpufv,
 437         .store  = store_cpufv
 438 };
 439
 440 static struct device_attribute dev_attr_available_cpufv = {
 441         .attr = {
 442                 .name = "available_cpufv",
 443                 .mode = 0444 },
 444         .show   = show_available_cpufv
 445 };
 446
 447 static struct device_attribute dev_attr_cpufv_disabled = {
 448         .attr = {
 449                 .name = "cpufv_disabled",
 450                 .mode = 0644 },
 451         .show   = show_cpufv_disabled,
 452         .store  = store_cpufv_disabled
 453 };
 454
 455
 456 static struct attribute *platform_attributes[] = {
 457         &dev_attr_camera.attr,
 458         &dev_attr_cardr.attr,
 459         &dev_attr_disp.attr,
 460         &dev_attr_cpufv.attr,
 461         &dev_attr_available_cpufv.attr,
 462         &dev_attr_cpufv_disabled.attr,
 463         NULL
 464 };
 465
 466 static struct attribute_group platform_attribute_group = {
 467         .attrs = platform_attributes
 468 };
 469
 470 static int eeepc_platform_init(struct eeepc_laptop *eeepc)
 471 {
 472         int result;
 473
 474         eeepc->platform_device = platform_device_alloc(EEEPC_LAPTOP_FILE, -1);
 475         if (!eeepc->platform_device)
 476                 return -ENOMEM;
 477         platform_set_drvdata(eeepc->platform_device, eeepc);
 478
 479         result = platform_device_add(eeepc->platform_device);
 480         if (result)
 481                 goto fail_platform_device;
 482
 483         result = sysfs_create_group(&eeepc->platform_device->dev.kobj,
 484                                     &platform_attribute_group);
 485         if (result)
 486                 goto fail_sysfs;
 487         return 0;
 488
 489 fail_sysfs:
 490         platform_device_del(eeepc->platform_device);
 491 fail_platform_device:
 492         platform_device_put(eeepc->platform_device);
 493         return result;
 494 }
 495
 496 static void eeepc_platform_exit(struct eeepc_laptop *eeepc)
 497 {
 498         sysfs_remove_group(&eeepc->platform_device->dev.kobj,
 499                            &platform_attribute_group);
 500         platform_device_unregister(eeepc->platform_device);
 501 }
 502
 503 /*
 504  * LEDs
 505  */
 506 /*
 507  * These functions actually update the LED's, and are called from a
 508  * workqueue. By doing this as separate work rather than when the LED
 509  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 510  * potentially bad time, such as a timer interrupt.
 511  */
 512 static void tpd_led_update(struct work_struct *work)
 513  {
 514         struct eeepc_laptop *eeepc;
 515
 516         eeepc = container_of(work, struct eeepc_laptop, tpd_led_work);
 517
 518         set_acpi(eeepc, CM_ASL_TPD, eeepc->tpd_led_wk);
 519 }
 520
 521 static void tpd_led_set(struct led_classdev *led_cdev,
 522                         enum led_brightness value)
 523 {
 524         struct eeepc_laptop *eeepc;
 525
 526         eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
 527
 528         eeepc->tpd_led_wk = (value > 0) ? 1 : 0;
 529         queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
 530 }
 531
 532 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
 533 {
 534         struct eeepc_laptop *eeepc;
 535
 536         eeepc = container_of(led_cdev, struct eeepc_laptop, tpd_led);
 537
 538         return get_acpi(eeepc, CM_ASL_TPD);
 539 }
 540
 541 static int eeepc_led_init(struct eeepc_laptop *eeepc)
 542 {
 543         int rv;
 544
 545         if (get_acpi(eeepc, CM_ASL_TPD) == -ENODEV)
 546                 return 0;
 547
 548         eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
 549         if (!eeepc->led_workqueue)
 550                 return -ENOMEM;
 551         INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
 552
 553         eeepc->tpd_led.name = "eeepc::touchpad";
 554         eeepc->tpd_led.brightness_set = tpd_led_set;
 555         if (get_acpi(eeepc, CM_ASL_TPD) >= 0) /* if method is available */
 556           eeepc->tpd_led.brightness_get = tpd_led_get;
 557         eeepc->tpd_led.max_brightness = 1;
 558
 559         rv = led_classdev_register(&eeepc->platform_device->dev,
 560                                    &eeepc->tpd_led);
 561         if (rv) {
 562                 destroy_workqueue(eeepc->led_workqueue);
 563                 return rv;
 564         }
 565
 566         return 0;
 567 }
 568
 569 static void eeepc_led_exit(struct eeepc_laptop *eeepc)
 570 {
 571         if (eeepc->tpd_led.dev)
 572                 led_classdev_unregister(&eeepc->tpd_led);
 573         if (eeepc->led_workqueue)
 574                 destroy_workqueue(eeepc->led_workqueue);
 575 }
 576
 577
 578 /*
 579  * PCI hotplug (for wlan rfkill)
 580  */
 581 static bool eeepc_wlan_rfkill_blocked(struct eeepc_laptop *eeepc)
 582 {
 583         if (get_acpi(eeepc, CM_ASL_WLAN) == 1)
 584                 return false;
 585         return true;
 586 }
 587
 588 static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
 589 {
 590         struct pci_dev *port;
 591         struct pci_dev *dev;
 592         struct pci_bus *bus;
 593         bool blocked = eeepc_wlan_rfkill_blocked(eeepc);
 594         bool absent;
 595         u32 l;
 596
 597         if (eeepc->wlan_rfkill)
 598                 rfkill_set_sw_state(eeepc->wlan_rfkill, blocked);
 599
 600         mutex_lock(&eeepc->hotplug_lock);
 601
 602         if (eeepc->hotplug_slot) {
 603                 port = acpi_get_pci_dev(handle);
 604                 if (!port) {
 605                         pr_warning("Unable to find port\n");
 606                         goto out_unlock;
 607                 }
 608
 609                 bus = port->subordinate;
 610
 611                 if (!bus) {
 612                         pr_warning("Unable to find PCI bus?\n");
 613                         goto out_unlock;
 614                 }
 615
 616                 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
 617                         pr_err("Unable to read PCI config space?\n");
 618                         goto out_unlock;
 619                 }
 620
 621                 absent = (l == 0xffffffff);
 622
 623                 if (blocked != absent) {
 624                         pr_warning("BIOS says wireless lan is %s, "
 625                                         "but the pci device is %s\n",
 626                                 blocked ? "blocked" : "unblocked",
 627                                 absent ? "absent" : "present");
 628                         pr_warning("skipped wireless hotplug as probably "
 629                                         "inappropriate for this model\n");
 630                         goto out_unlock;
 631                 }
 632
 633                 if (!blocked) {
 634                         dev = pci_get_slot(bus, 0);
 635                         if (dev) {
 636                                 /* Device already present */
 637                                 pci_dev_put(dev);
 638                                 goto out_unlock;
 639                         }
 640                         dev = pci_scan_single_device(bus, 0);
 641                         if (dev) {
 642                                 pci_bus_assign_resources(bus);
 643                                 if (pci_bus_add_device(dev))
 644                                         pr_err("Unable to hotplug wifi\n");
 645                         }
 646                 } else {
 647                         dev = pci_get_slot(bus, 0);
 648                         if (dev) {
 649                                 pci_remove_bus_device(dev);
 650                                 pci_dev_put(dev);
 651                         }
 652                 }
 653         }
 654
 655 out_unlock:
 656         mutex_unlock(&eeepc->hotplug_lock);
 657 }
 658
 659 static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node)
 660 {
 661         acpi_status status = AE_OK;
 662         acpi_handle handle;
 663
 664         status = acpi_get_handle(NULL, node, &handle);
 665
 666         if (ACPI_SUCCESS(status))
 667                 eeepc_rfkill_hotplug(eeepc, handle);
 668 }
 669
 670 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 671 {
 672         struct eeepc_laptop *eeepc = data;
 673
 674         if (event != ACPI_NOTIFY_BUS_CHECK)
 675                 return;
 676
 677         eeepc_rfkill_hotplug(eeepc, handle);
 678 }
 679
 680 static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
 681                                           char *node)
 682 {
 683         acpi_status status;
 684         acpi_handle handle;
 685
 686         status = acpi_get_handle(NULL, node, &handle);
 687
 688         if (ACPI_SUCCESS(status)) {
 689                 status = acpi_install_notify_handler(handle,
 690                                                      ACPI_SYSTEM_NOTIFY,
 691                                                      eeepc_rfkill_notify,
 692                                                      eeepc);
 693                 if (ACPI_FAILURE(status))
 694                         pr_warning("Failed to register notify on %s\n", node);
 695                 /*
 696                  * Refresh pci hotplug in case the rfkill state was
 697                  * changed during setup.
 698                  */
 699                 eeepc_rfkill_hotplug(eeepc, handle);
 700         } else
 701                 return -ENODEV;
 702
 703         return 0;
 704 }
 705
 706 static void eeepc_unregister_rfkill_notifier(struct eeepc_laptop *eeepc,
 707                                              char *node)
 708 {
 709         acpi_status status = AE_OK;
 710         acpi_handle handle;
 711
 712         status = acpi_get_handle(NULL, node, &handle);
 713
 714         if (ACPI_SUCCESS(status)) {
 715                 status = acpi_remove_notify_handler(handle,
 716                                                      ACPI_SYSTEM_NOTIFY,
 717                                                      eeepc_rfkill_notify);
 718                 if (ACPI_FAILURE(status))
 719                         pr_err("Error removing rfkill notify handler %s\n",
 720                                 node);
 721                         /*
 722                          * Refresh pci hotplug in case the rfkill
 723                          * state was changed after
 724                          * eeepc_unregister_rfkill_notifier()
 725                          */
 726                 eeepc_rfkill_hotplug(eeepc, handle);
 727         }
 728 }
 729
 730 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
 731                                     u8 *value)
 732 {
 733         struct eeepc_laptop *eeepc = hotplug_slot->private;
 734         int val = get_acpi(eeepc, CM_ASL_WLAN);
 735
 736         if (val == 1 || val == 0)
 737                 *value = val;
 738         else
 739                 return -EINVAL;
 740
 741         return 0;
 742 }
 743
 744 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
 745 {
 746         kfree(hotplug_slot->info);
 747         kfree(hotplug_slot);
 748 }
 749
 750 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
 751         .owner = THIS_MODULE,
 752         .get_adapter_status = eeepc_get_adapter_status,
 753         .get_power_status = eeepc_get_adapter_status,
 754 };
 755
 756 static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
 757 {
 758         int ret = -ENOMEM;
 759         struct pci_bus *bus = pci_find_bus(0, 1);
 760
 761         if (!bus) {
 762                 pr_err("Unable to find wifi PCI bus\n");
 763                 return -ENODEV;
 764         }
 765
 766         eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 767         if (!eeepc->hotplug_slot)
 768                 goto error_slot;
 769
 770         eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
 771                                             GFP_KERNEL);
 772         if (!eeepc->hotplug_slot->info)
 773                 goto error_info;
 774
 775         eeepc->hotplug_slot->private = eeepc;
 776         eeepc->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
 777         eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
 778         eeepc_get_adapter_status(eeepc->hotplug_slot,
 779                                  &eeepc->hotplug_slot->info->adapter_status);
 780
 781         ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
 782         if (ret) {
 783                 pr_err("Unable to register hotplug slot - %d\n", ret);
 784                 goto error_register;
 785         }
 786
 787         return 0;
 788
 789 error_register:
 790         kfree(eeepc->hotplug_slot->info);
 791 error_info:
 792         kfree(eeepc->hotplug_slot);
 793         eeepc->hotplug_slot = NULL;
 794 error_slot:
 795         return ret;
 796 }
 797
 798 /*
 799  * Rfkill devices
 800  */
 801 static int eeepc_rfkill_set(void *data, bool blocked)
 802 {
 803         acpi_handle handle = data;
 804
 805         return write_acpi_int(handle, NULL, !blocked);
 806 }
 807
 808 static const struct rfkill_ops eeepc_rfkill_ops = {
 809         .set_block = eeepc_rfkill_set,
 810 };
 811
 812 static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
 813                             struct rfkill **rfkill,
 814                             const char *name,
 815                             enum rfkill_type type, int cm)
 816 {
 817         acpi_handle handle;
 818         int result;
 819
 820         result = acpi_setter_handle(eeepc, cm, &handle);
 821         if (result < 0)
 822                 return result;
 823
 824         *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
 825                                &eeepc_rfkill_ops, handle);
 826
 827         if (!*rfkill)
 828                 return -EINVAL;
 829
 830         rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
 831         result = rfkill_register(*rfkill);
 832         if (result) {
 833                 rfkill_destroy(*rfkill);
 834                 *rfkill = NULL;
 835                 return result;
 836         }
 837         return 0;
 838 }
 839
 840 static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
 841 {
 842         eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
 843         eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
 844         eeepc_unregister_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
 845         if (eeepc->wlan_rfkill) {
 846                 rfkill_unregister(eeepc->wlan_rfkill);
 847                 rfkill_destroy(eeepc->wlan_rfkill);
 848                 eeepc->wlan_rfkill = NULL;
 849         }
 850
 851         if (eeepc->hotplug_slot)
 852                 pci_hp_deregister(eeepc->hotplug_slot);
 853
 854         if (eeepc->bluetooth_rfkill) {
 855                 rfkill_unregister(eeepc->bluetooth_rfkill);
 856                 rfkill_destroy(eeepc->bluetooth_rfkill);
 857                 eeepc->bluetooth_rfkill = NULL;
 858         }
 859         if (eeepc->wwan3g_rfkill) {
 860                 rfkill_unregister(eeepc->wwan3g_rfkill);
 861                 rfkill_destroy(eeepc->wwan3g_rfkill);
 862                 eeepc->wwan3g_rfkill = NULL;
 863         }
 864         if (eeepc->wimax_rfkill) {
 865                 rfkill_unregister(eeepc->wimax_rfkill);
 866                 rfkill_destroy(eeepc->wimax_rfkill);
 867                 eeepc->wimax_rfkill = NULL;
 868         }
 869 }
 870
 871 static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
 872 {
 873         int result = 0;
 874
 875         mutex_init(&eeepc->hotplug_lock);
 876
 877         result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
 878                                   "eeepc-wlan", RFKILL_TYPE_WLAN,
 879                                   CM_ASL_WLAN);
 880
 881         if (result && result != -ENODEV)
 882                 goto exit;
 883
 884         result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
 885                                   "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
 886                                   CM_ASL_BLUETOOTH);
 887
 888         if (result && result != -ENODEV)
 889                 goto exit;
 890
 891         result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
 892                                   "eeepc-wwan3g", RFKILL_TYPE_WWAN,
 893                                   CM_ASL_3G);
 894
 895         if (result && result != -ENODEV)
 896                 goto exit;
 897
 898         result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
 899                                   "eeepc-wimax", RFKILL_TYPE_WIMAX,
 900                                   CM_ASL_WIMAX);
 901
 902         if (result && result != -ENODEV)
 903                 goto exit;
 904
 905         if (eeepc->hotplug_disabled)
 906                 return 0;
 907
 908         result = eeepc_setup_pci_hotplug(eeepc);
 909         /*
 910          * If we get -EBUSY then something else is handling the PCI hotplug -
 911          * don't fail in this case
 912          */
 913         if (result == -EBUSY)
 914                 result = 0;
 915
 916         eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P5");
 917         eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P6");
 918         eeepc_register_rfkill_notifier(eeepc, "\\_SB.PCI0.P0P7");
 919
 920 exit:
 921         if (result && result != -ENODEV)
 922                 eeepc_rfkill_exit(eeepc);
 923         return result;
 924 }
 925
 926 /*
 927  * Platform driver - hibernate/resume callbacks
 928  */
 929 static int eeepc_hotk_thaw(struct device *device)
 930 {
 931         struct eeepc_laptop *eeepc = dev_get_drvdata(device);
 932
 933         if (eeepc->wlan_rfkill) {
 934                 bool wlan;
 935
 936                 /*
 937                  * Work around bios bug - acpi _PTS turns off the wireless led
 938                  * during suspend.  Normally it restores it on resume, but
 939                  * we should kick it ourselves in case hibernation is aborted.
 940                  */
 941                 wlan = get_acpi(eeepc, CM_ASL_WLAN);
 942                 set_acpi(eeepc, CM_ASL_WLAN, wlan);
 943         }
 944
 945         return 0;
 946 }
 947
 948 static int eeepc_hotk_restore(struct device *device)
 949 {
 950         struct eeepc_laptop *eeepc = dev_get_drvdata(device);
 951
 952         /* Refresh both wlan rfkill state and pci hotplug */
 953         if (eeepc->wlan_rfkill) {
 954                 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P5");
 955                 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P6");
 956                 eeepc_rfkill_hotplug_update(eeepc, "\\_SB.PCI0.P0P7");
 957         }
 958
 959         if (eeepc->bluetooth_rfkill)
 960                 rfkill_set_sw_state(eeepc->bluetooth_rfkill,
 961                                     get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
 962         if (eeepc->wwan3g_rfkill)
 963                 rfkill_set_sw_state(eeepc->wwan3g_rfkill,
 964                                     get_acpi(eeepc, CM_ASL_3G) != 1);
 965         if (eeepc->wimax_rfkill)
 966                 rfkill_set_sw_state(eeepc->wimax_rfkill,
 967                                     get_acpi(eeepc, CM_ASL_WIMAX) != 1);
 968
 969         return 0;
 970 }
 971
 972 static const struct dev_pm_ops eeepc_pm_ops = {
 973         .thaw = eeepc_hotk_thaw,
 974         .restore = eeepc_hotk_restore,
 975 };
 976
 977 static struct platform_driver platform_driver = {
 978         .driver = {
 979                 .name = EEEPC_LAPTOP_FILE,
 980                 .owner = THIS_MODULE,
 981                 .pm = &eeepc_pm_ops,
 982         }
 983 };
 984
 985 /*
 986  * Hwmon device
 987  */
 988
 989 #define EEEPC_EC_SC00      0x61
 990 #define EEEPC_EC_FAN_PWM   (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
 991 #define EEEPC_EC_FAN_HRPM  (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
 992 #define EEEPC_EC_FAN_LRPM  (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
 993
 994 #define EEEPC_EC_SFB0      0xD0
 995 #define EEEPC_EC_FAN_CTRL  (EEEPC_EC_SFB0 + 3) /* Byte containing SF25  */
 996
 997 static int eeepc_get_fan_pwm(void)
 998 {
 999         u8 value = 0;
1000
1001         ec_read(EEEPC_EC_FAN_PWM, &value);
1002         return value * 255 / 100;
1003 }
1004
1005 static void eeepc_set_fan_pwm(int value)
1006 {
1007         value = SENSORS_LIMIT(value, 0, 255);
1008         value = value * 100 / 255;
1009         ec_write(EEEPC_EC_FAN_PWM, value);
1010 }
1011
1012 static int eeepc_get_fan_rpm(void)
1013 {
1014         u8 high = 0;
1015         u8 low = 0;
1016
1017         ec_read(EEEPC_EC_FAN_HRPM, &high);
1018         ec_read(EEEPC_EC_FAN_LRPM, &low);
1019         return high << 8 | low;
1020 }
1021
1022 static int eeepc_get_fan_ctrl(void)
1023 {
1024         u8 value = 0;
1025
1026         ec_read(EEEPC_EC_FAN_CTRL, &value);
1027         if (value & 0x02)
1028                 return 1; /* manual */
1029         else
1030                 return 2; /* automatic */
1031 }
1032
1033 static void eeepc_set_fan_ctrl(int manual)
1034 {
1035         u8 value = 0;
1036
1037         ec_read(EEEPC_EC_FAN_CTRL, &value);
1038         if (manual == 1)
1039                 value |= 0x02;
1040         else
1041                 value &= ~0x02;
1042         ec_write(EEEPC_EC_FAN_CTRL, value);
1043 }
1044
1045 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1046 {
1047         int rv, value;
1048
1049         rv = parse_arg(buf, count, &value);
1050         if (rv > 0)
1051                 set(value);
1052         return rv;
1053 }
1054
1055 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1056 {
1057         return sprintf(buf, "%d\n", get());
1058 }
1059
1060 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get)              \
1061         static ssize_t show_##_name(struct device *dev,                 \
1062                                     struct device_attribute *attr,      \
1063                                     char *buf)                          \
1064         {                                                               \
1065                 return show_sys_hwmon(_set, buf);                       \
1066         }                                                               \
1067         static ssize_t store_##_name(struct device *dev,                \
1068                                      struct device_attribute *attr,     \
1069                                      const char *buf, size_t count)     \
1070         {                                                               \
1071                 return store_sys_hwmon(_get, buf, count);               \
1072         }                                                               \
1073         static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
1074
1075 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
1076 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
1077                          eeepc_get_fan_pwm, eeepc_set_fan_pwm);
1078 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
1079                          eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
1080
1081 static ssize_t
1082 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1083 {
1084         return sprintf(buf, "eeepc\n");
1085 }
1086 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
1087
1088 static struct attribute *hwmon_attributes[] = {
1089         &sensor_dev_attr_pwm1.dev_attr.attr,
1090         &sensor_dev_attr_fan1_input.dev_attr.attr,
1091         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1092         &sensor_dev_attr_name.dev_attr.attr,
1093         NULL
1094 };
1095
1096 static struct attribute_group hwmon_attribute_group = {
1097         .attrs = hwmon_attributes
1098 };
1099
1100 static void eeepc_hwmon_exit(struct eeepc_laptop *eeepc)
1101 {
1102         struct device *hwmon;
1103
1104         hwmon = eeepc->hwmon_device;
1105         if (!hwmon)
1106                 return;
1107         sysfs_remove_group(&hwmon->kobj,
1108                            &hwmon_attribute_group);
1109         hwmon_device_unregister(hwmon);
1110         eeepc->hwmon_device = NULL;
1111 }
1112
1113 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1114 {
1115         struct device *hwmon;
1116         int result;
1117
1118         hwmon = hwmon_device_register(&eeepc->platform_device->dev);
1119         if (IS_ERR(hwmon)) {
1120                 pr_err("Could not register eeepc hwmon device\n");
1121                 eeepc->hwmon_device = NULL;
1122                 return PTR_ERR(hwmon);
1123         }
1124         eeepc->hwmon_device = hwmon;
1125         result = sysfs_create_group(&hwmon->kobj,
1126                                     &hwmon_attribute_group);
1127         if (result)
1128                 eeepc_hwmon_exit(eeepc);
1129         return result;
1130 }
1131
1132 /*
1133  * Backlight device
1134  */
1135 static int read_brightness(struct backlight_device *bd)
1136 {
1137         struct eeepc_laptop *eeepc = bl_get_data(bd);
1138
1139         return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1140 }
1141
1142 static int set_brightness(struct backlight_device *bd, int value)
1143 {
1144         struct eeepc_laptop *eeepc = bl_get_data(bd);
1145
1146         return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1147 }
1148
1149 static int update_bl_status(struct backlight_device *bd)
1150 {
1151         return set_brightness(bd, bd->props.brightness);
1152 }
1153
1154 static const struct backlight_ops eeepcbl_ops = {
1155         .get_brightness = read_brightness,
1156         .update_status = update_bl_status,
1157 };
1158
1159 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1160 {
1161         struct backlight_device *bd = eeepc->backlight_device;
1162         int old = bd->props.brightness;
1163
1164         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1165
1166         return old;
1167 }
1168
1169 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1170 {
1171         struct backlight_properties props;
1172         struct backlight_device *bd;
1173
1174         memset(&props, 0, sizeof(struct backlight_properties));
1175         props.type = BACKLIGHT_PLATFORM;
1176         props.max_brightness = 15;
1177         bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1178                                        &eeepc->platform_device->dev, eeepc,
1179                                        &eeepcbl_ops, &props);
1180         if (IS_ERR(bd)) {
1181                 pr_err("Could not register eeepc backlight device\n");
1182                 eeepc->backlight_device = NULL;
1183                 return PTR_ERR(bd);
1184         }
1185         eeepc->backlight_device = bd;
1186         bd->props.brightness = read_brightness(bd);
1187         bd->props.power = FB_BLANK_UNBLANK;
1188         backlight_update_status(bd);
1189         return 0;
1190 }
1191
1192 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1193 {
1194         if (eeepc->backlight_device)
1195                 backlight_device_unregister(eeepc->backlight_device);
1196         eeepc->backlight_device = NULL;
1197 }
1198
1199
1200 /*
1201  * Input device (i.e. hotkeys)
1202  */
1203 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1204 {
1205         struct input_dev *input;
1206         int error;
1207
1208         input = input_allocate_device();
1209         if (!input) {
1210                 pr_info("Unable to allocate input device\n");
1211                 return -ENOMEM;
1212         }
1213
1214         input->name = "Asus EeePC extra buttons";
1215         input->phys = EEEPC_LAPTOP_FILE "/input0";
1216         input->id.bustype = BUS_HOST;
1217         input->dev.parent = &eeepc->platform_device->dev;
1218
1219         error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1220         if (error) {
1221                 pr_err("Unable to setup input device keymap\n");
1222                 goto err_free_dev;
1223         }
1224
1225         error = input_register_device(input);
1226         if (error) {
1227                 pr_err("Unable to register input device\n");
1228                 goto err_free_keymap;
1229         }
1230
1231         eeepc->inputdev = input;
1232         return 0;
1233
1234 err_free_keymap:
1235         sparse_keymap_free(input);
1236 err_free_dev:
1237         input_free_device(input);
1238         return error;
1239 }
1240
1241 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1242 {
1243         if (eeepc->inputdev) {
1244                 sparse_keymap_free(eeepc->inputdev);
1245                 input_unregister_device(eeepc->inputdev);
1246         }
1247         eeepc->inputdev = NULL;
1248 }
1249
1250 /*
1251  * ACPI driver
1252  */
1253 static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
1254 {
1255         struct eeepc_laptop *eeepc = acpi_driver_data(device);
1256         u16 count;
1257
1258         if (event > ACPI_MAX_SYS_NOTIFY)
1259                 return;
1260         count = eeepc->event_count[event % 128]++;
1261         acpi_bus_generate_proc_event(device, event, count);
1262         acpi_bus_generate_netlink_event(device->pnp.device_class,
1263                                         dev_name(&device->dev), event,
1264                                         count);
1265
1266         /* Brightness events are special */
1267         if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX) {
1268
1269                 /* Ignore them completely if the acpi video driver is used */
1270                 if (eeepc->backlight_device != NULL) {
1271                         int old_brightness, new_brightness;
1272
1273                         /* Update the backlight device. */
1274                         old_brightness = eeepc_backlight_notify(eeepc);
1275
1276                         /* Convert event to keypress (obsolescent hack) */
1277                         new_brightness = event - NOTIFY_BRN_MIN;
1278
1279                         if (new_brightness < old_brightness) {
1280                                 event = NOTIFY_BRN_MIN; /* brightness down */
1281                         } else if (new_brightness > old_brightness) {
1282                                 event = NOTIFY_BRN_MAX; /* brightness up */
1283                         } else {
1284                                 /*
1285                                 * no change in brightness - already at min/max,
1286                                 * event will be desired value (or else ignored)
1287                                 */
1288                         }
1289                         sparse_keymap_report_event(eeepc->inputdev, event,
1290                                                    1, true);
1291                 }
1292         } else {
1293                 /* Everything else is a bona-fide keypress event */
1294                 sparse_keymap_report_event(eeepc->inputdev, event, 1, true);
1295         }
1296 }
1297
1298 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1299 {
1300         const char *model;
1301
1302         model = dmi_get_system_info(DMI_PRODUCT_NAME);
1303         if (!model)
1304                 return;
1305
1306         /*
1307          * Blacklist for setting cpufv (cpu speed).
1308          *
1309          * EeePC 4G ("701") implements CFVS, but it is not supported
1310          * by the pre-installed OS, and the original option to change it
1311          * in the BIOS setup screen was removed in later versions.
1312          *
1313          * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1314          * this applies to all "701" models (4G/4G Surf/2G Surf).
1315          *
1316          * So Asus made a deliberate decision not to support it on this model.
1317          * We have several reports that using it can cause the system to hang
1318          *
1319          * The hang has also been reported on a "702" (Model name "8G"?).
1320          *
1321          * We avoid dmi_check_system() / dmi_match(), because they use
1322          * substring matching.  We don't want to affect the "701SD"
1323          * and "701SDX" models, because they do support S.H.E.
1324          */
1325         if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1326                 eeepc->cpufv_disabled = true;
1327                 pr_info("model %s does not officially support setting cpu "
1328                         "speed\n", model);
1329                 pr_info("cpufv disabled to avoid instability\n");
1330         }
1331
1332         /*
1333          * Blacklist for wlan hotplug
1334          *
1335          * Eeepc 1005HA doesn't work like others models and don't need the
1336          * hotplug code. In fact, current hotplug code seems to unplug another
1337          * device...
1338          */
1339         if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1340             strcmp(model, "1005PE") == 0) {
1341                 eeepc->hotplug_disabled = true;
1342                 pr_info("wlan hotplug disabled\n");
1343         }
1344 }
1345
1346 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1347 {
1348         int dummy;
1349
1350         /* Some BIOSes do not report cm although it is available.
1351            Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1352         if (!(eeepc->cm_supported & (1 << cm))
1353             && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1354                 pr_info("%s (%x) not reported by BIOS,"
1355                         " enabling anyway\n", name, 1 << cm);
1356                 eeepc->cm_supported |= 1 << cm;
1357         }
1358 }
1359
1360 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1361 {
1362         cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1363         cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1364         cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1365         cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1366 }
1367
1368 static int __devinit eeepc_acpi_init(struct eeepc_laptop *eeepc)
1369 {
1370         unsigned int init_flags;
1371         int result;
1372
1373         result = acpi_bus_get_status(eeepc->device);
1374         if (result)
1375                 return result;
1376         if (!eeepc->device->status.present) {
1377                 pr_err("Hotkey device not present, aborting\n");
1378                 return -ENODEV;
1379         }
1380
1381         init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1382         pr_notice("Hotkey init flags 0x%x\n", init_flags);
1383
1384         if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1385                 pr_err("Hotkey initialization failed\n");
1386                 return -ENODEV;
1387         }
1388
1389         /* get control methods supported */
1390         if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1391                 pr_err("Get control methods supported failed\n");
1392                 return -ENODEV;
1393         }
1394         cmsg_quirks(eeepc);
1395         pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1396
1397         return 0;
1398 }
1399
1400 static void __devinit eeepc_enable_camera(struct eeepc_laptop *eeepc)
1401 {
1402         /*
1403          * If the following call to set_acpi() fails, it's because there's no
1404          * camera so we can ignore the error.
1405          */
1406         if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1407                 set_acpi(eeepc, CM_ASL_CAMERA, 1);
1408 }
1409
1410 static bool eeepc_device_present;
1411
1412 static int __devinit eeepc_acpi_add(struct acpi_device *device)
1413 {
1414         struct eeepc_laptop *eeepc;
1415         int result;
1416
1417         pr_notice(EEEPC_LAPTOP_NAME "\n");
1418         eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1419         if (!eeepc)
1420                 return -ENOMEM;
1421         eeepc->handle = device->handle;
1422         strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1423         strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1424         device->driver_data = eeepc;
1425         eeepc->device = device;
1426
1427         eeepc->hotplug_disabled = hotplug_disabled;
1428
1429         eeepc_dmi_check(eeepc);
1430
1431         result = eeepc_acpi_init(eeepc);
1432         if (result)
1433                 goto fail_platform;
1434         eeepc_enable_camera(eeepc);
1435
1436         /*
1437          * Register the platform device first.  It is used as a parent for the
1438          * sub-devices below.
1439          *
1440          * Note that if there are multiple instances of this ACPI device it
1441          * will bail out, because the platform device is registered with a
1442          * fixed name.  Of course it doesn't make sense to have more than one,
1443          * and machine-specific scripts find the fixed name convenient.  But
1444          * It's also good for us to exclude multiple instances because both
1445          * our hwmon and our wlan rfkill subdevice use global ACPI objects
1446          * (the EC and the wlan PCI slot respectively).
1447          */
1448         result = eeepc_platform_init(eeepc);
1449         if (result)
1450                 goto fail_platform;
1451
1452         if (!acpi_video_backlight_support()) {
1453                 result = eeepc_backlight_init(eeepc);
1454                 if (result)
1455                         goto fail_backlight;
1456         } else
1457                 pr_info("Backlight controlled by ACPI video driver\n");
1458
1459         result = eeepc_input_init(eeepc);
1460         if (result)
1461                 goto fail_input;
1462
1463         result = eeepc_hwmon_init(eeepc);
1464         if (result)
1465                 goto fail_hwmon;
1466
1467         result = eeepc_led_init(eeepc);
1468         if (result)
1469                 goto fail_led;
1470
1471         result = eeepc_rfkill_init(eeepc);
1472         if (result)
1473                 goto fail_rfkill;
1474
1475         eeepc_device_present = true;
1476         return 0;
1477
1478 fail_rfkill:
1479         eeepc_led_exit(eeepc);
1480 fail_led:
1481         eeepc_hwmon_exit(eeepc);
1482 fail_hwmon:
1483         eeepc_input_exit(eeepc);
1484 fail_input:
1485         eeepc_backlight_exit(eeepc);
1486 fail_backlight:
1487         eeepc_platform_exit(eeepc);
1488 fail_platform:
1489         kfree(eeepc);
1490
1491         return result;
1492 }
1493
1494 static int eeepc_acpi_remove(struct acpi_device *device, int type)
1495 {
1496         struct eeepc_laptop *eeepc = acpi_driver_data(device);
1497
1498         eeepc_backlight_exit(eeepc);
1499         eeepc_rfkill_exit(eeepc);
1500         eeepc_input_exit(eeepc);
1501         eeepc_hwmon_exit(eeepc);
1502         eeepc_led_exit(eeepc);
1503         eeepc_platform_exit(eeepc);
1504
1505         kfree(eeepc);
1506         return 0;
1507 }
1508
1509
1510 static const struct acpi_device_id eeepc_device_ids[] = {
1511         {EEEPC_ACPI_HID, 0},
1512         {"", 0},
1513 };
1514 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1515
1516 static struct acpi_driver eeepc_acpi_driver = {
1517         .name = EEEPC_LAPTOP_NAME,
1518         .class = EEEPC_ACPI_CLASS,
1519         .owner = THIS_MODULE,
1520         .ids = eeepc_device_ids,
1521         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1522         .ops = {
1523                 .add = eeepc_acpi_add,
1524                 .remove = eeepc_acpi_remove,
1525                 .notify = eeepc_acpi_notify,
1526         },
1527 };
1528
1529
1530 static int __init eeepc_laptop_init(void)
1531 {
1532         int result;
1533
1534         result = platform_driver_register(&platform_driver);
1535         if (result < 0)
1536                 return result;
1537
1538         result = acpi_bus_register_driver(&eeepc_acpi_driver);
1539         if (result < 0)
1540                 goto fail_acpi_driver;
1541
1542         if (!eeepc_device_present) {
1543                 result = -ENODEV;
1544                 goto fail_no_device;
1545         }
1546
1547         return 0;
1548
1549 fail_no_device:
1550         acpi_bus_unregister_driver(&eeepc_acpi_driver);
1551 fail_acpi_driver:
1552         platform_driver_unregister(&platform_driver);
1553         return result;
1554 }
1555
1556 static void __exit eeepc_laptop_exit(void)
1557 {
1558         acpi_bus_unregister_driver(&eeepc_acpi_driver);
1559         platform_driver_unregister(&platform_driver);
1560 }
1561
1562 module_init(eeepc_laptop_init);
1563 module_exit(eeepc_laptop_exit);