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