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