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