1 /* 2 * eepc-laptop.c - Asus Eee PC extras 3 * 4 * Based on asus_acpi.c as patched for the Eee PC by Asus: 5 * ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar 6 * Based on eee.c from eeepc-linux 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/types.h> 25 #include <linux/platform_device.h> 26 #include <linux/backlight.h> 27 #include <linux/fb.h> 28 #include <linux/hwmon.h> 29 #include <linux/hwmon-sysfs.h> 30 #include <acpi/acpi_drivers.h> 31 #include <acpi/acpi_bus.h> 32 #include <linux/uaccess.h> 33 #include <linux/input.h> 34 #include <linux/rfkill.h> 35 #include <linux/pci.h> 36 #include <linux/pci_hotplug.h> 37 38 #define EEEPC_LAPTOP_VERSION "0.1" 39 40 #define EEEPC_HOTK_NAME "Eee PC Hotkey Driver" 41 #define EEEPC_HOTK_FILE "eeepc" 42 #define EEEPC_HOTK_CLASS "hotkey" 43 #define EEEPC_HOTK_DEVICE_NAME "Hotkey" 44 #define EEEPC_HOTK_HID "ASUS010" 45 46 47 /* 48 * Definitions for Asus EeePC 49 */ 50 #define NOTIFY_WLAN_ON 0x10 51 #define NOTIFY_BRN_MIN 0x20 52 #define NOTIFY_BRN_MAX 0x2f 53 54 enum { 55 DISABLE_ASL_WLAN = 0x0001, 56 DISABLE_ASL_BLUETOOTH = 0x0002, 57 DISABLE_ASL_IRDA = 0x0004, 58 DISABLE_ASL_CAMERA = 0x0008, 59 DISABLE_ASL_TV = 0x0010, 60 DISABLE_ASL_GPS = 0x0020, 61 DISABLE_ASL_DISPLAYSWITCH = 0x0040, 62 DISABLE_ASL_MODEM = 0x0080, 63 DISABLE_ASL_CARDREADER = 0x0100, 64 DISABLE_ASL_3G = 0x0200, 65 DISABLE_ASL_WIMAX = 0x0400, 66 DISABLE_ASL_HWCF = 0x0800 67 }; 68 69 enum { 70 CM_ASL_WLAN = 0, 71 CM_ASL_BLUETOOTH, 72 CM_ASL_IRDA, 73 CM_ASL_1394, 74 CM_ASL_CAMERA, 75 CM_ASL_TV, 76 CM_ASL_GPS, 77 CM_ASL_DVDROM, 78 CM_ASL_DISPLAYSWITCH, 79 CM_ASL_PANELBRIGHT, 80 CM_ASL_BIOSFLASH, 81 CM_ASL_ACPIFLASH, 82 CM_ASL_CPUFV, 83 CM_ASL_CPUTEMPERATURE, 84 CM_ASL_FANCPU, 85 CM_ASL_FANCHASSIS, 86 CM_ASL_USBPORT1, 87 CM_ASL_USBPORT2, 88 CM_ASL_USBPORT3, 89 CM_ASL_MODEM, 90 CM_ASL_CARDREADER, 91 CM_ASL_3G, 92 CM_ASL_WIMAX, 93 CM_ASL_HWCF, 94 CM_ASL_LID, 95 CM_ASL_TYPE, 96 CM_ASL_PANELPOWER, /*P901*/ 97 CM_ASL_TPD 98 }; 99 100 static const char *cm_getv[] = { 101 "WLDG", "BTHG", NULL, NULL, 102 "CAMG", NULL, NULL, NULL, 103 NULL, "PBLG", NULL, NULL, 104 "CFVG", NULL, NULL, NULL, 105 "USBG", NULL, NULL, "MODG", 106 "CRDG", "M3GG", "WIMG", "HWCF", 107 "LIDG", "TYPE", "PBPG", "TPDG" 108 }; 109 110 static const char *cm_setv[] = { 111 "WLDS", "BTHS", NULL, NULL, 112 "CAMS", NULL, NULL, NULL, 113 "SDSP", "PBLS", "HDPS", NULL, 114 "CFVS", NULL, NULL, NULL, 115 "USBG", NULL, NULL, "MODS", 116 "CRDS", "M3GS", "WIMS", NULL, 117 NULL, NULL, "PBPS", "TPDS" 118 }; 119 120 #define EEEPC_EC "\\_SB.PCI0.SBRG.EC0." 121 122 #define EEEPC_EC_FAN_PWM EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */ 123 #define EEEPC_EC_SC02 0x63 124 #define EEEPC_EC_FAN_HRPM EEEPC_EC "SC05" /* High byte, fan speed (RPM) */ 125 #define EEEPC_EC_FAN_LRPM EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */ 126 #define EEEPC_EC_FAN_CTRL EEEPC_EC "SFB3" /* Byte containing SF25 */ 127 #define EEEPC_EC_SFB3 0xD3 128 129 /* 130 * This is the main structure, we can use it to store useful information 131 * about the hotk device 132 */ 133 struct eeepc_hotk { 134 struct acpi_device *device; /* the device we are in */ 135 acpi_handle handle; /* the handle of the hotk device */ 136 u32 cm_supported; /* the control methods supported 137 by this BIOS */ 138 uint init_flag; /* Init flags */ 139 u16 event_count[128]; /* count for each event */ 140 struct input_dev *inputdev; 141 u16 *keycode_map; 142 struct rfkill *wlan_rfkill; 143 struct rfkill *bluetooth_rfkill; 144 struct rfkill *wwan3g_rfkill; 145 struct hotplug_slot *hotplug_slot; 146 struct work_struct hotplug_work; 147 }; 148 149 /* The actual device the driver binds to */ 150 static struct eeepc_hotk *ehotk; 151 152 /* Platform device/driver */ 153 static struct platform_driver platform_driver = { 154 .driver = { 155 .name = EEEPC_HOTK_FILE, 156 .owner = THIS_MODULE, 157 } 158 }; 159 160 static struct platform_device *platform_device; 161 162 struct key_entry { 163 char type; 164 u8 code; 165 u16 keycode; 166 }; 167 168 enum { KE_KEY, KE_END }; 169 170 static struct key_entry eeepc_keymap[] = { 171 /* Sleep already handled via generic ACPI code */ 172 {KE_KEY, 0x10, KEY_WLAN }, 173 {KE_KEY, 0x11, KEY_WLAN }, 174 {KE_KEY, 0x12, KEY_PROG1 }, 175 {KE_KEY, 0x13, KEY_MUTE }, 176 {KE_KEY, 0x14, KEY_VOLUMEDOWN }, 177 {KE_KEY, 0x15, KEY_VOLUMEUP }, 178 {KE_KEY, 0x1a, KEY_COFFEE }, 179 {KE_KEY, 0x1b, KEY_ZOOM }, 180 {KE_KEY, 0x1c, KEY_PROG2 }, 181 {KE_KEY, 0x1d, KEY_PROG3 }, 182 {KE_KEY, NOTIFY_BRN_MIN, KEY_BRIGHTNESSDOWN }, 183 {KE_KEY, NOTIFY_BRN_MIN + 2, KEY_BRIGHTNESSUP }, 184 {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE }, 185 {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE }, 186 {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE }, 187 {KE_END, 0}, 188 }; 189 190 /* 191 * The hotkey driver declaration 192 */ 193 static int eeepc_hotk_add(struct acpi_device *device); 194 static int eeepc_hotk_remove(struct acpi_device *device, int type); 195 static int eeepc_hotk_resume(struct acpi_device *device); 196 static void eeepc_hotk_notify(struct acpi_device *device, u32 event); 197 198 static const struct acpi_device_id eeepc_device_ids[] = { 199 {EEEPC_HOTK_HID, 0}, 200 {"", 0}, 201 }; 202 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids); 203 204 static struct acpi_driver eeepc_hotk_driver = { 205 .name = EEEPC_HOTK_NAME, 206 .class = EEEPC_HOTK_CLASS, 207 .ids = eeepc_device_ids, 208 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 209 .ops = { 210 .add = eeepc_hotk_add, 211 .remove = eeepc_hotk_remove, 212 .resume = eeepc_hotk_resume, 213 .notify = eeepc_hotk_notify, 214 }, 215 }; 216 217 /* PCI hotplug ops */ 218 static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value); 219 220 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = { 221 .owner = THIS_MODULE, 222 .get_adapter_status = eeepc_get_adapter_status, 223 .get_power_status = eeepc_get_adapter_status, 224 }; 225 226 /* The backlight device /sys/class/backlight */ 227 static struct backlight_device *eeepc_backlight_device; 228 229 /* The hwmon device */ 230 static struct device *eeepc_hwmon_device; 231 232 /* 233 * The backlight class declaration 234 */ 235 static int read_brightness(struct backlight_device *bd); 236 static int update_bl_status(struct backlight_device *bd); 237 static struct backlight_ops eeepcbl_ops = { 238 .get_brightness = read_brightness, 239 .update_status = update_bl_status, 240 }; 241 242 MODULE_AUTHOR("Corentin Chary, Eric Cooper"); 243 MODULE_DESCRIPTION(EEEPC_HOTK_NAME); 244 MODULE_LICENSE("GPL"); 245 246 /* 247 * ACPI Helpers 248 */ 249 static int write_acpi_int(acpi_handle handle, const char *method, int val, 250 struct acpi_buffer *output) 251 { 252 struct acpi_object_list params; 253 union acpi_object in_obj; 254 acpi_status status; 255 256 params.count = 1; 257 params.pointer = &in_obj; 258 in_obj.type = ACPI_TYPE_INTEGER; 259 in_obj.integer.value = val; 260 261 status = acpi_evaluate_object(handle, (char *)method, ¶ms, output); 262 return (status == AE_OK ? 0 : -1); 263 } 264 265 static int read_acpi_int(acpi_handle handle, const char *method, int *val) 266 { 267 acpi_status status; 268 unsigned long long result; 269 270 status = acpi_evaluate_integer(handle, (char *)method, NULL, &result); 271 if (ACPI_FAILURE(status)) { 272 *val = -1; 273 return -1; 274 } else { 275 *val = result; 276 return 0; 277 } 278 } 279 280 static int set_acpi(int cm, int value) 281 { 282 if (ehotk->cm_supported & (0x1 << cm)) { 283 const char *method = cm_setv[cm]; 284 if (method == NULL) 285 return -ENODEV; 286 if (write_acpi_int(ehotk->handle, method, value, NULL)) 287 pr_warning("Error writing %s\n", method); 288 } 289 return 0; 290 } 291 292 static int get_acpi(int cm) 293 { 294 int value = -ENODEV; 295 if ((ehotk->cm_supported & (0x1 << cm))) { 296 const char *method = cm_getv[cm]; 297 if (method == NULL) 298 return -ENODEV; 299 if (read_acpi_int(ehotk->handle, method, &value)) 300 pr_warning("Error reading %s\n", method); 301 } 302 return value; 303 } 304 305 /* 306 * Backlight 307 */ 308 static int read_brightness(struct backlight_device *bd) 309 { 310 return get_acpi(CM_ASL_PANELBRIGHT); 311 } 312 313 static int set_brightness(struct backlight_device *bd, int value) 314 { 315 value = max(0, min(15, value)); 316 return set_acpi(CM_ASL_PANELBRIGHT, value); 317 } 318 319 static int update_bl_status(struct backlight_device *bd) 320 { 321 return set_brightness(bd, bd->props.brightness); 322 } 323 324 /* 325 * Rfkill helpers 326 */ 327 328 static bool eeepc_wlan_rfkill_blocked(void) 329 { 330 if (get_acpi(CM_ASL_WLAN) == 1) 331 return false; 332 return true; 333 } 334 335 static int eeepc_rfkill_set(void *data, bool blocked) 336 { 337 unsigned long asl = (unsigned long)data; 338 return set_acpi(asl, !blocked); 339 } 340 341 static const struct rfkill_ops eeepc_rfkill_ops = { 342 .set_block = eeepc_rfkill_set, 343 }; 344 345 static void __init eeepc_enable_camera(void) 346 { 347 /* 348 * If the following call to set_acpi() fails, it's because there's no 349 * camera so we can ignore the error. 350 */ 351 set_acpi(CM_ASL_CAMERA, 1); 352 } 353 354 /* 355 * Sys helpers 356 */ 357 static int parse_arg(const char *buf, unsigned long count, int *val) 358 { 359 if (!count) 360 return 0; 361 if (sscanf(buf, "%i", val) != 1) 362 return -EINVAL; 363 return count; 364 } 365 366 static ssize_t store_sys_acpi(int cm, const char *buf, size_t count) 367 { 368 int rv, value; 369 370 rv = parse_arg(buf, count, &value); 371 if (rv > 0) 372 value = set_acpi(cm, value); 373 if (value < 0) 374 return value; 375 return rv; 376 } 377 378 static ssize_t show_sys_acpi(int cm, char *buf) 379 { 380 int value = get_acpi(cm); 381 382 if (value < 0) 383 return value; 384 return sprintf(buf, "%d\n", value); 385 } 386 387 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm) \ 388 static ssize_t show_##_name(struct device *dev, \ 389 struct device_attribute *attr, \ 390 char *buf) \ 391 { \ 392 return show_sys_acpi(_cm, buf); \ 393 } \ 394 static ssize_t store_##_name(struct device *dev, \ 395 struct device_attribute *attr, \ 396 const char *buf, size_t count) \ 397 { \ 398 return store_sys_acpi(_cm, buf, count); \ 399 } \ 400 static struct device_attribute dev_attr_##_name = { \ 401 .attr = { \ 402 .name = __stringify(_name), \ 403 .mode = 0644 }, \ 404 .show = show_##_name, \ 405 .store = store_##_name, \ 406 } 407 408 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA); 409 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER); 410 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH); 411 412 struct eeepc_cpufv { 413 int num; 414 int cur; 415 }; 416 417 static int get_cpufv(struct eeepc_cpufv *c) 418 { 419 c->cur = get_acpi(CM_ASL_CPUFV); 420 c->num = (c->cur >> 8) & 0xff; 421 c->cur &= 0xff; 422 if (c->cur < 0 || c->num <= 0 || c->num > 12) 423 return -ENODEV; 424 return 0; 425 } 426 427 static ssize_t show_available_cpufv(struct device *dev, 428 struct device_attribute *attr, 429 char *buf) 430 { 431 struct eeepc_cpufv c; 432 int i; 433 ssize_t len = 0; 434 435 if (get_cpufv(&c)) 436 return -ENODEV; 437 for (i = 0; i < c.num; i++) 438 len += sprintf(buf + len, "%d ", i); 439 len += sprintf(buf + len, "\n"); 440 return len; 441 } 442 443 static ssize_t show_cpufv(struct device *dev, 444 struct device_attribute *attr, 445 char *buf) 446 { 447 struct eeepc_cpufv c; 448 449 if (get_cpufv(&c)) 450 return -ENODEV; 451 return sprintf(buf, "%#x\n", (c.num << 8) | c.cur); 452 } 453 454 static ssize_t store_cpufv(struct device *dev, 455 struct device_attribute *attr, 456 const char *buf, size_t count) 457 { 458 struct eeepc_cpufv c; 459 int rv, value; 460 461 if (get_cpufv(&c)) 462 return -ENODEV; 463 rv = parse_arg(buf, count, &value); 464 if (rv < 0) 465 return rv; 466 if (!rv || value < 0 || value >= c.num) 467 return -EINVAL; 468 set_acpi(CM_ASL_CPUFV, value); 469 return rv; 470 } 471 472 static struct device_attribute dev_attr_cpufv = { 473 .attr = { 474 .name = "cpufv", 475 .mode = 0644 }, 476 .show = show_cpufv, 477 .store = store_cpufv 478 }; 479 480 static struct device_attribute dev_attr_available_cpufv = { 481 .attr = { 482 .name = "available_cpufv", 483 .mode = 0444 }, 484 .show = show_available_cpufv 485 }; 486 487 static struct attribute *platform_attributes[] = { 488 &dev_attr_camera.attr, 489 &dev_attr_cardr.attr, 490 &dev_attr_disp.attr, 491 &dev_attr_cpufv.attr, 492 &dev_attr_available_cpufv.attr, 493 NULL 494 }; 495 496 static struct attribute_group platform_attribute_group = { 497 .attrs = platform_attributes 498 }; 499 500 /* 501 * Hotkey functions 502 */ 503 static struct key_entry *eepc_get_entry_by_scancode(int code) 504 { 505 struct key_entry *key; 506 507 for (key = eeepc_keymap; key->type != KE_END; key++) 508 if (code == key->code) 509 return key; 510 511 return NULL; 512 } 513 514 static struct key_entry *eepc_get_entry_by_keycode(int code) 515 { 516 struct key_entry *key; 517 518 for (key = eeepc_keymap; key->type != KE_END; key++) 519 if (code == key->keycode && key->type == KE_KEY) 520 return key; 521 522 return NULL; 523 } 524 525 static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode) 526 { 527 struct key_entry *key = eepc_get_entry_by_scancode(scancode); 528 529 if (key && key->type == KE_KEY) { 530 *keycode = key->keycode; 531 return 0; 532 } 533 534 return -EINVAL; 535 } 536 537 static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode) 538 { 539 struct key_entry *key; 540 int old_keycode; 541 542 if (keycode < 0 || keycode > KEY_MAX) 543 return -EINVAL; 544 545 key = eepc_get_entry_by_scancode(scancode); 546 if (key && key->type == KE_KEY) { 547 old_keycode = key->keycode; 548 key->keycode = keycode; 549 set_bit(keycode, dev->keybit); 550 if (!eepc_get_entry_by_keycode(old_keycode)) 551 clear_bit(old_keycode, dev->keybit); 552 return 0; 553 } 554 555 return -EINVAL; 556 } 557 558 static void cmsg_quirk(int cm, const char *name) 559 { 560 int dummy; 561 562 /* Some BIOSes do not report cm although it is avaliable. 563 Check if cm_getv[cm] works and, if yes, assume cm should be set. */ 564 if (!(ehotk->cm_supported & (1 << cm)) 565 && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) { 566 pr_info("%s (%x) not reported by BIOS," 567 " enabling anyway\n", name, 1 << cm); 568 ehotk->cm_supported |= 1 << cm; 569 } 570 } 571 572 static void cmsg_quirks(void) 573 { 574 cmsg_quirk(CM_ASL_LID, "LID"); 575 cmsg_quirk(CM_ASL_TYPE, "TYPE"); 576 cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER"); 577 cmsg_quirk(CM_ASL_TPD, "TPD"); 578 } 579 580 static int eeepc_hotk_check(void) 581 { 582 const struct key_entry *key; 583 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 584 int result; 585 586 result = acpi_bus_get_status(ehotk->device); 587 if (result) 588 return result; 589 if (ehotk->device->status.present) { 590 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag, 591 &buffer)) { 592 pr_err("Hotkey initialization failed\n"); 593 return -ENODEV; 594 } else { 595 pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag); 596 } 597 /* get control methods supported */ 598 if (read_acpi_int(ehotk->handle, "CMSG" 599 , &ehotk->cm_supported)) { 600 pr_err("Get control methods supported failed\n"); 601 return -ENODEV; 602 } else { 603 cmsg_quirks(); 604 pr_info("Get control methods supported: 0x%x\n", 605 ehotk->cm_supported); 606 } 607 ehotk->inputdev = input_allocate_device(); 608 if (!ehotk->inputdev) { 609 pr_info("Unable to allocate input device\n"); 610 return 0; 611 } 612 ehotk->inputdev->name = "Asus EeePC extra buttons"; 613 ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0"; 614 ehotk->inputdev->id.bustype = BUS_HOST; 615 ehotk->inputdev->getkeycode = eeepc_getkeycode; 616 ehotk->inputdev->setkeycode = eeepc_setkeycode; 617 618 for (key = eeepc_keymap; key->type != KE_END; key++) { 619 switch (key->type) { 620 case KE_KEY: 621 set_bit(EV_KEY, ehotk->inputdev->evbit); 622 set_bit(key->keycode, ehotk->inputdev->keybit); 623 break; 624 } 625 } 626 result = input_register_device(ehotk->inputdev); 627 if (result) { 628 pr_info("Unable to register input device\n"); 629 input_free_device(ehotk->inputdev); 630 return 0; 631 } 632 } else { 633 pr_err("Hotkey device not present, aborting\n"); 634 return -EINVAL; 635 } 636 return 0; 637 } 638 639 static int notify_brn(void) 640 { 641 /* returns the *previous* brightness, or -1 */ 642 struct backlight_device *bd = eeepc_backlight_device; 643 if (bd) { 644 int old = bd->props.brightness; 645 bd->props.brightness = read_brightness(bd); 646 return old; 647 } 648 return -1; 649 } 650 651 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot, 652 u8 *value) 653 { 654 int val = get_acpi(CM_ASL_WLAN); 655 656 if (val == 1 || val == 0) 657 *value = val; 658 else 659 return -EINVAL; 660 661 return 0; 662 } 663 664 static void eeepc_hotplug_work(struct work_struct *work) 665 { 666 struct pci_dev *dev; 667 struct pci_bus *bus = pci_find_bus(0, 1); 668 bool blocked; 669 670 if (!bus) { 671 pr_warning("Unable to find PCI bus 1?\n"); 672 return; 673 } 674 675 blocked = eeepc_wlan_rfkill_blocked(); 676 if (!blocked) { 677 dev = pci_get_slot(bus, 0); 678 if (dev) { 679 /* Device already present */ 680 pci_dev_put(dev); 681 return; 682 } 683 dev = pci_scan_single_device(bus, 0); 684 if (dev) { 685 pci_bus_assign_resources(bus); 686 if (pci_bus_add_device(dev)) 687 pr_err("Unable to hotplug wifi\n"); 688 } 689 } else { 690 dev = pci_get_slot(bus, 0); 691 if (dev) { 692 pci_remove_bus_device(dev); 693 pci_dev_put(dev); 694 } 695 } 696 697 rfkill_set_sw_state(ehotk->wlan_rfkill, blocked); 698 } 699 700 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data) 701 { 702 if (event != ACPI_NOTIFY_BUS_CHECK) 703 return; 704 705 schedule_work(&ehotk->hotplug_work); 706 } 707 708 static void eeepc_hotk_notify(struct acpi_device *device, u32 event) 709 { 710 static struct key_entry *key; 711 u16 count; 712 int brn = -ENODEV; 713 714 if (!ehotk) 715 return; 716 if (event > ACPI_MAX_SYS_NOTIFY) 717 return; 718 if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX) 719 brn = notify_brn(); 720 count = ehotk->event_count[event % 128]++; 721 acpi_bus_generate_proc_event(ehotk->device, event, count); 722 acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class, 723 dev_name(&ehotk->device->dev), event, 724 count); 725 if (ehotk->inputdev) { 726 if (brn != -ENODEV) { 727 /* brightness-change events need special 728 * handling for conversion to key events 729 */ 730 if (brn < 0) 731 brn = event; 732 else 733 brn += NOTIFY_BRN_MIN; 734 if (event < brn) 735 event = NOTIFY_BRN_MIN; /* brightness down */ 736 else if (event > brn) 737 event = NOTIFY_BRN_MIN + 2; /* ... up */ 738 else 739 event = NOTIFY_BRN_MIN + 1; /* ... unchanged */ 740 } 741 key = eepc_get_entry_by_scancode(event); 742 if (key) { 743 switch (key->type) { 744 case KE_KEY: 745 input_report_key(ehotk->inputdev, key->keycode, 746 1); 747 input_sync(ehotk->inputdev); 748 input_report_key(ehotk->inputdev, key->keycode, 749 0); 750 input_sync(ehotk->inputdev); 751 break; 752 } 753 } 754 } 755 } 756 757 static int eeepc_register_rfkill_notifier(char *node) 758 { 759 acpi_status status = AE_OK; 760 acpi_handle handle; 761 762 status = acpi_get_handle(NULL, node, &handle); 763 764 if (ACPI_SUCCESS(status)) { 765 status = acpi_install_notify_handler(handle, 766 ACPI_SYSTEM_NOTIFY, 767 eeepc_rfkill_notify, 768 NULL); 769 if (ACPI_FAILURE(status)) 770 pr_warning("Failed to register notify on %s\n", node); 771 } else 772 return -ENODEV; 773 774 return 0; 775 } 776 777 static void eeepc_unregister_rfkill_notifier(char *node) 778 { 779 acpi_status status = AE_OK; 780 acpi_handle handle; 781 782 status = acpi_get_handle(NULL, node, &handle); 783 784 if (ACPI_SUCCESS(status)) { 785 status = acpi_remove_notify_handler(handle, 786 ACPI_SYSTEM_NOTIFY, 787 eeepc_rfkill_notify); 788 if (ACPI_FAILURE(status)) 789 pr_err("Error removing rfkill notify handler %s\n", 790 node); 791 } 792 } 793 794 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot) 795 { 796 kfree(hotplug_slot->info); 797 kfree(hotplug_slot); 798 } 799 800 static int eeepc_setup_pci_hotplug(void) 801 { 802 int ret = -ENOMEM; 803 struct pci_bus *bus = pci_find_bus(0, 1); 804 805 if (!bus) { 806 pr_err("Unable to find wifi PCI bus\n"); 807 return -ENODEV; 808 } 809 810 ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL); 811 if (!ehotk->hotplug_slot) 812 goto error_slot; 813 814 ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info), 815 GFP_KERNEL); 816 if (!ehotk->hotplug_slot->info) 817 goto error_info; 818 819 ehotk->hotplug_slot->private = ehotk; 820 ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug; 821 ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops; 822 eeepc_get_adapter_status(ehotk->hotplug_slot, 823 &ehotk->hotplug_slot->info->adapter_status); 824 825 ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi"); 826 if (ret) { 827 pr_err("Unable to register hotplug slot - %d\n", ret); 828 goto error_register; 829 } 830 831 return 0; 832 833 error_register: 834 kfree(ehotk->hotplug_slot->info); 835 error_info: 836 kfree(ehotk->hotplug_slot); 837 ehotk->hotplug_slot = NULL; 838 error_slot: 839 return ret; 840 } 841 842 static int eeepc_hotk_add(struct acpi_device *device) 843 { 844 int result; 845 846 if (!device) 847 return -EINVAL; 848 pr_notice(EEEPC_HOTK_NAME "\n"); 849 ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL); 850 if (!ehotk) 851 return -ENOMEM; 852 ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH; 853 ehotk->handle = device->handle; 854 strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME); 855 strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS); 856 device->driver_data = ehotk; 857 ehotk->device = device; 858 result = eeepc_hotk_check(); 859 if (result) 860 goto ehotk_fail; 861 862 return 0; 863 864 ehotk_fail: 865 kfree(ehotk); 866 ehotk = NULL; 867 868 return result; 869 } 870 871 static int eeepc_hotk_remove(struct acpi_device *device, int type) 872 { 873 if (!device || !acpi_driver_data(device)) 874 return -EINVAL; 875 876 kfree(ehotk); 877 return 0; 878 } 879 880 static int eeepc_hotk_resume(struct acpi_device *device) 881 { 882 if (ehotk->wlan_rfkill) { 883 bool wlan; 884 885 /* Workaround - it seems that _PTS disables the wireless 886 without notification or changing the value read by WLAN. 887 Normally this is fine because the correct value is restored 888 from the non-volatile storage on resume, but we need to do 889 it ourself if case suspend is aborted, or we lose wireless. 890 */ 891 wlan = get_acpi(CM_ASL_WLAN); 892 set_acpi(CM_ASL_WLAN, wlan); 893 894 rfkill_set_sw_state(ehotk->wlan_rfkill, wlan != 1); 895 896 schedule_work(&ehotk->hotplug_work); 897 } 898 899 if (ehotk->bluetooth_rfkill) 900 rfkill_set_sw_state(ehotk->bluetooth_rfkill, 901 get_acpi(CM_ASL_BLUETOOTH) != 1); 902 903 return 0; 904 } 905 906 /* 907 * Hwmon 908 */ 909 static int eeepc_get_fan_pwm(void) 910 { 911 int value = 0; 912 913 read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value); 914 value = value * 255 / 100; 915 return (value); 916 } 917 918 static void eeepc_set_fan_pwm(int value) 919 { 920 value = SENSORS_LIMIT(value, 0, 255); 921 value = value * 100 / 255; 922 ec_write(EEEPC_EC_SC02, value); 923 } 924 925 static int eeepc_get_fan_rpm(void) 926 { 927 int high = 0; 928 int low = 0; 929 930 read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high); 931 read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low); 932 return (high << 8 | low); 933 } 934 935 static int eeepc_get_fan_ctrl(void) 936 { 937 int value = 0; 938 939 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value); 940 return ((value & 0x02 ? 1 : 0)); 941 } 942 943 static void eeepc_set_fan_ctrl(int manual) 944 { 945 int value = 0; 946 947 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value); 948 if (manual) 949 value |= 0x02; 950 else 951 value &= ~0x02; 952 ec_write(EEEPC_EC_SFB3, value); 953 } 954 955 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count) 956 { 957 int rv, value; 958 959 rv = parse_arg(buf, count, &value); 960 if (rv > 0) 961 set(value); 962 return rv; 963 } 964 965 static ssize_t show_sys_hwmon(int (*get)(void), char *buf) 966 { 967 return sprintf(buf, "%d\n", get()); 968 } 969 970 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \ 971 static ssize_t show_##_name(struct device *dev, \ 972 struct device_attribute *attr, \ 973 char *buf) \ 974 { \ 975 return show_sys_hwmon(_set, buf); \ 976 } \ 977 static ssize_t store_##_name(struct device *dev, \ 978 struct device_attribute *attr, \ 979 const char *buf, size_t count) \ 980 { \ 981 return store_sys_hwmon(_get, buf, count); \ 982 } \ 983 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0); 984 985 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL); 986 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR, 987 eeepc_get_fan_pwm, eeepc_set_fan_pwm); 988 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, 989 eeepc_get_fan_ctrl, eeepc_set_fan_ctrl); 990 991 static ssize_t 992 show_name(struct device *dev, struct device_attribute *attr, char *buf) 993 { 994 return sprintf(buf, "eeepc\n"); 995 } 996 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0); 997 998 static struct attribute *hwmon_attributes[] = { 999 &sensor_dev_attr_pwm1.dev_attr.attr, 1000 &sensor_dev_attr_fan1_input.dev_attr.attr, 1001 &sensor_dev_attr_pwm1_enable.dev_attr.attr, 1002 &sensor_dev_attr_name.dev_attr.attr, 1003 NULL 1004 }; 1005 1006 static struct attribute_group hwmon_attribute_group = { 1007 .attrs = hwmon_attributes 1008 }; 1009 1010 /* 1011 * exit/init 1012 */ 1013 static void eeepc_backlight_exit(void) 1014 { 1015 if (eeepc_backlight_device) 1016 backlight_device_unregister(eeepc_backlight_device); 1017 eeepc_backlight_device = NULL; 1018 } 1019 1020 static void eeepc_rfkill_exit(void) 1021 { 1022 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6"); 1023 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7"); 1024 if (ehotk->wlan_rfkill) 1025 rfkill_unregister(ehotk->wlan_rfkill); 1026 if (ehotk->bluetooth_rfkill) 1027 rfkill_unregister(ehotk->bluetooth_rfkill); 1028 if (ehotk->wwan3g_rfkill) 1029 rfkill_unregister(ehotk->wwan3g_rfkill); 1030 if (ehotk->hotplug_slot) 1031 pci_hp_deregister(ehotk->hotplug_slot); 1032 } 1033 1034 static void eeepc_input_exit(void) 1035 { 1036 if (ehotk->inputdev) 1037 input_unregister_device(ehotk->inputdev); 1038 } 1039 1040 static void eeepc_hwmon_exit(void) 1041 { 1042 struct device *hwmon; 1043 1044 hwmon = eeepc_hwmon_device; 1045 if (!hwmon) 1046 return ; 1047 sysfs_remove_group(&hwmon->kobj, 1048 &hwmon_attribute_group); 1049 hwmon_device_unregister(hwmon); 1050 eeepc_hwmon_device = NULL; 1051 } 1052 1053 static void __exit eeepc_laptop_exit(void) 1054 { 1055 eeepc_backlight_exit(); 1056 eeepc_rfkill_exit(); 1057 eeepc_input_exit(); 1058 eeepc_hwmon_exit(); 1059 acpi_bus_unregister_driver(&eeepc_hotk_driver); 1060 sysfs_remove_group(&platform_device->dev.kobj, 1061 &platform_attribute_group); 1062 platform_device_unregister(platform_device); 1063 platform_driver_unregister(&platform_driver); 1064 } 1065 1066 static int eeepc_new_rfkill(struct rfkill **rfkill, 1067 const char *name, struct device *dev, 1068 enum rfkill_type type, int cm) 1069 { 1070 int result; 1071 1072 result = get_acpi(cm); 1073 if (result < 0) 1074 return result; 1075 1076 *rfkill = rfkill_alloc(name, dev, type, 1077 &eeepc_rfkill_ops, (void *)(unsigned long)cm); 1078 1079 if (!*rfkill) 1080 return -EINVAL; 1081 1082 rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1); 1083 result = rfkill_register(*rfkill); 1084 if (result) { 1085 rfkill_destroy(*rfkill); 1086 *rfkill = NULL; 1087 return result; 1088 } 1089 return 0; 1090 } 1091 1092 1093 static int eeepc_rfkill_init(struct device *dev) 1094 { 1095 int result = 0; 1096 1097 INIT_WORK(&ehotk->hotplug_work, eeepc_hotplug_work); 1098 1099 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6"); 1100 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7"); 1101 1102 result = eeepc_new_rfkill(&ehotk->wlan_rfkill, 1103 "eeepc-wlan", dev, 1104 RFKILL_TYPE_WLAN, CM_ASL_WLAN); 1105 1106 if (result && result != -ENODEV) 1107 goto exit; 1108 1109 result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill, 1110 "eeepc-bluetooth", dev, 1111 RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH); 1112 1113 if (result && result != -ENODEV) 1114 goto exit; 1115 1116 result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill, 1117 "eeepc-wwan3g", dev, 1118 RFKILL_TYPE_WWAN, CM_ASL_3G); 1119 1120 if (result && result != -ENODEV) 1121 goto exit; 1122 1123 result = eeepc_setup_pci_hotplug(); 1124 /* 1125 * If we get -EBUSY then something else is handling the PCI hotplug - 1126 * don't fail in this case 1127 */ 1128 if (result == -EBUSY) 1129 result = 0; 1130 1131 exit: 1132 if (result && result != -ENODEV) 1133 eeepc_rfkill_exit(); 1134 return result; 1135 } 1136 1137 static int eeepc_backlight_init(struct device *dev) 1138 { 1139 struct backlight_device *bd; 1140 1141 bd = backlight_device_register(EEEPC_HOTK_FILE, dev, 1142 NULL, &eeepcbl_ops); 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.max_brightness = 15; 1150 bd->props.brightness = read_brightness(NULL); 1151 bd->props.power = FB_BLANK_UNBLANK; 1152 backlight_update_status(bd); 1153 return 0; 1154 } 1155 1156 static int eeepc_hwmon_init(struct device *dev) 1157 { 1158 struct device *hwmon; 1159 int result; 1160 1161 hwmon = hwmon_device_register(dev); 1162 if (IS_ERR(hwmon)) { 1163 pr_err("Could not register eeepc hwmon device\n"); 1164 eeepc_hwmon_device = NULL; 1165 return PTR_ERR(hwmon); 1166 } 1167 eeepc_hwmon_device = hwmon; 1168 result = sysfs_create_group(&hwmon->kobj, 1169 &hwmon_attribute_group); 1170 if (result) 1171 eeepc_hwmon_exit(); 1172 return result; 1173 } 1174 1175 static int __init eeepc_laptop_init(void) 1176 { 1177 struct device *dev; 1178 int result; 1179 1180 if (acpi_disabled) 1181 return -ENODEV; 1182 result = acpi_bus_register_driver(&eeepc_hotk_driver); 1183 if (result < 0) 1184 return result; 1185 if (!ehotk) { 1186 acpi_bus_unregister_driver(&eeepc_hotk_driver); 1187 return -ENODEV; 1188 } 1189 1190 eeepc_enable_camera(); 1191 1192 /* Register platform stuff */ 1193 result = platform_driver_register(&platform_driver); 1194 if (result) 1195 goto fail_platform_driver; 1196 platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1); 1197 if (!platform_device) { 1198 result = -ENOMEM; 1199 goto fail_platform_device1; 1200 } 1201 result = platform_device_add(platform_device); 1202 if (result) 1203 goto fail_platform_device2; 1204 result = sysfs_create_group(&platform_device->dev.kobj, 1205 &platform_attribute_group); 1206 if (result) 1207 goto fail_sysfs; 1208 1209 dev = &platform_device->dev; 1210 1211 if (!acpi_video_backlight_support()) { 1212 result = eeepc_backlight_init(dev); 1213 if (result) 1214 goto fail_backlight; 1215 } else 1216 pr_info("Backlight controlled by ACPI video " 1217 "driver\n"); 1218 1219 result = eeepc_hwmon_init(dev); 1220 if (result) 1221 goto fail_hwmon; 1222 1223 result = eeepc_rfkill_init(dev); 1224 if (result) 1225 goto fail_rfkill; 1226 1227 return 0; 1228 fail_rfkill: 1229 eeepc_hwmon_exit(); 1230 fail_hwmon: 1231 eeepc_backlight_exit(); 1232 fail_backlight: 1233 sysfs_remove_group(&platform_device->dev.kobj, 1234 &platform_attribute_group); 1235 fail_sysfs: 1236 platform_device_del(platform_device); 1237 fail_platform_device2: 1238 platform_device_put(platform_device); 1239 fail_platform_device1: 1240 platform_driver_unregister(&platform_driver); 1241 fail_platform_driver: 1242 eeepc_input_exit(); 1243 return result; 1244 } 1245 1246 module_init(eeepc_laptop_init); 1247 module_exit(eeepc_laptop_exit); 1248