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