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