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