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