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