drivers/platform/x86/eeepc-laptop.c

   1 /*
   2  *  eepc-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 <acpi/acpi_drivers.h>
  31 #include <acpi/acpi_bus.h>
  32 #include <linux/uaccess.h>
  33 #include <linux/input.h>
  34 #include <linux/rfkill.h>
  35 #include <linux/pci.h>
  36 #include <linux/pci_hotplug.h>
  37
  38 #define EEEPC_LAPTOP_VERSION    "0.1"
  39
  40 #define EEEPC_HOTK_NAME         "Eee PC Hotkey Driver"
  41 #define EEEPC_HOTK_FILE         "eeepc"
  42 #define EEEPC_HOTK_CLASS        "hotkey"
  43 #define EEEPC_HOTK_DEVICE_NAME  "Hotkey"
  44 #define EEEPC_HOTK_HID          "ASUS010"
  45
  46
  47 /*
  48  * Definitions for Asus EeePC
  49  */
  50 #define NOTIFY_WLAN_ON  0x10
  51 #define NOTIFY_BRN_MIN  0x20
  52 #define NOTIFY_BRN_MAX  0x2f
  53
  54 enum {
  55         DISABLE_ASL_WLAN = 0x0001,
  56         DISABLE_ASL_BLUETOOTH = 0x0002,
  57         DISABLE_ASL_IRDA = 0x0004,
  58         DISABLE_ASL_CAMERA = 0x0008,
  59         DISABLE_ASL_TV = 0x0010,
  60         DISABLE_ASL_GPS = 0x0020,
  61         DISABLE_ASL_DISPLAYSWITCH = 0x0040,
  62         DISABLE_ASL_MODEM = 0x0080,
  63         DISABLE_ASL_CARDREADER = 0x0100,
  64         DISABLE_ASL_3G = 0x0200,
  65         DISABLE_ASL_WIMAX = 0x0400,
  66         DISABLE_ASL_HWCF = 0x0800
  67 };
  68
  69 enum {
  70         CM_ASL_WLAN = 0,
  71         CM_ASL_BLUETOOTH,
  72         CM_ASL_IRDA,
  73         CM_ASL_1394,
  74         CM_ASL_CAMERA,
  75         CM_ASL_TV,
  76         CM_ASL_GPS,
  77         CM_ASL_DVDROM,
  78         CM_ASL_DISPLAYSWITCH,
  79         CM_ASL_PANELBRIGHT,
  80         CM_ASL_BIOSFLASH,
  81         CM_ASL_ACPIFLASH,
  82         CM_ASL_CPUFV,
  83         CM_ASL_CPUTEMPERATURE,
  84         CM_ASL_FANCPU,
  85         CM_ASL_FANCHASSIS,
  86         CM_ASL_USBPORT1,
  87         CM_ASL_USBPORT2,
  88         CM_ASL_USBPORT3,
  89         CM_ASL_MODEM,
  90         CM_ASL_CARDREADER,
  91         CM_ASL_3G,
  92         CM_ASL_WIMAX,
  93         CM_ASL_HWCF,
  94         CM_ASL_LID,
  95         CM_ASL_TYPE,
  96         CM_ASL_PANELPOWER,      /*P901*/
  97         CM_ASL_TPD
  98 };
  99
 100 static const char *cm_getv[] = {
 101         "WLDG", "BTHG", NULL, NULL,
 102         "CAMG", NULL, NULL, NULL,
 103         NULL, "PBLG", NULL, NULL,
 104         "CFVG", NULL, NULL, NULL,
 105         "USBG", NULL, NULL, "MODG",
 106         "CRDG", "M3GG", "WIMG", "HWCF",
 107         "LIDG", "TYPE", "PBPG", "TPDG"
 108 };
 109
 110 static const char *cm_setv[] = {
 111         "WLDS", "BTHS", NULL, NULL,
 112         "CAMS", NULL, NULL, NULL,
 113         "SDSP", "PBLS", "HDPS", NULL,
 114         "CFVS", NULL, NULL, NULL,
 115         "USBG", NULL, NULL, "MODS",
 116         "CRDS", "M3GS", "WIMS", NULL,
 117         NULL, NULL, "PBPS", "TPDS"
 118 };
 119
 120 #define EEEPC_EC        "\\_SB.PCI0.SBRG.EC0."
 121
 122 #define EEEPC_EC_FAN_PWM        EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
 123 #define EEEPC_EC_SC02           0x63
 124 #define EEEPC_EC_FAN_HRPM       EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
 125 #define EEEPC_EC_FAN_LRPM       EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
 126 #define EEEPC_EC_FAN_CTRL       EEEPC_EC "SFB3" /* Byte containing SF25  */
 127 #define EEEPC_EC_SFB3           0xD3
 128
 129 /*
 130  * This is the main structure, we can use it to store useful information
 131  * about the hotk device
 132  */
 133 struct eeepc_hotk {
 134         struct acpi_device *device;     /* the device we are in */
 135         acpi_handle handle;             /* the handle of the hotk device */
 136         u32 cm_supported;               /* the control methods supported
 137                                            by this BIOS */
 138         uint init_flag;                 /* Init flags */
 139         u16 event_count[128];           /* count for each event */
 140         struct input_dev *inputdev;
 141         u16 *keycode_map;
 142         struct rfkill *wlan_rfkill;
 143         struct rfkill *bluetooth_rfkill;
 144         struct rfkill *wwan3g_rfkill;
 145         struct rfkill *wimax_rfkill;
 146         struct hotplug_slot *hotplug_slot;
 147         struct mutex hotplug_lock;
 148 };
 149
 150 /* The actual device the driver binds to */
 151 static struct eeepc_hotk *ehotk;
 152
 153 static void eeepc_rfkill_hotplug(bool real);
 154
 155 /* Platform device/driver */
 156 static int eeepc_hotk_thaw(struct device *device);
 157 static int eeepc_hotk_restore(struct device *device);
 158
 159 static struct dev_pm_ops eeepc_pm_ops = {
 160         .thaw = eeepc_hotk_thaw,
 161         .restore = eeepc_hotk_restore,
 162 };
 163
 164 static struct platform_driver platform_driver = {
 165         .driver = {
 166                 .name = EEEPC_HOTK_FILE,
 167                 .owner = THIS_MODULE,
 168                 .pm = &eeepc_pm_ops,
 169         }
 170 };
 171
 172 static struct platform_device *platform_device;
 173
 174 struct key_entry {
 175         char type;
 176         u8 code;
 177         u16 keycode;
 178 };
 179
 180 enum { KE_KEY, KE_END };
 181
 182 static struct key_entry eeepc_keymap[] = {
 183         /* Sleep already handled via generic ACPI code */
 184         {KE_KEY, 0x10, KEY_WLAN },
 185         {KE_KEY, 0x11, KEY_WLAN },
 186         {KE_KEY, 0x12, KEY_PROG1 },
 187         {KE_KEY, 0x13, KEY_MUTE },
 188         {KE_KEY, 0x14, KEY_VOLUMEDOWN },
 189         {KE_KEY, 0x15, KEY_VOLUMEUP },
 190         {KE_KEY, 0x1a, KEY_COFFEE },
 191         {KE_KEY, 0x1b, KEY_ZOOM },
 192         {KE_KEY, 0x1c, KEY_PROG2 },
 193         {KE_KEY, 0x1d, KEY_PROG3 },
 194         {KE_KEY, NOTIFY_BRN_MIN,     KEY_BRIGHTNESSDOWN },
 195         {KE_KEY, NOTIFY_BRN_MIN + 2, KEY_BRIGHTNESSUP },
 196         {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE },
 197         {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE },
 198         {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE },
 199         {KE_END, 0},
 200 };
 201
 202 /*
 203  * The hotkey driver declaration
 204  */
 205 static int eeepc_hotk_add(struct acpi_device *device);
 206 static int eeepc_hotk_remove(struct acpi_device *device, int type);
 207 static void eeepc_hotk_notify(struct acpi_device *device, u32 event);
 208
 209 static const struct acpi_device_id eeepc_device_ids[] = {
 210         {EEEPC_HOTK_HID, 0},
 211         {"", 0},
 212 };
 213 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
 214
 215 static struct acpi_driver eeepc_hotk_driver = {
 216         .name = EEEPC_HOTK_NAME,
 217         .class = EEEPC_HOTK_CLASS,
 218         .ids = eeepc_device_ids,
 219         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
 220         .ops = {
 221                 .add = eeepc_hotk_add,
 222                 .remove = eeepc_hotk_remove,
 223                 .notify = eeepc_hotk_notify,
 224         },
 225 };
 226
 227 /* PCI hotplug ops */
 228 static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value);
 229
 230 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
 231         .owner = THIS_MODULE,
 232         .get_adapter_status = eeepc_get_adapter_status,
 233         .get_power_status = eeepc_get_adapter_status,
 234 };
 235
 236 /* The backlight device /sys/class/backlight */
 237 static struct backlight_device *eeepc_backlight_device;
 238
 239 /* The hwmon device */
 240 static struct device *eeepc_hwmon_device;
 241
 242 /*
 243  * The backlight class declaration
 244  */
 245 static int read_brightness(struct backlight_device *bd);
 246 static int update_bl_status(struct backlight_device *bd);
 247 static struct backlight_ops eeepcbl_ops = {
 248         .get_brightness = read_brightness,
 249         .update_status = update_bl_status,
 250 };
 251
 252 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
 253 MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
 254 MODULE_LICENSE("GPL");
 255
 256 /*
 257  * ACPI Helpers
 258  */
 259 static int write_acpi_int(acpi_handle handle, const char *method, int val,
 260                           struct acpi_buffer *output)
 261 {
 262         struct acpi_object_list params;
 263         union acpi_object in_obj;
 264         acpi_status status;
 265
 266         params.count = 1;
 267         params.pointer = &in_obj;
 268         in_obj.type = ACPI_TYPE_INTEGER;
 269         in_obj.integer.value = val;
 270
 271         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 272         return (status == AE_OK ? 0 : -1);
 273 }
 274
 275 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
 276 {
 277         acpi_status status;
 278         unsigned long long result;
 279
 280         status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
 281         if (ACPI_FAILURE(status)) {
 282                 *val = -1;
 283                 return -1;
 284         } else {
 285                 *val = result;
 286                 return 0;
 287         }
 288 }
 289
 290 static int set_acpi(int cm, int value)
 291 {
 292         if (ehotk->cm_supported & (0x1 << cm)) {
 293                 const char *method = cm_setv[cm];
 294                 if (method == NULL)
 295                         return -ENODEV;
 296                 if (write_acpi_int(ehotk->handle, method, value, NULL))
 297                         pr_warning("Error writing %s\n", method);
 298         }
 299         return 0;
 300 }
 301
 302 static int get_acpi(int cm)
 303 {
 304         int value = -ENODEV;
 305         if ((ehotk->cm_supported & (0x1 << cm))) {
 306                 const char *method = cm_getv[cm];
 307                 if (method == NULL)
 308                         return -ENODEV;
 309                 if (read_acpi_int(ehotk->handle, method, &value))
 310                         pr_warning("Error reading %s\n", method);
 311         }
 312         return value;
 313 }
 314
 315 /*
 316  * Backlight
 317  */
 318 static int read_brightness(struct backlight_device *bd)
 319 {
 320         return get_acpi(CM_ASL_PANELBRIGHT);
 321 }
 322
 323 static int set_brightness(struct backlight_device *bd, int value)
 324 {
 325         value = max(0, min(15, value));
 326         return set_acpi(CM_ASL_PANELBRIGHT, value);
 327 }
 328
 329 static int update_bl_status(struct backlight_device *bd)
 330 {
 331         return set_brightness(bd, bd->props.brightness);
 332 }
 333
 334 /*
 335  * Rfkill helpers
 336  */
 337
 338 static bool eeepc_wlan_rfkill_blocked(void)
 339 {
 340         if (get_acpi(CM_ASL_WLAN) == 1)
 341                 return false;
 342         return true;
 343 }
 344
 345 static int eeepc_rfkill_set(void *data, bool blocked)
 346 {
 347         unsigned long asl = (unsigned long)data;
 348         int ret;
 349
 350         if (asl != CM_ASL_WLAN)
 351                 return set_acpi(asl, !blocked);
 352
 353         /* hack to avoid panic with rt2860sta */
 354         if (blocked)
 355                 eeepc_rfkill_hotplug(false);
 356         ret = set_acpi(asl, !blocked);
 357         return ret;
 358 }
 359
 360 static const struct rfkill_ops eeepc_rfkill_ops = {
 361         .set_block = eeepc_rfkill_set,
 362 };
 363
 364 static void __devinit eeepc_enable_camera(void)
 365 {
 366         /*
 367          * If the following call to set_acpi() fails, it's because there's no
 368          * camera so we can ignore the error.
 369          */
 370         set_acpi(CM_ASL_CAMERA, 1);
 371 }
 372
 373 /*
 374  * Sys helpers
 375  */
 376 static int parse_arg(const char *buf, unsigned long count, int *val)
 377 {
 378         if (!count)
 379                 return 0;
 380         if (sscanf(buf, "%i", val) != 1)
 381                 return -EINVAL;
 382         return count;
 383 }
 384
 385 static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
 386 {
 387         int rv, value;
 388
 389         rv = parse_arg(buf, count, &value);
 390         if (rv > 0)
 391                 value = set_acpi(cm, value);
 392         if (value < 0)
 393                 return value;
 394         return rv;
 395 }
 396
 397 static ssize_t show_sys_acpi(int cm, char *buf)
 398 {
 399         int value = get_acpi(cm);
 400
 401         if (value < 0)
 402                 return value;
 403         return sprintf(buf, "%d\n", value);
 404 }
 405
 406 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)                            \
 407         static ssize_t show_##_name(struct device *dev,                 \
 408                                     struct device_attribute *attr,      \
 409                                     char *buf)                          \
 410         {                                                               \
 411                 return show_sys_acpi(_cm, buf);                         \
 412         }                                                               \
 413         static ssize_t store_##_name(struct device *dev,                \
 414                                      struct device_attribute *attr,     \
 415                                      const char *buf, size_t count)     \
 416         {                                                               \
 417                 return store_sys_acpi(_cm, buf, count);                 \
 418         }                                                               \
 419         static struct device_attribute dev_attr_##_name = {             \
 420                 .attr = {                                               \
 421                         .name = __stringify(_name),                     \
 422                         .mode = 0644 },                                 \
 423                 .show   = show_##_name,                                 \
 424                 .store  = store_##_name,                                \
 425         }
 426
 427 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
 428 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
 429 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
 430
 431 struct eeepc_cpufv {
 432         int num;
 433         int cur;
 434 };
 435
 436 static int get_cpufv(struct eeepc_cpufv *c)
 437 {
 438         c->cur = get_acpi(CM_ASL_CPUFV);
 439         c->num = (c->cur >> 8) & 0xff;
 440         c->cur &= 0xff;
 441         if (c->cur < 0 || c->num <= 0 || c->num > 12)
 442                 return -ENODEV;
 443         return 0;
 444 }
 445
 446 static ssize_t show_available_cpufv(struct device *dev,
 447                                     struct device_attribute *attr,
 448                                     char *buf)
 449 {
 450         struct eeepc_cpufv c;
 451         int i;
 452         ssize_t len = 0;
 453
 454         if (get_cpufv(&c))
 455                 return -ENODEV;
 456         for (i = 0; i < c.num; i++)
 457                 len += sprintf(buf + len, "%d ", i);
 458         len += sprintf(buf + len, "\n");
 459         return len;
 460 }
 461
 462 static ssize_t show_cpufv(struct device *dev,
 463                           struct device_attribute *attr,
 464                           char *buf)
 465 {
 466         struct eeepc_cpufv c;
 467
 468         if (get_cpufv(&c))
 469                 return -ENODEV;
 470         return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
 471 }
 472
 473 static ssize_t store_cpufv(struct device *dev,
 474                            struct device_attribute *attr,
 475                            const char *buf, size_t count)
 476 {
 477         struct eeepc_cpufv c;
 478         int rv, value;
 479
 480         if (get_cpufv(&c))
 481                 return -ENODEV;
 482         rv = parse_arg(buf, count, &value);
 483         if (rv < 0)
 484                 return rv;
 485         if (!rv || value < 0 || value >= c.num)
 486                 return -EINVAL;
 487         set_acpi(CM_ASL_CPUFV, value);
 488         return rv;
 489 }
 490
 491 static struct device_attribute dev_attr_cpufv = {
 492         .attr = {
 493                 .name = "cpufv",
 494                 .mode = 0644 },
 495         .show   = show_cpufv,
 496         .store  = store_cpufv
 497 };
 498
 499 static struct device_attribute dev_attr_available_cpufv = {
 500         .attr = {
 501                 .name = "available_cpufv",
 502                 .mode = 0444 },
 503         .show   = show_available_cpufv
 504 };
 505
 506 static struct attribute *platform_attributes[] = {
 507         &dev_attr_camera.attr,
 508         &dev_attr_cardr.attr,
 509         &dev_attr_disp.attr,
 510         &dev_attr_cpufv.attr,
 511         &dev_attr_available_cpufv.attr,
 512         NULL
 513 };
 514
 515 static struct attribute_group platform_attribute_group = {
 516         .attrs = platform_attributes
 517 };
 518
 519 /*
 520  * Hotkey functions
 521  */
 522 static struct key_entry *eepc_get_entry_by_scancode(int code)
 523 {
 524         struct key_entry *key;
 525
 526         for (key = eeepc_keymap; key->type != KE_END; key++)
 527                 if (code == key->code)
 528                         return key;
 529
 530         return NULL;
 531 }
 532
 533 static struct key_entry *eepc_get_entry_by_keycode(int code)
 534 {
 535         struct key_entry *key;
 536
 537         for (key = eeepc_keymap; key->type != KE_END; key++)
 538                 if (code == key->keycode && key->type == KE_KEY)
 539                         return key;
 540
 541         return NULL;
 542 }
 543
 544 static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
 545 {
 546         struct key_entry *key = eepc_get_entry_by_scancode(scancode);
 547
 548         if (key && key->type == KE_KEY) {
 549                 *keycode = key->keycode;
 550                 return 0;
 551         }
 552
 553         return -EINVAL;
 554 }
 555
 556 static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
 557 {
 558         struct key_entry *key;
 559         int old_keycode;
 560
 561         if (keycode < 0 || keycode > KEY_MAX)
 562                 return -EINVAL;
 563
 564         key = eepc_get_entry_by_scancode(scancode);
 565         if (key && key->type == KE_KEY) {
 566                 old_keycode = key->keycode;
 567                 key->keycode = keycode;
 568                 set_bit(keycode, dev->keybit);
 569                 if (!eepc_get_entry_by_keycode(old_keycode))
 570                         clear_bit(old_keycode, dev->keybit);
 571                 return 0;
 572         }
 573
 574         return -EINVAL;
 575 }
 576
 577 static void cmsg_quirk(int cm, const char *name)
 578 {
 579         int dummy;
 580
 581         /* Some BIOSes do not report cm although it is avaliable.
 582            Check if cm_getv[cm] works and, if yes, assume cm should be set. */
 583         if (!(ehotk->cm_supported & (1 << cm))
 584             && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
 585                 pr_info("%s (%x) not reported by BIOS,"
 586                         " enabling anyway\n", name, 1 << cm);
 587                 ehotk->cm_supported |= 1 << cm;
 588         }
 589 }
 590
 591 static void cmsg_quirks(void)
 592 {
 593         cmsg_quirk(CM_ASL_LID, "LID");
 594         cmsg_quirk(CM_ASL_TYPE, "TYPE");
 595         cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
 596         cmsg_quirk(CM_ASL_TPD, "TPD");
 597 }
 598
 599 static int eeepc_hotk_check(void)
 600 {
 601         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 602         int result;
 603
 604         result = acpi_bus_get_status(ehotk->device);
 605         if (result)
 606                 return result;
 607         if (ehotk->device->status.present) {
 608                 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
 609                                     &buffer)) {
 610                         pr_err("Hotkey initialization failed\n");
 611                         return -ENODEV;
 612                 } else {
 613                         pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
 614                 }
 615                 /* get control methods supported */
 616                 if (read_acpi_int(ehotk->handle, "CMSG"
 617                                    , &ehotk->cm_supported)) {
 618                         pr_err("Get control methods supported failed\n");
 619                         return -ENODEV;
 620                 } else {
 621                         cmsg_quirks();
 622                         pr_info("Get control methods supported: 0x%x\n",
 623                                 ehotk->cm_supported);
 624                 }
 625         } else {
 626                 pr_err("Hotkey device not present, aborting\n");
 627                 return -EINVAL;
 628         }
 629         return 0;
 630 }
 631
 632 static int notify_brn(void)
 633 {
 634         /* returns the *previous* brightness, or -1 */
 635         struct backlight_device *bd = eeepc_backlight_device;
 636         if (bd) {
 637                 int old = bd->props.brightness;
 638                 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
 639                 return old;
 640         }
 641         return -1;
 642 }
 643
 644 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
 645                                     u8 *value)
 646 {
 647         int val = get_acpi(CM_ASL_WLAN);
 648
 649         if (val == 1 || val == 0)
 650                 *value = val;
 651         else
 652                 return -EINVAL;
 653
 654         return 0;
 655 }
 656
 657 static void eeepc_rfkill_hotplug(bool real)
 658 {
 659         struct pci_dev *dev;
 660         struct pci_bus *bus;
 661         bool blocked = real ? eeepc_wlan_rfkill_blocked() : true;
 662
 663         if (real && ehotk->wlan_rfkill)
 664                 rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
 665
 666         mutex_lock(&ehotk->hotplug_lock);
 667
 668         if (ehotk->hotplug_slot) {
 669                 bus = pci_find_bus(0, 1);
 670                 if (!bus) {
 671                         pr_warning("Unable to find PCI bus 1?\n");
 672                         goto out_unlock;
 673                 }
 674
 675                 if (!blocked) {
 676                         dev = pci_get_slot(bus, 0);
 677                         if (dev) {
 678                                 /* Device already present */
 679                                 pci_dev_put(dev);
 680                                 goto out_unlock;
 681                         }
 682                         dev = pci_scan_single_device(bus, 0);
 683                         if (dev) {
 684                                 pci_bus_assign_resources(bus);
 685                                 if (pci_bus_add_device(dev))
 686                                         pr_err("Unable to hotplug wifi\n");
 687                         }
 688                 } else {
 689                         dev = pci_get_slot(bus, 0);
 690                         if (dev) {
 691                                 pci_remove_bus_device(dev);
 692                                 pci_dev_put(dev);
 693                         }
 694                 }
 695         }
 696
 697 out_unlock:
 698         mutex_unlock(&ehotk->hotplug_lock);
 699 }
 700
 701 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 702 {
 703         if (event != ACPI_NOTIFY_BUS_CHECK)
 704                 return;
 705
 706         eeepc_rfkill_hotplug(true);
 707 }
 708
 709 static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
 710 {
 711         static struct key_entry *key;
 712         u16 count;
 713         int brn = -ENODEV;
 714
 715         if (!ehotk)
 716                 return;
 717         if (event > ACPI_MAX_SYS_NOTIFY)
 718                 return;
 719         if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
 720                 brn = notify_brn();
 721         count = ehotk->event_count[event % 128]++;
 722         acpi_bus_generate_proc_event(ehotk->device, event, count);
 723         acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class,
 724                                         dev_name(&ehotk->device->dev), event,
 725                                         count);
 726         if (ehotk->inputdev) {
 727                 if (brn != -ENODEV) {
 728                         /* brightness-change events need special
 729                          * handling for conversion to key events
 730                          */
 731                         if (brn < 0)
 732                                 brn = event;
 733                         else
 734                                 brn += NOTIFY_BRN_MIN;
 735                         if (event < brn)
 736                                 event = NOTIFY_BRN_MIN; /* brightness down */
 737                         else if (event > brn)
 738                                 event = NOTIFY_BRN_MIN + 2; /* ... up */
 739                         else
 740                                 event = NOTIFY_BRN_MIN + 1; /* ... unchanged */
 741                 }
 742                 key = eepc_get_entry_by_scancode(event);
 743                 if (key) {
 744                         switch (key->type) {
 745                         case KE_KEY:
 746                                 input_report_key(ehotk->inputdev, key->keycode,
 747                                                  1);
 748                                 input_sync(ehotk->inputdev);
 749                                 input_report_key(ehotk->inputdev, key->keycode,
 750                                                  0);
 751                                 input_sync(ehotk->inputdev);
 752                                 break;
 753                         }
 754                 }
 755         }
 756 }
 757
 758 static int eeepc_register_rfkill_notifier(char *node)
 759 {
 760         acpi_status status = AE_OK;
 761         acpi_handle handle;
 762
 763         status = acpi_get_handle(NULL, node, &handle);
 764
 765         if (ACPI_SUCCESS(status)) {
 766                 status = acpi_install_notify_handler(handle,
 767                                                      ACPI_SYSTEM_NOTIFY,
 768                                                      eeepc_rfkill_notify,
 769                                                      NULL);
 770                 if (ACPI_FAILURE(status))
 771                         pr_warning("Failed to register notify on %s\n", node);
 772         } else
 773                 return -ENODEV;
 774
 775         return 0;
 776 }
 777
 778 static void eeepc_unregister_rfkill_notifier(char *node)
 779 {
 780         acpi_status status = AE_OK;
 781         acpi_handle handle;
 782
 783         status = acpi_get_handle(NULL, node, &handle);
 784
 785         if (ACPI_SUCCESS(status)) {
 786                 status = acpi_remove_notify_handler(handle,
 787                                                      ACPI_SYSTEM_NOTIFY,
 788                                                      eeepc_rfkill_notify);
 789                 if (ACPI_FAILURE(status))
 790                         pr_err("Error removing rfkill notify handler %s\n",
 791                                 node);
 792         }
 793 }
 794
 795 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
 796 {
 797         kfree(hotplug_slot->info);
 798         kfree(hotplug_slot);
 799 }
 800
 801 static int eeepc_setup_pci_hotplug(void)
 802 {
 803         int ret = -ENOMEM;
 804         struct pci_bus *bus = pci_find_bus(0, 1);
 805
 806         if (!bus) {
 807                 pr_err("Unable to find wifi PCI bus\n");
 808                 return -ENODEV;
 809         }
 810
 811         ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 812         if (!ehotk->hotplug_slot)
 813                 goto error_slot;
 814
 815         ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
 816                                             GFP_KERNEL);
 817         if (!ehotk->hotplug_slot->info)
 818                 goto error_info;
 819
 820         ehotk->hotplug_slot->private = ehotk;
 821         ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
 822         ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
 823         eeepc_get_adapter_status(ehotk->hotplug_slot,
 824                                  &ehotk->hotplug_slot->info->adapter_status);
 825
 826         ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
 827         if (ret) {
 828                 pr_err("Unable to register hotplug slot - %d\n", ret);
 829                 goto error_register;
 830         }
 831
 832         return 0;
 833
 834 error_register:
 835         kfree(ehotk->hotplug_slot->info);
 836 error_info:
 837         kfree(ehotk->hotplug_slot);
 838         ehotk->hotplug_slot = NULL;
 839 error_slot:
 840         return ret;
 841 }
 842
 843 static int eeepc_hotk_thaw(struct device *device)
 844 {
 845         if (ehotk->wlan_rfkill) {
 846                 bool wlan;
 847
 848                 /*
 849                  * Work around bios bug - acpi _PTS turns off the wireless led
 850                  * during suspend.  Normally it restores it on resume, but
 851                  * we should kick it ourselves in case hibernation is aborted.
 852                  */
 853                 wlan = get_acpi(CM_ASL_WLAN);
 854                 set_acpi(CM_ASL_WLAN, wlan);
 855         }
 856
 857         return 0;
 858 }
 859
 860 static int eeepc_hotk_restore(struct device *device)
 861 {
 862         /* Refresh both wlan rfkill state and pci hotplug */
 863         if (ehotk->wlan_rfkill)
 864                 eeepc_rfkill_hotplug(true);
 865
 866         if (ehotk->bluetooth_rfkill)
 867                 rfkill_set_sw_state(ehotk->bluetooth_rfkill,
 868                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
 869         if (ehotk->wwan3g_rfkill)
 870                 rfkill_set_sw_state(ehotk->wwan3g_rfkill,
 871                                     get_acpi(CM_ASL_3G) != 1);
 872         if (ehotk->wimax_rfkill)
 873                 rfkill_set_sw_state(ehotk->wimax_rfkill,
 874                                     get_acpi(CM_ASL_WIMAX) != 1);
 875
 876         return 0;
 877 }
 878
 879 /*
 880  * Hwmon
 881  */
 882 static int eeepc_get_fan_pwm(void)
 883 {
 884         int value = 0;
 885
 886         read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
 887         value = value * 255 / 100;
 888         return (value);
 889 }
 890
 891 static void eeepc_set_fan_pwm(int value)
 892 {
 893         value = SENSORS_LIMIT(value, 0, 255);
 894         value = value * 100 / 255;
 895         ec_write(EEEPC_EC_SC02, value);
 896 }
 897
 898 static int eeepc_get_fan_rpm(void)
 899 {
 900         int high = 0;
 901         int low = 0;
 902
 903         read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
 904         read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
 905         return (high << 8 | low);
 906 }
 907
 908 static int eeepc_get_fan_ctrl(void)
 909 {
 910         int value = 0;
 911
 912         read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
 913         return ((value & 0x02 ? 1 : 0));
 914 }
 915
 916 static void eeepc_set_fan_ctrl(int manual)
 917 {
 918         int value = 0;
 919
 920         read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
 921         if (manual)
 922                 value |= 0x02;
 923         else
 924                 value &= ~0x02;
 925         ec_write(EEEPC_EC_SFB3, value);
 926 }
 927
 928 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
 929 {
 930         int rv, value;
 931
 932         rv = parse_arg(buf, count, &value);
 933         if (rv > 0)
 934                 set(value);
 935         return rv;
 936 }
 937
 938 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
 939 {
 940         return sprintf(buf, "%d\n", get());
 941 }
 942
 943 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get)              \
 944         static ssize_t show_##_name(struct device *dev,                 \
 945                                     struct device_attribute *attr,      \
 946                                     char *buf)                          \
 947         {                                                               \
 948                 return show_sys_hwmon(_set, buf);                       \
 949         }                                                               \
 950         static ssize_t store_##_name(struct device *dev,                \
 951                                      struct device_attribute *attr,     \
 952                                      const char *buf, size_t count)     \
 953         {                                                               \
 954                 return store_sys_hwmon(_get, buf, count);               \
 955         }                                                               \
 956         static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
 957
 958 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
 959 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
 960                          eeepc_get_fan_pwm, eeepc_set_fan_pwm);
 961 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
 962                          eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
 963
 964 static ssize_t
 965 show_name(struct device *dev, struct device_attribute *attr, char *buf)
 966 {
 967         return sprintf(buf, "eeepc\n");
 968 }
 969 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
 970
 971 static struct attribute *hwmon_attributes[] = {
 972         &sensor_dev_attr_pwm1.dev_attr.attr,
 973         &sensor_dev_attr_fan1_input.dev_attr.attr,
 974         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 975         &sensor_dev_attr_name.dev_attr.attr,
 976         NULL
 977 };
 978
 979 static struct attribute_group hwmon_attribute_group = {
 980         .attrs = hwmon_attributes
 981 };
 982
 983 /*
 984  * exit/init
 985  */
 986 static void eeepc_backlight_exit(void)
 987 {
 988         if (eeepc_backlight_device)
 989                 backlight_device_unregister(eeepc_backlight_device);
 990         eeepc_backlight_device = NULL;
 991 }
 992
 993 static void eeepc_rfkill_exit(void)
 994 {
 995         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
 996         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
 997         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
 998         if (ehotk->wlan_rfkill) {
 999                 rfkill_unregister(ehotk->wlan_rfkill);
1000                 rfkill_destroy(ehotk->wlan_rfkill);
1001                 ehotk->wlan_rfkill = NULL;
1002         }
1003         /*
1004          * Refresh pci hotplug in case the rfkill state was changed after
1005          * eeepc_unregister_rfkill_notifier()
1006          */
1007         eeepc_rfkill_hotplug(true);
1008         if (ehotk->hotplug_slot)
1009                 pci_hp_deregister(ehotk->hotplug_slot);
1010
1011         if (ehotk->bluetooth_rfkill) {
1012                 rfkill_unregister(ehotk->bluetooth_rfkill);
1013                 rfkill_destroy(ehotk->bluetooth_rfkill);
1014                 ehotk->bluetooth_rfkill = NULL;
1015         }
1016         if (ehotk->wwan3g_rfkill) {
1017                 rfkill_unregister(ehotk->wwan3g_rfkill);
1018                 rfkill_destroy(ehotk->wwan3g_rfkill);
1019                 ehotk->wwan3g_rfkill = NULL;
1020         }
1021         if (ehotk->wimax_rfkill) {
1022                 rfkill_unregister(ehotk->wimax_rfkill);
1023                 rfkill_destroy(ehotk->wimax_rfkill);
1024                 ehotk->wimax_rfkill = NULL;
1025         }
1026 }
1027
1028 static void eeepc_input_exit(void)
1029 {
1030         if (ehotk->inputdev)
1031                 input_unregister_device(ehotk->inputdev);
1032 }
1033
1034 static void eeepc_hwmon_exit(void)
1035 {
1036         struct device *hwmon;
1037
1038         hwmon = eeepc_hwmon_device;
1039         if (!hwmon)
1040                 return ;
1041         sysfs_remove_group(&hwmon->kobj,
1042                            &hwmon_attribute_group);
1043         hwmon_device_unregister(hwmon);
1044         eeepc_hwmon_device = NULL;
1045 }
1046
1047 static int eeepc_new_rfkill(struct rfkill **rfkill,
1048                             const char *name, struct device *dev,
1049                             enum rfkill_type type, int cm)
1050 {
1051         int result;
1052
1053         result = get_acpi(cm);
1054         if (result < 0)
1055                 return result;
1056
1057         *rfkill = rfkill_alloc(name, dev, type,
1058                                &eeepc_rfkill_ops, (void *)(unsigned long)cm);
1059
1060         if (!*rfkill)
1061                 return -EINVAL;
1062
1063         rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
1064         result = rfkill_register(*rfkill);
1065         if (result) {
1066                 rfkill_destroy(*rfkill);
1067                 *rfkill = NULL;
1068                 return result;
1069         }
1070         return 0;
1071 }
1072
1073
1074 static int eeepc_rfkill_init(struct device *dev)
1075 {
1076         int result = 0;
1077
1078         mutex_init(&ehotk->hotplug_lock);
1079
1080         result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
1081                                   "eeepc-wlan", dev,
1082                                   RFKILL_TYPE_WLAN, CM_ASL_WLAN);
1083
1084         if (result && result != -ENODEV)
1085                 goto exit;
1086
1087         result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
1088                                   "eeepc-bluetooth", dev,
1089                                   RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
1090
1091         if (result && result != -ENODEV)
1092                 goto exit;
1093
1094         result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
1095                                   "eeepc-wwan3g", dev,
1096                                   RFKILL_TYPE_WWAN, CM_ASL_3G);
1097
1098         if (result && result != -ENODEV)
1099                 goto exit;
1100
1101         result = eeepc_new_rfkill(&ehotk->wimax_rfkill,
1102                                   "eeepc-wimax", dev,
1103                                   RFKILL_TYPE_WIMAX, CM_ASL_WIMAX);
1104
1105         if (result && result != -ENODEV)
1106                 goto exit;
1107
1108         result = eeepc_setup_pci_hotplug();
1109         /*
1110          * If we get -EBUSY then something else is handling the PCI hotplug -
1111          * don't fail in this case
1112          */
1113         if (result == -EBUSY)
1114                 result = 0;
1115
1116         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
1117         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
1118         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
1119         /*
1120          * Refresh pci hotplug in case the rfkill state was changed during
1121          * setup.
1122          */
1123         eeepc_rfkill_hotplug(true);
1124
1125 exit:
1126         if (result && result != -ENODEV)
1127                 eeepc_rfkill_exit();
1128         return result;
1129 }
1130
1131 static int eeepc_backlight_init(struct device *dev)
1132 {
1133         struct backlight_device *bd;
1134
1135         bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
1136                                        NULL, &eeepcbl_ops);
1137         if (IS_ERR(bd)) {
1138                 pr_err("Could not register eeepc backlight device\n");
1139                 eeepc_backlight_device = NULL;
1140                 return PTR_ERR(bd);
1141         }
1142         eeepc_backlight_device = bd;
1143         bd->props.max_brightness = 15;
1144         bd->props.brightness = read_brightness(NULL);
1145         bd->props.power = FB_BLANK_UNBLANK;
1146         backlight_update_status(bd);
1147         return 0;
1148 }
1149
1150 static int eeepc_hwmon_init(struct device *dev)
1151 {
1152         struct device *hwmon;
1153         int result;
1154
1155         hwmon = hwmon_device_register(dev);
1156         if (IS_ERR(hwmon)) {
1157                 pr_err("Could not register eeepc hwmon device\n");
1158                 eeepc_hwmon_device = NULL;
1159                 return PTR_ERR(hwmon);
1160         }
1161         eeepc_hwmon_device = hwmon;
1162         result = sysfs_create_group(&hwmon->kobj,
1163                                     &hwmon_attribute_group);
1164         if (result)
1165                 eeepc_hwmon_exit();
1166         return result;
1167 }
1168
1169 static int eeepc_input_init(struct device *dev)
1170 {
1171         const struct key_entry *key;
1172         int result;
1173
1174         ehotk->inputdev = input_allocate_device();
1175         if (!ehotk->inputdev) {
1176                 pr_info("Unable to allocate input device\n");
1177                 return -ENOMEM;
1178         }
1179         ehotk->inputdev->name = "Asus EeePC extra buttons";
1180         ehotk->inputdev->dev.parent = dev;
1181         ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
1182         ehotk->inputdev->id.bustype = BUS_HOST;
1183         ehotk->inputdev->getkeycode = eeepc_getkeycode;
1184         ehotk->inputdev->setkeycode = eeepc_setkeycode;
1185
1186         for (key = eeepc_keymap; key->type != KE_END; key++) {
1187                 switch (key->type) {
1188                 case KE_KEY:
1189                         set_bit(EV_KEY, ehotk->inputdev->evbit);
1190                         set_bit(key->keycode, ehotk->inputdev->keybit);
1191                         break;
1192                 }
1193         }
1194         result = input_register_device(ehotk->inputdev);
1195         if (result) {
1196                 pr_info("Unable to register input device\n");
1197                 input_free_device(ehotk->inputdev);
1198                 return result;
1199         }
1200         return 0;
1201 }
1202
1203 static int __devinit eeepc_hotk_add(struct acpi_device *device)
1204 {
1205         struct device *dev;
1206         int result;
1207
1208         if (!device)
1209                 return -EINVAL;
1210         pr_notice(EEEPC_HOTK_NAME "\n");
1211         ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
1212         if (!ehotk)
1213                 return -ENOMEM;
1214         ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1215         ehotk->handle = device->handle;
1216         strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
1217         strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
1218         device->driver_data = ehotk;
1219         ehotk->device = device;
1220
1221         result = eeepc_hotk_check();
1222         if (result)
1223                 goto fail_platform_driver;
1224         eeepc_enable_camera();
1225
1226         /* Register platform stuff */
1227         result = platform_driver_register(&platform_driver);
1228         if (result)
1229                 goto fail_platform_driver;
1230         platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
1231         if (!platform_device) {
1232                 result = -ENOMEM;
1233                 goto fail_platform_device1;
1234         }
1235         result = platform_device_add(platform_device);
1236         if (result)
1237                 goto fail_platform_device2;
1238         result = sysfs_create_group(&platform_device->dev.kobj,
1239                                     &platform_attribute_group);
1240         if (result)
1241                 goto fail_sysfs;
1242
1243         dev = &platform_device->dev;
1244
1245         if (!acpi_video_backlight_support()) {
1246                 result = eeepc_backlight_init(dev);
1247                 if (result)
1248                         goto fail_backlight;
1249         } else
1250                 pr_info("Backlight controlled by ACPI video "
1251                         "driver\n");
1252
1253         result = eeepc_input_init(dev);
1254         if (result)
1255                 goto fail_input;
1256
1257         result = eeepc_hwmon_init(dev);
1258         if (result)
1259                 goto fail_hwmon;
1260
1261         result = eeepc_rfkill_init(dev);
1262         if (result)
1263                 goto fail_rfkill;
1264
1265         return 0;
1266
1267 fail_rfkill:
1268         eeepc_hwmon_exit();
1269 fail_hwmon:
1270         eeepc_input_exit();
1271 fail_input:
1272         eeepc_backlight_exit();
1273 fail_backlight:
1274         sysfs_remove_group(&platform_device->dev.kobj,
1275                            &platform_attribute_group);
1276 fail_sysfs:
1277         platform_device_del(platform_device);
1278 fail_platform_device2:
1279         platform_device_put(platform_device);
1280 fail_platform_device1:
1281         platform_driver_unregister(&platform_driver);
1282 fail_platform_driver:
1283         kfree(ehotk);
1284
1285         return result;
1286 }
1287
1288 static int eeepc_hotk_remove(struct acpi_device *device, int type)
1289 {
1290         if (!device || !acpi_driver_data(device))
1291                 return -EINVAL;
1292
1293         eeepc_backlight_exit();
1294         eeepc_rfkill_exit();
1295         eeepc_input_exit();
1296         eeepc_hwmon_exit();
1297         sysfs_remove_group(&platform_device->dev.kobj,
1298                            &platform_attribute_group);
1299         platform_device_unregister(platform_device);
1300         platform_driver_unregister(&platform_driver);
1301
1302         kfree(ehotk);
1303         return 0;
1304 }
1305
1306 static int __init eeepc_laptop_init(void)
1307 {
1308         int result;
1309
1310         if (acpi_disabled)
1311                 return -ENODEV;
1312         result = acpi_bus_register_driver(&eeepc_hotk_driver);
1313         if (result < 0)
1314                 return result;
1315         if (!ehotk) {
1316                 acpi_bus_unregister_driver(&eeepc_hotk_driver);
1317                 return -ENODEV;
1318         }
1319         return 0;
1320 }
1321
1322 static void __exit eeepc_laptop_exit(void)
1323 {
1324         acpi_bus_unregister_driver(&eeepc_hotk_driver);
1325 }
1326
1327 module_init(eeepc_laptop_init);
1328 module_exit(eeepc_laptop_exit);