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)
 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 = hotplug_slot->private;
 719         int val = get_acpi(eeepc, CM_ASL_WLAN);
 720
 721         if (val == 1 || val == 0)
 722                 *value = val;
 723         else
 724                 return -EINVAL;
 725
 726         return 0;
 727 }
 728
 729 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
 730         .owner = THIS_MODULE,
 731         .get_adapter_status = eeepc_get_adapter_status,
 732         .get_power_status = eeepc_get_adapter_status,
 733 };
 734
 735 static int eeepc_setup_pci_hotplug(struct eeepc_laptop *eeepc)
 736 {
 737         int ret = -ENOMEM;
 738         struct pci_bus *bus = pci_find_bus(0, 1);
 739
 740         if (!bus) {
 741                 pr_err("Unable to find wifi PCI bus\n");
 742                 return -ENODEV;
 743         }
 744
 745         eeepc->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 746         if (!eeepc->hotplug_slot)
 747                 goto error_slot;
 748
 749         eeepc->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
 750                                             GFP_KERNEL);
 751         if (!eeepc->hotplug_slot->info)
 752                 goto error_info;
 753
 754         eeepc->hotplug_slot->private = eeepc;
 755         eeepc->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
 756         eeepc_get_adapter_status(eeepc->hotplug_slot,
 757                                  &eeepc->hotplug_slot->info->adapter_status);
 758
 759         ret = pci_hp_register(eeepc->hotplug_slot, bus, 0, "eeepc-wifi");
 760         if (ret) {
 761                 pr_err("Unable to register hotplug slot - %d\n", ret);
 762                 goto error_register;
 763         }
 764
 765         return 0;
 766
 767 error_register:
 768         kfree(eeepc->hotplug_slot->info);
 769 error_info:
 770         kfree(eeepc->hotplug_slot);
 771         eeepc->hotplug_slot = NULL;
 772 error_slot:
 773         return ret;
 774 }
 775
 776 /*
 777  * Rfkill devices
 778  */
 779 static int eeepc_rfkill_set(void *data, bool blocked)
 780 {
 781         acpi_handle handle = data;
 782
 783         return write_acpi_int(handle, NULL, !blocked);
 784 }
 785
 786 static const struct rfkill_ops eeepc_rfkill_ops = {
 787         .set_block = eeepc_rfkill_set,
 788 };
 789
 790 static int eeepc_new_rfkill(struct eeepc_laptop *eeepc,
 791                             struct rfkill **rfkill,
 792                             const char *name,
 793                             enum rfkill_type type, int cm)
 794 {
 795         acpi_handle handle;
 796         int result;
 797
 798         result = acpi_setter_handle(eeepc, cm, &handle);
 799         if (result < 0)
 800                 return result;
 801
 802         *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
 803                                &eeepc_rfkill_ops, handle);
 804
 805         if (!*rfkill)
 806                 return -EINVAL;
 807
 808         rfkill_init_sw_state(*rfkill, get_acpi(eeepc, cm) != 1);
 809         result = rfkill_register(*rfkill);
 810         if (result) {
 811                 rfkill_destroy(*rfkill);
 812                 *rfkill = NULL;
 813                 return result;
 814         }
 815         return 0;
 816 }
 817
 818 static char EEEPC_RFKILL_NODE_1[] = "\\_SB.PCI0.P0P5";
 819 static char EEEPC_RFKILL_NODE_2[] = "\\_SB.PCI0.P0P6";
 820 static char EEEPC_RFKILL_NODE_3[] = "\\_SB.PCI0.P0P7";
 821
 822 static void eeepc_rfkill_exit(struct eeepc_laptop *eeepc)
 823 {
 824         eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
 825         eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
 826         eeepc_unregister_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
 827         if (eeepc->wlan_rfkill) {
 828                 rfkill_unregister(eeepc->wlan_rfkill);
 829                 rfkill_destroy(eeepc->wlan_rfkill);
 830                 eeepc->wlan_rfkill = NULL;
 831         }
 832
 833         if (eeepc->hotplug_slot) {
 834                 pci_hp_deregister(eeepc->hotplug_slot);
 835                 kfree(eeepc->hotplug_slot->info);
 836                 kfree(eeepc->hotplug_slot);
 837         }
 838
 839         if (eeepc->bluetooth_rfkill) {
 840                 rfkill_unregister(eeepc->bluetooth_rfkill);
 841                 rfkill_destroy(eeepc->bluetooth_rfkill);
 842                 eeepc->bluetooth_rfkill = NULL;
 843         }
 844         if (eeepc->wwan3g_rfkill) {
 845                 rfkill_unregister(eeepc->wwan3g_rfkill);
 846                 rfkill_destroy(eeepc->wwan3g_rfkill);
 847                 eeepc->wwan3g_rfkill = NULL;
 848         }
 849         if (eeepc->wimax_rfkill) {
 850                 rfkill_unregister(eeepc->wimax_rfkill);
 851                 rfkill_destroy(eeepc->wimax_rfkill);
 852                 eeepc->wimax_rfkill = NULL;
 853         }
 854 }
 855
 856 static int eeepc_rfkill_init(struct eeepc_laptop *eeepc)
 857 {
 858         int result = 0;
 859
 860         mutex_init(&eeepc->hotplug_lock);
 861
 862         result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
 863                                   "eeepc-wlan", RFKILL_TYPE_WLAN,
 864                                   CM_ASL_WLAN);
 865
 866         if (result && result != -ENODEV)
 867                 goto exit;
 868
 869         result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
 870                                   "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
 871                                   CM_ASL_BLUETOOTH);
 872
 873         if (result && result != -ENODEV)
 874                 goto exit;
 875
 876         result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
 877                                   "eeepc-wwan3g", RFKILL_TYPE_WWAN,
 878                                   CM_ASL_3G);
 879
 880         if (result && result != -ENODEV)
 881                 goto exit;
 882
 883         result = eeepc_new_rfkill(eeepc, &eeepc->wimax_rfkill,
 884                                   "eeepc-wimax", RFKILL_TYPE_WIMAX,
 885                                   CM_ASL_WIMAX);
 886
 887         if (result && result != -ENODEV)
 888                 goto exit;
 889
 890         if (eeepc->hotplug_disabled)
 891                 return 0;
 892
 893         result = eeepc_setup_pci_hotplug(eeepc);
 894         /*
 895          * If we get -EBUSY then something else is handling the PCI hotplug -
 896          * don't fail in this case
 897          */
 898         if (result == -EBUSY)
 899                 result = 0;
 900
 901         eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_1);
 902         eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_2);
 903         eeepc_register_rfkill_notifier(eeepc, EEEPC_RFKILL_NODE_3);
 904
 905 exit:
 906         if (result && result != -ENODEV)
 907                 eeepc_rfkill_exit(eeepc);
 908         return result;
 909 }
 910
 911 /*
 912  * Platform driver - hibernate/resume callbacks
 913  */
 914 static int eeepc_hotk_thaw(struct device *device)
 915 {
 916         struct eeepc_laptop *eeepc = dev_get_drvdata(device);
 917
 918         if (eeepc->wlan_rfkill) {
 919                 int wlan;
 920
 921                 /*
 922                  * Work around bios bug - acpi _PTS turns off the wireless led
 923                  * during suspend.  Normally it restores it on resume, but
 924                  * we should kick it ourselves in case hibernation is aborted.
 925                  */
 926                 wlan = get_acpi(eeepc, CM_ASL_WLAN);
 927                 if (wlan >= 0)
 928                         set_acpi(eeepc, CM_ASL_WLAN, wlan);
 929         }
 930
 931         return 0;
 932 }
 933
 934 static int eeepc_hotk_restore(struct device *device)
 935 {
 936         struct eeepc_laptop *eeepc = dev_get_drvdata(device);
 937
 938         /* Refresh both wlan rfkill state and pci hotplug */
 939         if (eeepc->wlan_rfkill) {
 940                 eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_1);
 941                 eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_2);
 942                 eeepc_rfkill_hotplug_update(eeepc, EEEPC_RFKILL_NODE_3);
 943         }
 944
 945         if (eeepc->bluetooth_rfkill)
 946                 rfkill_set_sw_state(eeepc->bluetooth_rfkill,
 947                                     get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
 948         if (eeepc->wwan3g_rfkill)
 949                 rfkill_set_sw_state(eeepc->wwan3g_rfkill,
 950                                     get_acpi(eeepc, CM_ASL_3G) != 1);
 951         if (eeepc->wimax_rfkill)
 952                 rfkill_set_sw_state(eeepc->wimax_rfkill,
 953                                     get_acpi(eeepc, CM_ASL_WIMAX) != 1);
 954
 955         return 0;
 956 }
 957
 958 static const struct dev_pm_ops eeepc_pm_ops = {
 959         .thaw = eeepc_hotk_thaw,
 960         .restore = eeepc_hotk_restore,
 961 };
 962
 963 static struct platform_driver platform_driver = {
 964         .driver = {
 965                 .name = EEEPC_LAPTOP_FILE,
 966                 .pm = &eeepc_pm_ops,
 967         }
 968 };
 969
 970 /*
 971  * Hwmon device
 972  */
 973
 974 #define EEEPC_EC_SC00      0x61
 975 #define EEEPC_EC_FAN_PWM   (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
 976 #define EEEPC_EC_FAN_HRPM  (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
 977 #define EEEPC_EC_FAN_LRPM  (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
 978
 979 #define EEEPC_EC_SFB0      0xD0
 980 #define EEEPC_EC_FAN_CTRL  (EEEPC_EC_SFB0 + 3) /* Byte containing SF25  */
 981
 982 static inline int eeepc_pwm_to_lmsensors(int value)
 983 {
 984         return value * 255 / 100;
 985 }
 986
 987 static inline int eeepc_lmsensors_to_pwm(int value)
 988 {
 989         value = clamp_val(value, 0, 255);
 990         return value * 100 / 255;
 991 }
 992
 993 static int eeepc_get_fan_pwm(void)
 994 {
 995         u8 value = 0;
 996
 997         ec_read(EEEPC_EC_FAN_PWM, &value);
 998         return eeepc_pwm_to_lmsensors(value);
 999 }
