SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/types.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/backlight.h>
  25 #include <linux/fb.h>
  26 #include <linux/hwmon.h>
  27 #include <linux/hwmon-sysfs.h>
  28 #include <acpi/acpi_drivers.h>
  29 #include <acpi/acpi_bus.h>
  30 #include <linux/uaccess.h>
  31 #include <linux/input.h>
  32 #include <linux/rfkill.h>
  33 #include <linux/pci.h>
  34
  35 #define EEEPC_LAPTOP_VERSION    "0.1"
  36
  37 #define EEEPC_HOTK_NAME         "Eee PC Hotkey Driver"
  38 #define EEEPC_HOTK_FILE         "eeepc"
  39 #define EEEPC_HOTK_CLASS        "hotkey"
  40 #define EEEPC_HOTK_DEVICE_NAME  "Hotkey"
  41 #define EEEPC_HOTK_HID          "ASUS010"
  42
  43 #define EEEPC_LOG       EEEPC_HOTK_FILE ": "
  44 #define EEEPC_ERR       KERN_ERR        EEEPC_LOG
  45 #define EEEPC_WARNING   KERN_WARNING    EEEPC_LOG
  46 #define EEEPC_NOTICE    KERN_NOTICE     EEEPC_LOG
  47 #define EEEPC_INFO      KERN_INFO       EEEPC_LOG
  48
  49 /*
  50  * Definitions for Asus EeePC
  51  */
  52 #define NOTIFY_WLAN_ON  0x10
  53 #define NOTIFY_BRN_MIN  0x20
  54 #define NOTIFY_BRN_MAX  0x2f
  55
  56 enum {
  57         DISABLE_ASL_WLAN = 0x0001,
  58         DISABLE_ASL_BLUETOOTH = 0x0002,
  59         DISABLE_ASL_IRDA = 0x0004,
  60         DISABLE_ASL_CAMERA = 0x0008,
  61         DISABLE_ASL_TV = 0x0010,
  62         DISABLE_ASL_GPS = 0x0020,
  63         DISABLE_ASL_DISPLAYSWITCH = 0x0040,
  64         DISABLE_ASL_MODEM = 0x0080,
  65         DISABLE_ASL_CARDREADER = 0x0100,
  66         DISABLE_ASL_3G = 0x0200,
  67         DISABLE_ASL_WIMAX = 0x0400,
  68         DISABLE_ASL_HWCF = 0x0800
  69 };
  70
  71 enum {
  72         CM_ASL_WLAN = 0,
  73         CM_ASL_BLUETOOTH,
  74         CM_ASL_IRDA,
  75         CM_ASL_1394,
  76         CM_ASL_CAMERA,
  77         CM_ASL_TV,
  78         CM_ASL_GPS,
  79         CM_ASL_DVDROM,
  80         CM_ASL_DISPLAYSWITCH,
  81         CM_ASL_PANELBRIGHT,
  82         CM_ASL_BIOSFLASH,
  83         CM_ASL_ACPIFLASH,
  84         CM_ASL_CPUFV,
  85         CM_ASL_CPUTEMPERATURE,
  86         CM_ASL_FANCPU,
  87         CM_ASL_FANCHASSIS,
  88         CM_ASL_USBPORT1,
  89         CM_ASL_USBPORT2,
  90         CM_ASL_USBPORT3,
  91         CM_ASL_MODEM,
  92         CM_ASL_CARDREADER,
  93         CM_ASL_3G,
  94         CM_ASL_WIMAX,
  95         CM_ASL_HWCF,
  96         CM_ASL_LID,
  97         CM_ASL_TYPE,
  98         CM_ASL_PANELPOWER,      /*P901*/
  99         CM_ASL_TPD
 100 };
 101
 102 static const char *cm_getv[] = {
 103         "WLDG", "BTHG", NULL, NULL,
 104         "CAMG", NULL, NULL, NULL,
 105         NULL, "PBLG", NULL, NULL,
 106         "CFVG", NULL, NULL, NULL,
 107         "USBG", NULL, NULL, "MODG",
 108         "CRDG", "M3GG", "WIMG", "HWCF",
 109         "LIDG", "TYPE", "PBPG", "TPDG"
 110 };
 111
 112 static const char *cm_setv[] = {
 113         "WLDS", "BTHS", NULL, NULL,
 114         "CAMS", NULL, NULL, NULL,
 115         "SDSP", "PBLS", "HDPS", NULL,
 116         "CFVS", NULL, NULL, NULL,
 117         "USBG", NULL, NULL, "MODS",
 118         "CRDS", "M3GS", "WIMS", NULL,
 119         NULL, NULL, "PBPS", "TPDS"
 120 };
 121
 122 #define EEEPC_EC        "\\_SB.PCI0.SBRG.EC0."
 123
 124 #define EEEPC_EC_FAN_PWM        EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
 125 #define EEEPC_EC_SC02           0x63
 126 #define EEEPC_EC_FAN_HRPM       EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
 127 #define EEEPC_EC_FAN_LRPM       EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
 128 #define EEEPC_EC_FAN_CTRL       EEEPC_EC "SFB3" /* Byte containing SF25  */
 129 #define EEEPC_EC_SFB3           0xD3
 130
 131 /*
 132  * This is the main structure, we can use it to store useful information
 133  * about the hotk device
 134  */
 135 struct eeepc_hotk {
 136         struct acpi_device *device;     /* the device we are in */
 137         acpi_handle handle;             /* the handle of the hotk device */
 138         u32 cm_supported;               /* the control methods supported
 139                                            by this BIOS */
 140         uint init_flag;                 /* Init flags */
 141         u16 event_count[128];           /* count for each event */
 142         struct input_dev *inputdev;
 143         u16 *keycode_map;
 144         struct rfkill *eeepc_wlan_rfkill;
 145         struct rfkill *eeepc_bluetooth_rfkill;
 146 };
 147
 148 /* The actual device the driver binds to */
 149 static struct eeepc_hotk *ehotk;
 150
 151 /* Platform device/driver */
 152 static struct platform_driver platform_driver = {
 153         .driver = {
 154                 .name = EEEPC_HOTK_FILE,
 155                 .owner = THIS_MODULE,
 156         }
 157 };
 158
 159 static struct platform_device *platform_device;
 160
 161 struct key_entry {
 162         char type;
 163         u8 code;
 164         u16 keycode;
 165 };
 166
 167 enum { KE_KEY, KE_END };
 168
 169 static struct key_entry eeepc_keymap[] = {
 170         /* Sleep already handled via generic ACPI code */
 171         {KE_KEY, 0x10, KEY_WLAN },
 172         {KE_KEY, 0x11, KEY_WLAN },
 173         {KE_KEY, 0x12, KEY_PROG1 },
 174         {KE_KEY, 0x13, KEY_MUTE },
 175         {KE_KEY, 0x14, KEY_VOLUMEDOWN },
 176         {KE_KEY, 0x15, KEY_VOLUMEUP },
 177         {KE_KEY, 0x1a, KEY_COFFEE },
 178         {KE_KEY, 0x1b, KEY_ZOOM },
 179         {KE_KEY, 0x1c, KEY_PROG2 },
 180         {KE_KEY, 0x1d, KEY_PROG3 },
 181         {KE_KEY, NOTIFY_BRN_MIN,     KEY_BRIGHTNESSDOWN },
 182         {KE_KEY, NOTIFY_BRN_MIN + 2, KEY_BRIGHTNESSUP },
 183         {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE },
 184         {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE },
 185         {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE },
 186         {KE_END, 0},
 187 };
 188
 189 /*
 190  * The hotkey driver declaration
 191  */
 192 static int eeepc_hotk_add(struct acpi_device *device);
 193 static int eeepc_hotk_remove(struct acpi_device *device, int type);
 194 static int eeepc_hotk_resume(struct acpi_device *device);
 195 static void eeepc_hotk_notify(struct acpi_device *device, u32 event);
 196
 197 static const struct acpi_device_id eeepc_device_ids[] = {
 198         {EEEPC_HOTK_HID, 0},
 199         {"", 0},
 200 };
 201 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
 202
 203 static struct acpi_driver eeepc_hotk_driver = {
 204         .name = EEEPC_HOTK_NAME,
 205         .class = EEEPC_HOTK_CLASS,
 206         .ids = eeepc_device_ids,
 207         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
 208         .ops = {
 209                 .add = eeepc_hotk_add,
 210                 .remove = eeepc_hotk_remove,
 211                 .resume = eeepc_hotk_resume,
 212                 .notify = eeepc_hotk_notify,
 213         },
 214 };
 215
 216 /* The backlight device /sys/class/backlight */
 217 static struct backlight_device *eeepc_backlight_device;
 218
 219 /* The hwmon device */
 220 static struct device *eeepc_hwmon_device;
 221
 222 /*
 223  * The backlight class declaration
 224  */
 225 static int read_brightness(struct backlight_device *bd);
 226 static int update_bl_status(struct backlight_device *bd);
 227 static struct backlight_ops eeepcbl_ops = {
 228         .get_brightness = read_brightness,
 229         .update_status = update_bl_status,
 230 };
 231
 232 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
 233 MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
 234 MODULE_LICENSE("GPL");
 235
 236 /*
 237  * ACPI Helpers
 238  */
 239 static int write_acpi_int(acpi_handle handle, const char *method, int val,
 240                           struct acpi_buffer *output)
 241 {
 242         struct acpi_object_list params;
 243         union acpi_object in_obj;
 244         acpi_status status;
 245
 246         params.count = 1;
 247         params.pointer = &in_obj;
 248         in_obj.type = ACPI_TYPE_INTEGER;
 249         in_obj.integer.value = val;
 250
 251         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 252         return (status == AE_OK ? 0 : -1);
 253 }
 254
 255 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
 256 {
 257         acpi_status status;
 258         unsigned long long result;
 259
 260         status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
 261         if (ACPI_FAILURE(status)) {
 262                 *val = -1;
 263                 return -1;
 264         } else {
 265                 *val = result;
 266                 return 0;
 267         }
 268 }
 269
 270 static int set_acpi(int cm, int value)
 271 {
 272         if (ehotk->cm_supported & (0x1 << cm)) {
 273                 const char *method = cm_setv[cm];
 274                 if (method == NULL)
 275                         return -ENODEV;
 276                 if (write_acpi_int(ehotk->handle, method, value, NULL))
 277                         printk(EEEPC_WARNING "Error writing %s\n", method);
 278         }
 279         return 0;
 280 }
 281
 282 static int get_acpi(int cm)
 283 {
 284         int value = -1;
 285         if ((ehotk->cm_supported & (0x1 << cm))) {
 286                 const char *method = cm_getv[cm];
 287                 if (method == NULL)
 288                         return -ENODEV;
 289                 if (read_acpi_int(ehotk->handle, method, &value))
 290                         printk(EEEPC_WARNING "Error reading %s\n", method);
 291         }
 292         return value;
 293 }
 294
 295 /*
 296  * Backlight
 297  */
 298 static int read_brightness(struct backlight_device *bd)
 299 {
 300         return get_acpi(CM_ASL_PANELBRIGHT);
 301 }
 302
 303 static int set_brightness(struct backlight_device *bd, int value)
 304 {
 305         value = max(0, min(15, value));
 306         return set_acpi(CM_ASL_PANELBRIGHT, value);
 307 }
 308
 309 static int update_bl_status(struct backlight_device *bd)
 310 {
 311         return set_brightness(bd, bd->props.brightness);
 312 }
 313
 314 /*
 315  * Rfkill helpers
 316  */
 317
 318 static bool eeepc_wlan_rfkill_blocked(void)
 319 {
 320         if (get_acpi(CM_ASL_WLAN) == 1)
 321                 return false;
 322         return true;
 323 }
 324
 325 static int eeepc_rfkill_set(void *data, bool blocked)
 326 {
 327         unsigned long asl = (unsigned long)data;
 328         return set_acpi(asl, !blocked);
 329 }
 330
 331 static const struct rfkill_ops eeepc_rfkill_ops = {
 332         .set_block = eeepc_rfkill_set,
 333 };
 334
 335 static void __init eeepc_enable_camera(void)
 336 {
 337         /*
 338          * If the following call to set_acpi() fails, it's because there's no
 339          * camera so we can ignore the error.
 340          */
 341         set_acpi(CM_ASL_CAMERA, 1);
 342 }
 343
 344 /*
 345  * Sys helpers
 346  */
 347 static int parse_arg(const char *buf, unsigned long count, int *val)
 348 {
 349         if (!count)
 350                 return 0;
 351         if (sscanf(buf, "%i", val) != 1)
 352                 return -EINVAL;
 353         return count;
 354 }
 355
 356 static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
 357 {
 358         int rv, value;
 359
 360         rv = parse_arg(buf, count, &value);
 361         if (rv > 0)
 362                 set_acpi(cm, value);
 363         return rv;
 364 }
 365
 366 static ssize_t show_sys_acpi(int cm, char *buf)
 367 {
 368         return sprintf(buf, "%d\n", get_acpi(cm));
 369 }
 370
 371 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)                            \
 372         static ssize_t show_##_name(struct device *dev,                 \
 373                                     struct device_attribute *attr,      \
 374                                     char *buf)                          \
 375         {                                                               \
 376                 return show_sys_acpi(_cm, buf);                         \
 377         }                                                               \
 378         static ssize_t store_##_name(struct device *dev,                \
 379                                      struct device_attribute *attr,     \
 380                                      const char *buf, size_t count)     \
 381         {                                                               \
 382                 return store_sys_acpi(_cm, buf, count);                 \
 383         }                                                               \
 384         static struct device_attribute dev_attr_##_name = {             \
 385                 .attr = {                                               \
 386                         .name = __stringify(_name),                     \
 387                         .mode = 0644 },                                 \
 388                 .show   = show_##_name,                                 \
 389                 .store  = store_##_name,                                \
 390         }
 391
 392 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
 393 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
 394 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
 395 EEEPC_CREATE_DEVICE_ATTR(cpufv, CM_ASL_CPUFV);
 396
 397 static struct attribute *platform_attributes[] = {
 398         &dev_attr_camera.attr,
 399         &dev_attr_cardr.attr,
 400         &dev_attr_disp.attr,
 401         &dev_attr_cpufv.attr,
 402         NULL
 403 };
 404
 405 static struct attribute_group platform_attribute_group = {
 406         .attrs = platform_attributes
 407 };
 408
 409 /*
 410  * Hotkey functions
 411  */
 412 static struct key_entry *eepc_get_entry_by_scancode(int code)
 413 {
 414         struct key_entry *key;
 415
 416         for (key = eeepc_keymap; key->type != KE_END; key++)
 417                 if (code == key->code)
 418                         return key;
 419
 420         return NULL;
 421 }
 422
 423 static struct key_entry *eepc_get_entry_by_keycode(int code)
 424 {
 425         struct key_entry *key;
 426
 427         for (key = eeepc_keymap; key->type != KE_END; key++)
 428                 if (code == key->keycode && key->type == KE_KEY)
 429                         return key;
 430
 431         return NULL;
 432 }
 433
 434 static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
 435 {
 436         struct key_entry *key = eepc_get_entry_by_scancode(scancode);
 437
 438         if (key && key->type == KE_KEY) {
 439                 *keycode = key->keycode;
 440                 return 0;
 441         }
 442
 443         return -EINVAL;
 444 }
 445
 446 static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
 447 {
 448         struct key_entry *key;
 449         int old_keycode;
 450
 451         if (keycode < 0 || keycode > KEY_MAX)
 452                 return -EINVAL;
 453
 454         key = eepc_get_entry_by_scancode(scancode);
 455         if (key && key->type == KE_KEY) {
 456                 old_keycode = key->keycode;
 457                 key->keycode = keycode;
 458                 set_bit(keycode, dev->keybit);
 459                 if (!eepc_get_entry_by_keycode(old_keycode))
 460                         clear_bit(old_keycode, dev->keybit);
 461                 return 0;
 462         }
 463
 464         return -EINVAL;
 465 }
 466
 467 static int eeepc_hotk_check(void)
 468 {
 469         const struct key_entry *key;
 470         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 471         int result;
 472
 473         result = acpi_bus_get_status(ehotk->device);
 474         if (result)
 475                 return result;
 476         if (ehotk->device->status.present) {
 477                 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
 478                                     &buffer)) {
 479                         printk(EEEPC_ERR "Hotkey initialization failed\n");
 480                         return -ENODEV;
 481                 } else {
 482                         printk(EEEPC_NOTICE "Hotkey init flags 0x%x\n",
 483                                ehotk->init_flag);
 484                 }
 485                 /* get control methods supported */
 486                 if (read_acpi_int(ehotk->handle, "CMSG"
 487                                    , &ehotk->cm_supported)) {
 488                         printk(EEEPC_ERR
 489                                "Get control methods supported failed\n");
 490                         return -ENODEV;
 491                 } else {
 492                         printk(EEEPC_INFO
 493                                "Get control methods supported: 0x%x\n",
 494                                ehotk->cm_supported);
 495                 }
 496                 ehotk->inputdev = input_allocate_device();
 497                 if (!ehotk->inputdev) {
 498                         printk(EEEPC_INFO "Unable to allocate input device\n");
 499                         return 0;
 500                 }
 501                 ehotk->inputdev->name = "Asus EeePC extra buttons";
 502                 ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
 503                 ehotk->inputdev->id.bustype = BUS_HOST;
 504                 ehotk->inputdev->getkeycode = eeepc_getkeycode;
 505                 ehotk->inputdev->setkeycode = eeepc_setkeycode;
 506
 507                 for (key = eeepc_keymap; key->type != KE_END; key++) {
 508                         switch (key->type) {
 509                         case KE_KEY:
 510                                 set_bit(EV_KEY, ehotk->inputdev->evbit);
 511                                 set_bit(key->keycode, ehotk->inputdev->keybit);
 512                                 break;
 513                         }
 514                 }
 515                 result = input_register_device(ehotk->inputdev);
 516                 if (result) {
 517                         printk(EEEPC_INFO "Unable to register input device\n");
 518                         input_free_device(ehotk->inputdev);
 519                         return 0;
 520                 }
 521         } else {
 522                 printk(EEEPC_ERR "Hotkey device not present, aborting\n");
 523                 return -EINVAL;
 524         }
 525         return 0;
 526 }
 527
 528 static int notify_brn(void)
 529 {
 530         /* returns the *previous* brightness, or -1 */
 531         struct backlight_device *bd = eeepc_backlight_device;
 532         if (bd) {
 533                 int old = bd->props.brightness;
 534                 bd->props.brightness = read_brightness(bd);
 535                 return old;
 536         }
 537         return -1;
 538 }
 539
 540 static void eeepc_rfkill_hotplug(void)
 541 {
 542         struct pci_dev *dev;
 543         struct pci_bus *bus = pci_find_bus(0, 1);
 544         bool blocked;
 545
 546         if (!bus) {
 547                 printk(EEEPC_WARNING "Unable to find PCI bus 1?\n");
 548                 return;
 549         }
 550
 551         blocked = eeepc_wlan_rfkill_blocked();
 552         if (!blocked) {
 553                 dev = pci_get_slot(bus, 0);
 554                 if (dev) {
 555                         /* Device already present */
 556                         pci_dev_put(dev);
 557                         return;
 558                 }
 559                 dev = pci_scan_single_device(bus, 0);
 560                 if (dev) {
 561                         pci_bus_assign_resources(bus);
 562                         if (pci_bus_add_device(dev))
 563                                 printk(EEEPC_ERR "Unable to hotplug wifi\n");
 564                 }
 565         } else {
 566                 dev = pci_get_slot(bus, 0);
 567                 if (dev) {
 568                         pci_remove_bus_device(dev);
 569                         pci_dev_put(dev);
 570                 }
 571         }
 572
 573         rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill, blocked);
 574 }
 575
 576 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
 577 {
 578         if (event != ACPI_NOTIFY_BUS_CHECK)
 579                 return;
 580
 581         eeepc_rfkill_hotplug();
 582 }
 583
 584 static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
 585 {
 586         static struct key_entry *key;
 587         u16 count;
 588         int brn = -ENODEV;
 589
 590         if (!ehotk)
 591                 return;
 592         if (event > ACPI_MAX_SYS_NOTIFY)
 593                 return;
 594         if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
 595                 brn = notify_brn();
 596         count = ehotk->event_count[event % 128]++;
 597         acpi_bus_generate_proc_event(ehotk->device, event, count);
 598         acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class,
 599                                         dev_name(&ehotk->device->dev), event,
 600                                         count);
 601         if (ehotk->inputdev) {
 602                 if (brn != -ENODEV) {
 603                         /* brightness-change events need special
 604                          * handling for conversion to key events
 605                          */
 606                         if (brn < 0)
 607                                 brn = event;
 608                         else
 609                                 brn += NOTIFY_BRN_MIN;
 610                         if (event < brn)
 611                                 event = NOTIFY_BRN_MIN; /* brightness down */
 612                         else if (event > brn)
 613                                 event = NOTIFY_BRN_MIN + 2; /* ... up */
 614                         else
 615                                 event = NOTIFY_BRN_MIN + 1; /* ... unchanged */
 616                 }
 617                 key = eepc_get_entry_by_scancode(event);
 618                 if (key) {
 619                         switch (key->type) {
 620                         case KE_KEY:
 621                                 input_report_key(ehotk->inputdev, key->keycode,
 622                                                  1);
 623                                 input_sync(ehotk->inputdev);
 624                                 input_report_key(ehotk->inputdev, key->keycode,
 625                                                  0);
 626                                 input_sync(ehotk->inputdev);
 627                                 break;
 628                         }
 629                 }
 630         }
 631 }
 632
 633 static int eeepc_register_rfkill_notifier(char *node)
 634 {
 635         acpi_status status = AE_OK;
 636         acpi_handle handle;
 637
 638         status = acpi_get_handle(NULL, node, &handle);
 639
 640         if (ACPI_SUCCESS(status)) {
 641                 status = acpi_install_notify_handler(handle,
 642                                                      ACPI_SYSTEM_NOTIFY,
 643                                                      eeepc_rfkill_notify,
 644                                                      NULL);
 645                 if (ACPI_FAILURE(status))
 646                         printk(EEEPC_WARNING
 647                                "Failed to register notify on %s\n", node);
 648         } else
 649                 return -ENODEV;
 650
 651         return 0;
 652 }
 653
 654 static void eeepc_unregister_rfkill_notifier(char *node)
 655 {
 656         acpi_status status = AE_OK;
 657         acpi_handle handle;
 658
 659         status = acpi_get_handle(NULL, node, &handle);
 660
 661         if (ACPI_SUCCESS(status)) {
 662                 status = acpi_remove_notify_handler(handle,
 663                                                      ACPI_SYSTEM_NOTIFY,
 664                                                      eeepc_rfkill_notify);
 665                 if (ACPI_FAILURE(status))
 666                         printk(EEEPC_ERR
 667                                "Error removing rfkill notify handler %s\n",
 668                                 node);
 669         }
 670 }
 671
 672 static int eeepc_hotk_add(struct acpi_device *device)
 673 {
 674         int result;
 675
 676         if (!device)
 677                  return -EINVAL;
 678         printk(EEEPC_NOTICE EEEPC_HOTK_NAME "\n");
 679         ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
 680         if (!ehotk)
 681                 return -ENOMEM;
 682         ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
 683         ehotk->handle = device->handle;
 684         strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
 685         strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
 686         device->driver_data = ehotk;
 687         ehotk->device = device;
 688         result = eeepc_hotk_check();
 689         if (result)
 690                 goto ehotk_fail;
 691
 692         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
 693         eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
 694
 695         if (get_acpi(CM_ASL_WLAN) != -1) {
 696                 ehotk->eeepc_wlan_rfkill = rfkill_alloc("eeepc-wlan",
 697                                                         &device->dev,
 698                                                         RFKILL_TYPE_WLAN,
 699                                                         &eeepc_rfkill_ops,
 700                                                         (void *)CM_ASL_WLAN);
 701
 702                 if (!ehotk->eeepc_wlan_rfkill)
 703                         goto wlan_fail;
 704
 705                 rfkill_init_sw_state(ehotk->eeepc_wlan_rfkill,
 706                                      get_acpi(CM_ASL_WLAN) != 1);
 707                 result = rfkill_register(ehotk->eeepc_wlan_rfkill);
 708                 if (result)
 709                         goto wlan_fail;
 710         }
 711
 712         if (get_acpi(CM_ASL_BLUETOOTH) != -1) {
 713                 ehotk->eeepc_bluetooth_rfkill =
 714                         rfkill_alloc("eeepc-bluetooth",
 715                                      &device->dev,
 716                                      RFKILL_TYPE_BLUETOOTH,
 717                                      &eeepc_rfkill_ops,
 718                                      (void *)CM_ASL_BLUETOOTH);
 719
 720                 if (!ehotk->eeepc_bluetooth_rfkill)
 721                         goto bluetooth_fail;
 722
 723                 rfkill_init_sw_state(ehotk->eeepc_bluetooth_rfkill,
 724                                      get_acpi(CM_ASL_BLUETOOTH) != 1);
 725                 result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
 726                 if (result)
 727                         goto bluetooth_fail;
 728         }
 729
 730         return 0;
 731
 732  bluetooth_fail:
 733         rfkill_destroy(ehotk->eeepc_bluetooth_rfkill);
 734         rfkill_unregister(ehotk->eeepc_wlan_rfkill);
 735  wlan_fail:
 736         rfkill_destroy(ehotk->eeepc_wlan_rfkill);
 737         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
 738         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
 739  ehotk_fail:
 740         kfree(ehotk);
 741         ehotk = NULL;
 742
 743         return result;
 744 }
 745
 746 static int eeepc_hotk_remove(struct acpi_device *device, int type)
 747 {
 748         if (!device || !acpi_driver_data(device))
 749                  return -EINVAL;
 750
 751         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
 752         eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
 753
 754         kfree(ehotk);
 755         return 0;
 756 }
 757
 758 static int eeepc_hotk_resume(struct acpi_device *device)
 759 {
 760         if (ehotk->eeepc_wlan_rfkill) {
 761                 bool wlan;
 762
 763                 /* Workaround - it seems that _PTS disables the wireless
 764                    without notification or changing the value read by WLAN.
 765                    Normally this is fine because the correct value is restored
 766                    from the non-volatile storage on resume, but we need to do
 767                    it ourself if case suspend is aborted, or we lose wireless.
 768                  */
 769                 wlan = get_acpi(CM_ASL_WLAN);
 770                 set_acpi(CM_ASL_WLAN, wlan);
 771
 772                 rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill,
 773                                     wlan != 1);
 774
 775                 eeepc_rfkill_hotplug();
 776         }
 777
 778         if (ehotk->eeepc_bluetooth_rfkill)
 779                 rfkill_set_sw_state(ehotk->eeepc_bluetooth_rfkill,
 780                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
 781
 782         return 0;
 783 }
 784
 785 /*
 786  * Hwmon
 787  */
 788 static int eeepc_get_fan_pwm(void)
 789 {
 790         int value = 0;
 791
 792         read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
 793         value = value * 255 / 100;
 794         return (value);
 795 }
 796
 797 static void eeepc_set_fan_pwm(int value)
 798 {
 799         value = SENSORS_LIMIT(value, 0, 255);
 800         value = value * 100 / 255;
 801         ec_write(EEEPC_EC_SC02, value);
 802 }
 803
 804 static int eeepc_get_fan_rpm(void)
 805 {
 806         int high = 0;
 807         int low = 0;
 808
 809         read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
 810         read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
 811         return (high << 8 | low);
 812 }
 813
 814 static int eeepc_get_fan_ctrl(void)
 815 {
 816         int value = 0;
 817
 818         read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
 819         return ((value & 0x02 ? 1 : 0));
 820 }
 821
 822 static void eeepc_set_fan_ctrl(int manual)
 823 {
 824         int value = 0;
 825
 826         read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
 827         if (manual)
 828                 value |= 0x02;
 829         else
 830                 value &= ~0x02;
 831         ec_write(EEEPC_EC_SFB3, value);
 832 }
 833
 834 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
 835 {
 836         int rv, value;
 837
 838         rv = parse_arg(buf, count, &value);
 839         if (rv > 0)
 840                 set(value);
 841         return rv;
 842 }
 843
 844 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
 845 {
 846         return sprintf(buf, "%d\n", get());
 847 }
 848
 849 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get)              \
 850         static ssize_t show_##_name(struct device *dev,                 \
 851                                     struct device_attribute *attr,      \
 852                                     char *buf)                          \
 853         {                                                               \
 854                 return show_sys_hwmon(_set, buf);                       \
 855         }                                                               \
 856         static ssize_t store_##_name(struct device *dev,                \
 857                                      struct device_attribute *attr,     \
 858                                      const char *buf, size_t count)     \
 859         {                                                               \
 860                 return store_sys_hwmon(_get, buf, count);               \
 861         }                                                               \
 862         static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
 863
 864 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
 865 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
 866                          eeepc_get_fan_pwm, eeepc_set_fan_pwm);
 867 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
 868                          eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
 869
 870 static ssize_t
 871 show_name(struct device *dev, struct device_attribute *attr, char *buf)
 872 {
 873         return sprintf(buf, "eeepc\n");
 874 }
 875 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
 876
 877 static struct attribute *hwmon_attributes[] = {
 878         &sensor_dev_attr_pwm1.dev_attr.attr,
 879         &sensor_dev_attr_fan1_input.dev_attr.attr,
 880         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 881         &sensor_dev_attr_name.dev_attr.attr,
 882         NULL
 883 };
 884
 885 static struct attribute_group hwmon_attribute_group = {
 886         .attrs = hwmon_attributes
 887 };
 888
 889 /*
 890  * exit/init
 891  */
 892 static void eeepc_backlight_exit(void)
 893 {
 894         if (eeepc_backlight_device)
 895                 backlight_device_unregister(eeepc_backlight_device);
 896         eeepc_backlight_device = NULL;
 897 }
 898
 899 static void eeepc_rfkill_exit(void)
 900 {
 901         if (ehotk->eeepc_wlan_rfkill)
 902                 rfkill_unregister(ehotk->eeepc_wlan_rfkill);
 903         if (ehotk->eeepc_bluetooth_rfkill)
 904                 rfkill_unregister(ehotk->eeepc_bluetooth_rfkill);
 905 }
 906
 907 static void eeepc_input_exit(void)
 908 {
 909         if (ehotk->inputdev)
 910                 input_unregister_device(ehotk->inputdev);
 911 }
 912
 913 static void eeepc_hwmon_exit(void)
 914 {
 915         struct device *hwmon;
 916
 917         hwmon = eeepc_hwmon_device;
 918         if (!hwmon)
 919                 return ;
 920         sysfs_remove_group(&hwmon->kobj,
 921                            &hwmon_attribute_group);
 922         hwmon_device_unregister(hwmon);
 923         eeepc_hwmon_device = NULL;
 924 }
 925
 926 static void __exit eeepc_laptop_exit(void)
 927 {
 928         eeepc_backlight_exit();
 929         eeepc_rfkill_exit();
 930         eeepc_input_exit();
 931         eeepc_hwmon_exit();
 932         acpi_bus_unregister_driver(&eeepc_hotk_driver);
 933         sysfs_remove_group(&platform_device->dev.kobj,
 934                            &platform_attribute_group);
 935         platform_device_unregister(platform_device);
 936         platform_driver_unregister(&platform_driver);
 937 }
 938
 939 static int eeepc_backlight_init(struct device *dev)
 940 {
 941         struct backlight_device *bd;
 942
 943         bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
 944                                        NULL, &eeepcbl_ops);
 945         if (IS_ERR(bd)) {
 946                 printk(EEEPC_ERR
 947                        "Could not register eeepc backlight device\n");
 948                 eeepc_backlight_device = NULL;
 949                 return PTR_ERR(bd);
 950         }
 951         eeepc_backlight_device = bd;
 952         bd->props.max_brightness = 15;
 953         bd->props.brightness = read_brightness(NULL);
 954         bd->props.power = FB_BLANK_UNBLANK;
 955         backlight_update_status(bd);
 956         return 0;
 957 }
 958
 959 static int eeepc_hwmon_init(struct device *dev)
 960 {
 961         struct device *hwmon;
 962         int result;
 963
 964         hwmon = hwmon_device_register(dev);
 965         if (IS_ERR(hwmon)) {
 966                 printk(EEEPC_ERR
 967                        "Could not register eeepc hwmon device\n");
 968                 eeepc_hwmon_device = NULL;
 969                 return PTR_ERR(hwmon);
 970         }
 971         eeepc_hwmon_device = hwmon;
 972         result = sysfs_create_group(&hwmon->kobj,
 973                                     &hwmon_attribute_group);
 974         if (result)
 975                 eeepc_hwmon_exit();
 976         return result;
 977 }
 978
 979 static int __init eeepc_laptop_init(void)
 980 {
 981         struct device *dev;
 982         int result;
 983
 984         if (acpi_disabled)
 985                 return -ENODEV;
 986         result = acpi_bus_register_driver(&eeepc_hotk_driver);
 987         if (result < 0)
 988                 return result;
 989         if (!ehotk) {
 990                 acpi_bus_unregister_driver(&eeepc_hotk_driver);
 991                 return -ENODEV;
 992         }
 993         dev = acpi_get_physical_device(ehotk->device->handle);
 994
 995         if (!acpi_video_backlight_support()) {
 996                 result = eeepc_backlight_init(dev);
 997                 if (result)
 998                         goto fail_backlight;
 999         } else
1000                 printk(EEEPC_INFO "Backlight controlled by ACPI video "
1001                        "driver\n");
1002
1003         result = eeepc_hwmon_init(dev);
1004         if (result)
1005                 goto fail_hwmon;
1006
1007         eeepc_enable_camera();
1008
1009         /* Register platform stuff */
1010         result = platform_driver_register(&platform_driver);
1011         if (result)
1012                 goto fail_platform_driver;
1013         platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
1014         if (!platform_device) {
1015                 result = -ENOMEM;
1016                 goto fail_platform_device1;
1017         }
1018         result = platform_device_add(platform_device);
1019         if (result)
1020                 goto fail_platform_device2;
1021         result = sysfs_create_group(&platform_device->dev.kobj,
1022                                     &platform_attribute_group);
1023         if (result)
1024                 goto fail_sysfs;
1025         return 0;
1026 fail_sysfs:
1027         platform_device_del(platform_device);
1028 fail_platform_device2:
1029         platform_device_put(platform_device);
1030 fail_platform_device1:
1031         platform_driver_unregister(&platform_driver);
1032 fail_platform_driver:
1033         eeepc_hwmon_exit();
1034 fail_hwmon:
1035         eeepc_backlight_exit();
1036 fail_backlight:
1037         eeepc_input_exit();
1038         eeepc_rfkill_exit();
1039         return result;
1040 }
1041
1042 module_init(eeepc_laptop_init);
1043 module_exit(eeepc_laptop_exit);