drivers/platform/x86/eeepc-laptop.c

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