1000
1001 static void eeepc_set_fan_pwm(int value)
1002 {
1003         value = eeepc_lmsensors_to_pwm(value);
1004         ec_write(EEEPC_EC_FAN_PWM, value);
1005 }
1006
1007 static int eeepc_get_fan_rpm(void)
1008 {
1009         u8 high = 0;
1010         u8 low = 0;
1011
1012         ec_read(EEEPC_EC_FAN_HRPM, &high);
1013         ec_read(EEEPC_EC_FAN_LRPM, &low);
1014         return high << 8 | low;
1015 }
1016
1017 #define EEEPC_EC_FAN_CTRL_BIT   0x02
1018 #define EEEPC_FAN_CTRL_MANUAL   1
1019 #define EEEPC_FAN_CTRL_AUTO     2
1020
1021 static int eeepc_get_fan_ctrl(void)
1022 {
1023         u8 value = 0;
1024
1025         ec_read(EEEPC_EC_FAN_CTRL, &value);
1026         if (value & EEEPC_EC_FAN_CTRL_BIT)
1027                 return EEEPC_FAN_CTRL_MANUAL;
1028         else
1029                 return EEEPC_FAN_CTRL_AUTO;
1030 }
1031
1032 static void eeepc_set_fan_ctrl(int manual)
1033 {
1034         u8 value = 0;
1035
1036         ec_read(EEEPC_EC_FAN_CTRL, &value);
1037         if (manual == EEEPC_FAN_CTRL_MANUAL)
1038                 value |= EEEPC_EC_FAN_CTRL_BIT;
1039         else
1040                 value &= ~EEEPC_EC_FAN_CTRL_BIT;
1041         ec_write(EEEPC_EC_FAN_CTRL, value);
1042 }
1043
1044 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1045 {
1046         int rv, value;
1047
1048         rv = parse_arg(buf, &value);
1049         if (rv < 0)
1050                 return rv;
1051         set(value);
1052         return count;
1053 }
1054
1055 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1056 {
1057         return sprintf(buf, "%d\n", get());
1058 }
1059
1060 #define EEEPC_SENSOR_SHOW_FUNC(_name, _get)                             \
1061         static ssize_t _name##_show(struct device *dev,                 \
1062                                     struct device_attribute *attr,      \
1063                                     char *buf)                          \
1064         {                                                               \
1065                 return show_sys_hwmon(_get, buf);                       \
1066         }
1067
1068 #define EEEPC_SENSOR_STORE_FUNC(_name, _set)                            \
1069         static ssize_t _name##_store(struct device *dev,                \
1070                                      struct device_attribute *attr,     \
1071                                      const char *buf, size_t count)     \
1072         {                                                               \
1073                 return store_sys_hwmon(_set, buf, count);               \
1074         }
1075
1076 #define EEEPC_CREATE_SENSOR_ATTR_RW(_name, _get, _set)                  \
1077         EEEPC_SENSOR_SHOW_FUNC(_name, _get)                             \
1078         EEEPC_SENSOR_STORE_FUNC(_name, _set)                            \
1079         static DEVICE_ATTR_RW(_name)
1080
1081 #define EEEPC_CREATE_SENSOR_ATTR_RO(_name, _get)                        \
1082         EEEPC_SENSOR_SHOW_FUNC(_name, _get)                             \
1083         static DEVICE_ATTR_RO(_name)
1084
1085 EEEPC_CREATE_SENSOR_ATTR_RO(fan1_input, eeepc_get_fan_rpm);
1086 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1, eeepc_get_fan_pwm,
1087                             eeepc_set_fan_pwm);
1088 EEEPC_CREATE_SENSOR_ATTR_RW(pwm1_enable, eeepc_get_fan_ctrl,
1089                             eeepc_set_fan_ctrl);
1090
1091 static struct attribute *hwmon_attrs[] = {
1092         &dev_attr_pwm1.attr,
1093         &dev_attr_fan1_input.attr,
1094         &dev_attr_pwm1_enable.attr,
1095         NULL
1096 };
1097 ATTRIBUTE_GROUPS(hwmon);
1098
1099 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1100 {
1101         struct device *dev = &eeepc->platform_device->dev;
1102         struct device *hwmon;
1103
1104         hwmon = devm_hwmon_device_register_with_groups(dev, "eeepc", NULL,
1105                                                        hwmon_groups);
1106         if (IS_ERR(hwmon)) {
1107                 pr_err("Could not register eeepc hwmon device\n");
1108                 return PTR_ERR(hwmon);
1109         }
1110         return 0;
1111 }
1112
1113 /*
1114  * Backlight device
1115  */
1116 static int read_brightness(struct backlight_device *bd)
1117 {
1118         struct eeepc_laptop *eeepc = bl_get_data(bd);
1119
1120         return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1121 }
1122
1123 static int set_brightness(struct backlight_device *bd, int value)
1124 {
1125         struct eeepc_laptop *eeepc = bl_get_data(bd);
1126
1127         return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1128 }
1129
1130 static int update_bl_status(struct backlight_device *bd)
1131 {
1132         return set_brightness(bd, bd->props.brightness);
1133 }
1134
1135 static const struct backlight_ops eeepcbl_ops = {
1136         .get_brightness = read_brightness,
1137         .update_status = update_bl_status,
1138 };
1139
1140 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1141 {
1142         struct backlight_device *bd = eeepc->backlight_device;
1143         int old = bd->props.brightness;
1144
1145         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1146
1147         return old;
1148 }
1149
1150 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1151 {
1152         struct backlight_properties props;
1153         struct backlight_device *bd;
1154
1155         memset(&props, 0, sizeof(struct backlight_properties));
1156         props.type = BACKLIGHT_PLATFORM;
1157         props.max_brightness = 15;
1158         bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1159                                        &eeepc->platform_device->dev, eeepc,
1160                                        &eeepcbl_ops, &props);
1161         if (IS_ERR(bd)) {
1162                 pr_err("Could not register eeepc backlight device\n");
1163                 eeepc->backlight_device = NULL;
1164                 return PTR_ERR(bd);
1165         }
1166         eeepc->backlight_device = bd;
1167         bd->props.brightness = read_brightness(bd);
1168         bd->props.power = FB_BLANK_UNBLANK;
1169         backlight_update_status(bd);
1170         return 0;
1171 }
1172
1173 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1174 {
1175         backlight_device_unregister(eeepc->backlight_device);
1176         eeepc->backlight_device = NULL;
1177 }
1178
1179
1180 /*
1181  * Input device (i.e. hotkeys)
1182  */
1183 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1184 {
1185         struct input_dev *input;
1186         int error;
1187
1188         input = input_allocate_device();
1189         if (!input)
1190                 return -ENOMEM;
1191
1192         input->name = "Asus EeePC extra buttons";
1193         input->phys = EEEPC_LAPTOP_FILE "/input0";
1194         input->id.bustype = BUS_HOST;
1195         input->dev.parent = &eeepc->platform_device->dev;
1196
1197         error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1198         if (error) {
1199                 pr_err("Unable to setup input device keymap\n");
1200                 goto err_free_dev;
1201         }
1202
1203         error = input_register_device(input);
1204         if (error) {
1205                 pr_err("Unable to register input device\n");
1206                 goto err_free_dev;
1207         }
1208
1209         eeepc->inputdev = input;
1210         return 0;
1211
1212 err_free_dev:
1213         input_free_device(input);
1214         return error;
1215 }
1216
1217 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1218 {
1219         if (eeepc->inputdev)
1220                 input_unregister_device(eeepc->inputdev);
1221         eeepc->inputdev = NULL;
1222 }
1223
1224 /*
1225  * ACPI driver
1226  */
1227 static void eeepc_input_notify(struct eeepc_laptop *eeepc, int event)
1228 {
1229         if (!eeepc->inputdev)
1230                 return;
1231         if (!sparse_keymap_report_event(eeepc->inputdev, event, 1, true))
1232                 pr_info("Unknown key %x pressed\n", event);
1233 }
1234
1235 static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
1236 {
1237         struct eeepc_laptop *eeepc = acpi_driver_data(device);
1238         int old_brightness, new_brightness;
1239         u16 count;
1240
1241         if (event > ACPI_MAX_SYS_NOTIFY)
1242                 return;
1243         count = eeepc->event_count[event % 128]++;
1244         acpi_bus_generate_netlink_event(device->pnp.device_class,
1245                                         dev_name(&device->dev), event,
1246                                         count);
1247
1248         /* Brightness events are special */
1249         if (event < NOTIFY_BRN_MIN || event > NOTIFY_BRN_MAX) {
1250                 eeepc_input_notify(eeepc, event);
1251                 return;
1252         }
1253
1254         /* Ignore them completely if the acpi video driver is used */
1255         if (!eeepc->backlight_device)
1256                 return;
1257
1258         /* Update the backlight device. */
1259         old_brightness = eeepc_backlight_notify(eeepc);
1260
1261         /* Convert event to keypress (obsolescent hack) */
1262         new_brightness = event - NOTIFY_BRN_MIN;
1263
1264         if (new_brightness < old_brightness) {
1265                 event = NOTIFY_BRN_MIN; /* brightness down */
1266         } else if (new_brightness > old_brightness) {
1267                 event = NOTIFY_BRN_MAX; /* brightness up */
1268         } else {
1269                 /*
1270                  * no change in brightness - already at min/max,
1271                  * event will be desired value (or else ignored)
1272                  */
1273         }
1274         eeepc_input_notify(eeepc, event);
1275 }
1276
1277 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1278 {
1279         const char *model;
1280
1281         model = dmi_get_system_info(DMI_PRODUCT_NAME);
1282         if (!model)
1283                 return;
1284
1285         /*
1286          * Blacklist for setting cpufv (cpu speed).
1287          *
1288          * EeePC 4G ("701") implements CFVS, but it is not supported
1289          * by the pre-installed OS, and the original option to change it
1290          * in the BIOS setup screen was removed in later versions.
1291          *
1292          * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1293          * this applies to all "701" models (4G/4G Surf/2G Surf).
1294          *
1295          * So Asus made a deliberate decision not to support it on this model.
1296          * We have several reports that using it can cause the system to hang
1297          *
1298          * The hang has also been reported on a "702" (Model name "8G"?).
1299          *
1300          * We avoid dmi_check_system() / dmi_match(), because they use
1301          * substring matching.  We don't want to affect the "701SD"
1302          * and "701SDX" models, because they do support S.H.E.
1303          */
1304         if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1305                 eeepc->cpufv_disabled = true;
1306                 pr_info("model %s does not officially support setting cpu speed\n",
1307                         model);
1308                 pr_info("cpufv disabled to avoid instability\n");
1309         }
1310
1311         /*
1312          * Blacklist for wlan hotplug
1313          *
1314          * Eeepc 1005HA doesn't work like others models and don't need the
1315          * hotplug code. In fact, current hotplug code seems to unplug another
1316          * device...
1317          */
1318         if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1319             strcmp(model, "1005PE") == 0) {
1320                 eeepc->hotplug_disabled = true;
1321                 pr_info("wlan hotplug disabled\n");
1322         }
1323 }
1324
1325 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1326 {
1327         int dummy;
1328
1329         /* Some BIOSes do not report cm although it is available.
1330            Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1331         if (!(eeepc->cm_supported & (1 << cm))
1332             && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1333                 pr_info("%s (%x) not reported by BIOS, enabling anyway\n",
1334                         name, 1 << cm);
1335                 eeepc->cm_supported |= 1 << cm;
1336         }
1337 }
1338
1339 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1340 {
1341         cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1342         cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1343         cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1344         cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1345 }
1346
1347 static int eeepc_acpi_init(struct eeepc_laptop *eeepc)
1348 {
1349         unsigned int init_flags;
1350         int result;
1351
1352         result = acpi_bus_get_status(eeepc->device);
1353         if (result)
1354                 return result;
1355         if (!eeepc->device->status.present) {
1356                 pr_err("Hotkey device not present, aborting\n");
1357                 return -ENODEV;
1358         }
1359
1360         init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1361         pr_notice("Hotkey init flags 0x%x\n", init_flags);
1362
1363         if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1364                 pr_err("Hotkey initialization failed\n");
1365                 return -ENODEV;
1366         }
1367
1368         /* get control methods supported */
1369         if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1370                 pr_err("Get control methods supported failed\n");
1371                 return -ENODEV;
1372         }
1373         cmsg_quirks(eeepc);
1374         pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1375
1376         return 0;
1377 }
1378
1379 static void eeepc_enable_camera(struct eeepc_laptop *eeepc)
1380 {
1381         /*
1382          * If the following call to set_acpi() fails, it's because there's no
1383          * camera so we can ignore the error.
1384          */
1385         if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1386                 set_acpi(eeepc, CM_ASL_CAMERA, 1);
1387 }
1388
1389 static bool eeepc_device_present;
1390
1391 static int eeepc_acpi_add(struct acpi_device *device)
1392 {
1393         struct eeepc_laptop *eeepc;
1394         int result;
1395
1396         pr_notice(EEEPC_LAPTOP_NAME "\n");
1397         eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1398         if (!eeepc)
1399                 return -ENOMEM;
1400         eeepc->handle = device->handle;
1401         strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1402         strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1403         device->driver_data = eeepc;
1404         eeepc->device = device;
1405
1406         eeepc->hotplug_disabled = hotplug_disabled;
1407
1408         eeepc_dmi_check(eeepc);
1409
1410         result = eeepc_acpi_init(eeepc);
1411         if (result)
1412                 goto fail_platform;
1413         eeepc_enable_camera(eeepc);
1414
1415         /*
1416          * Register the platform device first.  It is used as a parent for the
1417          * sub-devices below.
1418          *
1419          * Note that if there are multiple instances of this ACPI device it
1420          * will bail out, because the platform device is registered with a
1421          * fixed name.  Of course it doesn't make sense to have more than one,
1422          * and machine-specific scripts find the fixed name convenient.  But
1423          * It's also good for us to exclude multiple instances because both
1424          * our hwmon and our wlan rfkill subdevice use global ACPI objects
1425          * (the EC and the wlan PCI slot respectively).
1426          */
1427         result = eeepc_platform_init(eeepc);
1428         if (result)
1429                 goto fail_platform;
1430
1431         if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1432                 result = eeepc_backlight_init(eeepc);
1433                 if (result)
1434                         goto fail_backlight;
1435         }
1436
1437         result = eeepc_input_init(eeepc);
1438         if (result)
1439                 goto fail_input;
1440
1441         result = eeepc_hwmon_init(eeepc);
1442         if (result)
1443                 goto fail_hwmon;
1444
1445         result = eeepc_led_init(eeepc);
1446         if (result)
1447                 goto fail_led;
1448
1449         result = eeepc_rfkill_init(eeepc);
1450         if (result)
1451                 goto fail_rfkill;
1452
1453         eeepc_device_present = true;
1454         return 0;
1455
1456 fail_rfkill:
1457         eeepc_led_exit(eeepc);
1458 fail_led:
1459 fail_hwmon:
1460         eeepc_input_exit(eeepc);
1461 fail_input:
1462         eeepc_backlight_exit(eeepc);
1463 fail_backlight:
1464         eeepc_platform_exit(eeepc);
1465 fail_platform:
1466         kfree(eeepc);
1467
1468         return result;
1469 }
1470
1471 static int eeepc_acpi_remove(struct acpi_device *device)
1472 {
1473         struct eeepc_laptop *eeepc = acpi_driver_data(device);
1474
1475         eeepc_backlight_exit(eeepc);
1476         eeepc_rfkill_exit(eeepc);
1477         eeepc_input_exit(eeepc);
1478         eeepc_led_exit(eeepc);
1479         eeepc_platform_exit(eeepc);
1480
1481         kfree(eeepc);
1482         return 0;
1483 }
1484
1485
1486 static const struct acpi_device_id eeepc_device_ids[] = {
1487         {EEEPC_ACPI_HID, 0},
1488         {"", 0},
1489 };
1490 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1491
1492 static struct acpi_driver eeepc_acpi_driver = {
1493         .name = EEEPC_LAPTOP_NAME,
1494         .class = EEEPC_ACPI_CLASS,
1495         .owner = THIS_MODULE,
1496         .ids = eeepc_device_ids,
1497         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1498         .ops = {
1499                 .add = eeepc_acpi_add,
1500                 .remove = eeepc_acpi_remove,
1501                 .notify = eeepc_acpi_notify,
1502         },
1503 };
1504
1505
1506 static int __init eeepc_laptop_init(void)
1507 {
1508         int result;
1509
1510         result = platform_driver_register(&platform_driver);
1511         if (result < 0)
1512                 return result;
1513
1514         result = acpi_bus_register_driver(&eeepc_acpi_driver);
1515         if (result < 0)
1516                 goto fail_acpi_driver;
1517
1518         if (!eeepc_device_present) {
1519                 result = -ENODEV;
1520                 goto fail_no_device;
1521         }
1522
1523         return 0;
1524
1525 fail_no_device:
1526         acpi_bus_unregister_driver(&eeepc_acpi_driver);
1527 fail_acpi_driver:
1528         platform_driver_unregister(&platform_driver);
1529         return result;
1530 }
1531
1532 static void __exit eeepc_laptop_exit(void)
1533 {
1534         acpi_bus_unregister_driver(&eeepc_acpi_driver);
1535         platform_driver_unregister(&platform_driver);
1536 }
1537
1538 module_init(eeepc_laptop_init);
1539 module_exit(eeepc_laptop_exit);