1 /*-*-linux-c-*-*/ 2 3 /* 4 Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301, USA. 20 */ 21 22 /* 23 * msi-laptop.c - MSI S270 laptop support. This laptop is sold under 24 * various brands, including "Cytron/TCM/Medion/Tchibo MD96100". 25 * 26 * Driver also supports S271, S420 models. 27 * 28 * This driver exports a few files in /sys/devices/platform/msi-laptop-pf/: 29 * 30 * lcd_level - Screen brightness: contains a single integer in the 31 * range 0..8. (rw) 32 * 33 * auto_brightness - Enable automatic brightness control: contains 34 * either 0 or 1. If set to 1 the hardware adjusts the screen 35 * brightness automatically when the power cord is 36 * plugged/unplugged. (rw) 37 * 38 * wlan - WLAN subsystem enabled: contains either 0 or 1. (ro) 39 * 40 * bluetooth - Bluetooth subsystem enabled: contains either 0 or 1 41 * Please note that this file is constantly 0 if no Bluetooth 42 * hardware is available. (ro) 43 * 44 * In addition to these platform device attributes the driver 45 * registers itself in the Linux backlight control subsystem and is 46 * available to userspace under /sys/class/backlight/msi-laptop-bl/. 47 * 48 * This driver might work on other laptops produced by MSI. If you 49 * want to try it you can pass force=1 as argument to the module which 50 * will force it to load even when the DMI data doesn't identify the 51 * laptop as MSI S270. YMMV. 52 */ 53 54 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 55 56 #include <linux/module.h> 57 #include <linux/kernel.h> 58 #include <linux/init.h> 59 #include <linux/acpi.h> 60 #include <linux/dmi.h> 61 #include <linux/backlight.h> 62 #include <linux/platform_device.h> 63 #include <linux/rfkill.h> 64 #include <linux/i8042.h> 65 #include <linux/input.h> 66 #include <linux/input/sparse-keymap.h> 67 #include <acpi/video.h> 68 69 #define MSI_DRIVER_VERSION "0.5" 70 71 #define MSI_LCD_LEVEL_MAX 9 72 73 #define MSI_EC_COMMAND_WIRELESS 0x10 74 #define MSI_EC_COMMAND_LCD_LEVEL 0x11 75 76 #define MSI_STANDARD_EC_COMMAND_ADDRESS 0x2e 77 #define MSI_STANDARD_EC_BLUETOOTH_MASK (1 << 0) 78 #define MSI_STANDARD_EC_WEBCAM_MASK (1 << 1) 79 #define MSI_STANDARD_EC_WLAN_MASK (1 << 3) 80 #define MSI_STANDARD_EC_3G_MASK (1 << 4) 81 82 /* For set SCM load flag to disable BIOS fn key */ 83 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS 0x2d 84 #define MSI_STANDARD_EC_SCM_LOAD_MASK (1 << 0) 85 86 #define MSI_STANDARD_EC_FUNCTIONS_ADDRESS 0xe4 87 /* Power LED is orange - Turbo mode */ 88 #define MSI_STANDARD_EC_TURBO_MASK (1 << 1) 89 /* Power LED is green - ECO mode */ 90 #define MSI_STANDARD_EC_ECO_MASK (1 << 3) 91 /* Touchpad is turned on */ 92 #define MSI_STANDARD_EC_TOUCHPAD_MASK (1 << 4) 93 /* If this bit != bit 1, turbo mode can't be toggled */ 94 #define MSI_STANDARD_EC_TURBO_COOLDOWN_MASK (1 << 7) 95 96 #define MSI_STANDARD_EC_FAN_ADDRESS 0x33 97 /* If zero, fan rotates at maximal speed */ 98 #define MSI_STANDARD_EC_AUTOFAN_MASK (1 << 0) 99 100 #ifdef CONFIG_PM_SLEEP 101 static int msi_laptop_resume(struct device *device); 102 #endif 103 static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume); 104 105 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS 0x2f 106 107 static bool force; 108 module_param(force, bool, 0); 109 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); 110 111 static int auto_brightness; 112 module_param(auto_brightness, int, 0); 113 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)"); 114 115 static const struct key_entry msi_laptop_keymap[] = { 116 {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} }, /* Touch Pad On */ 117 {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */ 118 {KE_END, 0} 119 }; 120 121 static struct input_dev *msi_laptop_input_dev; 122 123 static int wlan_s, bluetooth_s, threeg_s; 124 static int threeg_exists; 125 static struct rfkill *rfk_wlan, *rfk_bluetooth, *rfk_threeg; 126 127 /* MSI laptop quirks */ 128 struct quirk_entry { 129 bool old_ec_model; 130 131 /* Some MSI 3G netbook only have one fn key to control 132 * Wlan/Bluetooth/3G, those netbook will load the SCM (windows app) to 133 * disable the original Wlan/Bluetooth control by BIOS when user press 134 * fn key, then control Wlan/Bluetooth/3G by SCM (software control by 135 * OS). Without SCM, user cann't on/off 3G module on those 3G netbook. 136 * On Linux, msi-laptop driver will do the same thing to disable the 137 * original BIOS control, then might need use HAL or other userland 138 * application to do the software control that simulate with SCM. 139 * e.g. MSI N034 netbook 140 */ 141 bool load_scm_model; 142 143 /* Some MSI laptops need delay before reading from EC */ 144 bool ec_delay; 145 146 /* Some MSI Wind netbooks (e.g. MSI Wind U100) need loading SCM to get 147 * some features working (e.g. ECO mode), but we cannot change 148 * Wlan/Bluetooth state in software and we can only read its state. 149 */ 150 bool ec_read_only; 151 }; 152 153 static struct quirk_entry *quirks; 154 155 /* Hardware access */ 156 157 static int set_lcd_level(int level) 158 { 159 u8 buf[2]; 160 161 if (level < 0 || level >= MSI_LCD_LEVEL_MAX) 162 return -EINVAL; 163 164 buf[0] = 0x80; 165 buf[1] = (u8) (level*31); 166 167 return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf), 168 NULL, 0); 169 } 170 171 static int get_lcd_level(void) 172 { 173 u8 wdata = 0, rdata; 174 int result; 175 176 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1, 177 &rdata, 1); 178 if (result < 0) 179 return result; 180 181 return (int) rdata / 31; 182 } 183 184 static int get_auto_brightness(void) 185 { 186 u8 wdata = 4, rdata; 187 int result; 188 189 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1, 190 &rdata, 1); 191 if (result < 0) 192 return result; 193 194 return !!(rdata & 8); 195 } 196 197 static int set_auto_brightness(int enable) 198 { 199 u8 wdata[2], rdata; 200 int result; 201 202 wdata[0] = 4; 203 204 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1, 205 &rdata, 1); 206 if (result < 0) 207 return result; 208 209 wdata[0] = 0x84; 210 wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0); 211 212 return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2, 213 NULL, 0); 214 } 215 216 static ssize_t set_device_state(const char *buf, size_t count, u8 mask) 217 { 218 int status; 219 u8 wdata = 0, rdata; 220 int result; 221 222 if (sscanf(buf, "%i", &status) != 1 || (status < 0 || status > 1)) 223 return -EINVAL; 224 225 if (quirks->ec_read_only) 226 return -EOPNOTSUPP; 227 228 /* read current device state */ 229 result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata); 230 if (result < 0) 231 return result; 232 233 if (!!(rdata & mask) != status) { 234 /* reverse device bit */ 235 if (rdata & mask) 236 wdata = rdata & ~mask; 237 else 238 wdata = rdata | mask; 239 240 result = ec_write(MSI_STANDARD_EC_COMMAND_ADDRESS, wdata); 241 if (result < 0) 242 return result; 243 } 244 245 return count; 246 } 247 248 static int get_wireless_state(int *wlan, int *bluetooth) 249 { 250 u8 wdata = 0, rdata; 251 int result; 252 253 result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1); 254 if (result < 0) 255 return result; 256 257 if (wlan) 258 *wlan = !!(rdata & 8); 259 260 if (bluetooth) 261 *bluetooth = !!(rdata & 128); 262 263 return 0; 264 } 265 266 static int get_wireless_state_ec_standard(void) 267 { 268 u8 rdata; 269 int result; 270 271 result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata); 272 if (result < 0) 273 return result; 274 275 wlan_s = !!(rdata & MSI_STANDARD_EC_WLAN_MASK); 276 277 bluetooth_s = !!(rdata & MSI_STANDARD_EC_BLUETOOTH_MASK); 278 279 threeg_s = !!(rdata & MSI_STANDARD_EC_3G_MASK); 280 281 return 0; 282 } 283 284 static int get_threeg_exists(void) 285 { 286 u8 rdata; 287 int result; 288 289 result = ec_read(MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS, &rdata); 290 if (result < 0) 291 return result; 292 293 threeg_exists = !!(rdata & MSI_STANDARD_EC_3G_MASK); 294 295 return 0; 296 } 297 298 /* Backlight device stuff */ 299 300 static int bl_get_brightness(struct backlight_device *b) 301 { 302 return get_lcd_level(); 303 } 304 305 306 static int bl_update_status(struct backlight_device *b) 307 { 308 return set_lcd_level(b->props.brightness); 309 } 310 311 static const struct backlight_ops msibl_ops = { 312 .get_brightness = bl_get_brightness, 313 .update_status = bl_update_status, 314 }; 315 316 static struct backlight_device *msibl_device; 317 318 /* Platform device */ 319 320 static ssize_t show_wlan(struct device *dev, 321 struct device_attribute *attr, char *buf) 322 { 323 324 int ret, enabled = 0; 325 326 if (quirks->old_ec_model) { 327 ret = get_wireless_state(&enabled, NULL); 328 } else { 329 ret = get_wireless_state_ec_standard(); 330 enabled = wlan_s; 331 } 332 if (ret < 0) 333 return ret; 334 335 return sprintf(buf, "%i\n", enabled); 336 } 337 338 static ssize_t store_wlan(struct device *dev, 339 struct device_attribute *attr, const char *buf, size_t count) 340 { 341 return set_device_state(buf, count, MSI_STANDARD_EC_WLAN_MASK); 342 } 343 344 static ssize_t show_bluetooth(struct device *dev, 345 struct device_attribute *attr, char *buf) 346 { 347 348 int ret, enabled = 0; 349 350 if (quirks->old_ec_model) { 351 ret = get_wireless_state(NULL, &enabled); 352 } else { 353 ret = get_wireless_state_ec_standard(); 354 enabled = bluetooth_s; 355 } 356 if (ret < 0) 357 return ret; 358 359 return sprintf(buf, "%i\n", enabled); 360 } 361 362 static ssize_t store_bluetooth(struct device *dev, 363 struct device_attribute *attr, const char *buf, size_t count) 364 { 365 return set_device_state(buf, count, MSI_STANDARD_EC_BLUETOOTH_MASK); 366 } 367 368 static ssize_t show_threeg(struct device *dev, 369 struct device_attribute *attr, char *buf) 370 { 371 372 int ret; 373 374 /* old msi ec not support 3G */ 375 if (quirks->old_ec_model) 376 return -ENODEV; 377 378 ret = get_wireless_state_ec_standard(); 379 if (ret < 0) 380 return ret; 381 382 return sprintf(buf, "%i\n", threeg_s); 383 } 384 385 static ssize_t store_threeg(struct device *dev, 386 struct device_attribute *attr, const char *buf, size_t count) 387 { 388 return set_device_state(buf, count, MSI_STANDARD_EC_3G_MASK); 389 } 390 391 static ssize_t show_lcd_level(struct device *dev, 392 struct device_attribute *attr, char *buf) 393 { 394 395 int ret; 396 397 ret = get_lcd_level(); 398 if (ret < 0) 399 return ret; 400 401 return sprintf(buf, "%i\n", ret); 402 } 403 404 static ssize_t store_lcd_level(struct device *dev, 405 struct device_attribute *attr, const char *buf, size_t count) 406 { 407 408 int level, ret; 409 410 if (sscanf(buf, "%i", &level) != 1 || 411 (level < 0 || level >= MSI_LCD_LEVEL_MAX)) 412 return -EINVAL; 413 414 ret = set_lcd_level(level); 415 if (ret < 0) 416 return ret; 417 418 return count; 419 } 420 421 static ssize_t show_auto_brightness(struct device *dev, 422 struct device_attribute *attr, char *buf) 423 { 424 425 int ret; 426 427 ret = get_auto_brightness(); 428 if (ret < 0) 429 return ret; 430 431 return sprintf(buf, "%i\n", ret); 432 } 433 434 static ssize_t store_auto_brightness(struct device *dev, 435 struct device_attribute *attr, const char *buf, size_t count) 436 { 437 438 int enable, ret; 439 440 if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1))) 441 return -EINVAL; 442 443 ret = set_auto_brightness(enable); 444 if (ret < 0) 445 return ret; 446 447 return count; 448 } 449 450 static ssize_t show_touchpad(struct device *dev, 451 struct device_attribute *attr, char *buf) 452 { 453 454 u8 rdata; 455 int result; 456 457 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 458 if (result < 0) 459 return result; 460 461 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TOUCHPAD_MASK)); 462 } 463 464 static ssize_t show_turbo(struct device *dev, 465 struct device_attribute *attr, char *buf) 466 { 467 468 u8 rdata; 469 int result; 470 471 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 472 if (result < 0) 473 return result; 474 475 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TURBO_MASK)); 476 } 477 478 static ssize_t show_eco(struct device *dev, 479 struct device_attribute *attr, char *buf) 480 { 481 482 u8 rdata; 483 int result; 484 485 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 486 if (result < 0) 487 return result; 488 489 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_ECO_MASK)); 490 } 491 492 static ssize_t show_turbo_cooldown(struct device *dev, 493 struct device_attribute *attr, char *buf) 494 { 495 496 u8 rdata; 497 int result; 498 499 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 500 if (result < 0) 501 return result; 502 503 return sprintf(buf, "%i\n", (!!(rdata & MSI_STANDARD_EC_TURBO_MASK)) | 504 (!!(rdata & MSI_STANDARD_EC_TURBO_COOLDOWN_MASK) << 1)); 505 } 506 507 static ssize_t show_auto_fan(struct device *dev, 508 struct device_attribute *attr, char *buf) 509 { 510 511 u8 rdata; 512 int result; 513 514 result = ec_read(MSI_STANDARD_EC_FAN_ADDRESS, &rdata); 515 if (result < 0) 516 return result; 517 518 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_AUTOFAN_MASK)); 519 } 520 521 static ssize_t store_auto_fan(struct device *dev, 522 struct device_attribute *attr, const char *buf, size_t count) 523 { 524 525 int enable, result; 526 527 if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1))) 528 return -EINVAL; 529 530 result = ec_write(MSI_STANDARD_EC_FAN_ADDRESS, enable); 531 if (result < 0) 532 return result; 533 534 return count; 535 } 536 537 static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level); 538 static DEVICE_ATTR(auto_brightness, 0644, show_auto_brightness, 539 store_auto_brightness); 540 static DEVICE_ATTR(bluetooth, 0444, show_bluetooth, NULL); 541 static DEVICE_ATTR(wlan, 0444, show_wlan, NULL); 542 static DEVICE_ATTR(threeg, 0444, show_threeg, NULL); 543 static DEVICE_ATTR(touchpad, 0444, show_touchpad, NULL); 544 static DEVICE_ATTR(turbo_mode, 0444, show_turbo, NULL); 545 static DEVICE_ATTR(eco_mode, 0444, show_eco, NULL); 546 static DEVICE_ATTR(turbo_cooldown, 0444, show_turbo_cooldown, NULL); 547 static DEVICE_ATTR(auto_fan, 0644, show_auto_fan, store_auto_fan); 548 549 static struct attribute *msipf_attributes[] = { 550 &dev_attr_bluetooth.attr, 551 &dev_attr_wlan.attr, 552 &dev_attr_touchpad.attr, 553 &dev_attr_turbo_mode.attr, 554 &dev_attr_eco_mode.attr, 555 &dev_attr_turbo_cooldown.attr, 556 &dev_attr_auto_fan.attr, 557 NULL 558 }; 559 560 static struct attribute *msipf_old_attributes[] = { 561 &dev_attr_lcd_level.attr, 562 &dev_attr_auto_brightness.attr, 563 NULL 564 }; 565 566 static struct attribute_group msipf_attribute_group = { 567 .attrs = msipf_attributes 568 }; 569 570 static struct attribute_group msipf_old_attribute_group = { 571 .attrs = msipf_old_attributes 572 }; 573 574 static struct platform_driver msipf_driver = { 575 .driver = { 576 .name = "msi-laptop-pf", 577 .pm = &msi_laptop_pm, 578 }, 579 }; 580 581 static struct platform_device *msipf_device; 582 583 /* Initialization */ 584 585 static struct quirk_entry quirk_old_ec_model = { 586 .old_ec_model = true, 587 }; 588 589 static struct quirk_entry quirk_load_scm_model = { 590 .load_scm_model = true, 591 .ec_delay = true, 592 }; 593 594 static struct quirk_entry quirk_load_scm_ro_model = { 595 .load_scm_model = true, 596 .ec_read_only = true, 597 }; 598 599 static int dmi_check_cb(const struct dmi_system_id *dmi) 600 { 601 pr_info("Identified laptop model '%s'\n", dmi->ident); 602 603 quirks = dmi->driver_data; 604 605 return 1; 606 } 607 608 static struct dmi_system_id __initdata msi_dmi_table[] = { 609 { 610 .ident = "MSI S270", 611 .matches = { 612 DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD"), 613 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1013"), 614 DMI_MATCH(DMI_PRODUCT_VERSION, "0131"), 615 DMI_MATCH(DMI_CHASSIS_VENDOR, 616 "MICRO-STAR INT'L CO.,LTD") 617 }, 618 .driver_data = &quirk_old_ec_model, 619 .callback = dmi_check_cb 620 }, 621 { 622 .ident = "MSI S271", 623 .matches = { 624 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), 625 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1058"), 626 DMI_MATCH(DMI_PRODUCT_VERSION, "0581"), 627 DMI_MATCH(DMI_BOARD_NAME, "MS-1058") 628 }, 629 .driver_data = &quirk_old_ec_model, 630 .callback = dmi_check_cb 631 }, 632 { 633 .ident = "MSI S420", 634 .matches = { 635 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), 636 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1412"), 637 DMI_MATCH(DMI_BOARD_VENDOR, "MSI"), 638 DMI_MATCH(DMI_BOARD_NAME, "MS-1412") 639 }, 640 .driver_data = &quirk_old_ec_model, 641 .callback = dmi_check_cb 642 }, 643 { 644 .ident = "Medion MD96100", 645 .matches = { 646 DMI_MATCH(DMI_SYS_VENDOR, "NOTEBOOK"), 647 DMI_MATCH(DMI_PRODUCT_NAME, "SAM2000"), 648 DMI_MATCH(DMI_PRODUCT_VERSION, "0131"), 649 DMI_MATCH(DMI_CHASSIS_VENDOR, 650 "MICRO-STAR INT'L CO.,LTD") 651 }, 652 .driver_data = &quirk_old_ec_model, 653 .callback = dmi_check_cb 654 }, 655 { 656 .ident = "MSI N034", 657 .matches = { 658 DMI_MATCH(DMI_SYS_VENDOR, 659 "MICRO-STAR INTERNATIONAL CO., LTD"), 660 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N034"), 661 DMI_MATCH(DMI_CHASSIS_VENDOR, 662 "MICRO-STAR INTERNATIONAL CO., LTD") 663 }, 664 .driver_data = &quirk_load_scm_model, 665 .callback = dmi_check_cb 666 }, 667 { 668 .ident = "MSI N051", 669 .matches = { 670 DMI_MATCH(DMI_SYS_VENDOR, 671 "MICRO-STAR INTERNATIONAL CO., LTD"), 672 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N051"), 673 DMI_MATCH(DMI_CHASSIS_VENDOR, 674 "MICRO-STAR INTERNATIONAL CO., LTD") 675 }, 676 .driver_data = &quirk_load_scm_model, 677 .callback = dmi_check_cb 678 }, 679 { 680 .ident = "MSI N014", 681 .matches = { 682 DMI_MATCH(DMI_SYS_VENDOR, 683 "MICRO-STAR INTERNATIONAL CO., LTD"), 684 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N014"), 685 }, 686 .driver_data = &quirk_load_scm_model, 687 .callback = dmi_check_cb 688 }, 689 { 690 .ident = "MSI CR620", 691 .matches = { 692 DMI_MATCH(DMI_SYS_VENDOR, 693 "Micro-Star International"), 694 DMI_MATCH(DMI_PRODUCT_NAME, "CR620"), 695 }, 696 .driver_data = &quirk_load_scm_model, 697 .callback = dmi_check_cb 698 }, 699 { 700 .ident = "MSI U270", 701 .matches = { 702 DMI_MATCH(DMI_SYS_VENDOR, 703 "Micro-Star International Co., Ltd."), 704 DMI_MATCH(DMI_PRODUCT_NAME, "U270 series"), 705 }, 706 .driver_data = &quirk_load_scm_model, 707 .callback = dmi_check_cb 708 }, 709 { 710 .ident = "MSI U90/U100", 711 .matches = { 712 DMI_MATCH(DMI_SYS_VENDOR, 713 "MICRO-STAR INTERNATIONAL CO., LTD"), 714 DMI_MATCH(DMI_PRODUCT_NAME, "U90/U100"), 715 }, 716 .driver_data = &quirk_load_scm_ro_model, 717 .callback = dmi_check_cb 718 }, 719 { } 720 }; 721 722 static int rfkill_bluetooth_set(void *data, bool blocked) 723 { 724 /* Do something with blocked...*/ 725 /* 726 * blocked == false is on 727 * blocked == true is off 728 */ 729 int result = set_device_state(blocked ? "0" : "1", 0, 730 MSI_STANDARD_EC_BLUETOOTH_MASK); 731 732 return min(result, 0); 733 } 734 735 static int rfkill_wlan_set(void *data, bool blocked) 736 { 737 int result = set_device_state(blocked ? "0" : "1", 0, 738 MSI_STANDARD_EC_WLAN_MASK); 739 740 return min(result, 0); 741 } 742 743 static int rfkill_threeg_set(void *data, bool blocked) 744 { 745 int result = set_device_state(blocked ? "0" : "1", 0, 746 MSI_STANDARD_EC_3G_MASK); 747 748 return min(result, 0); 749 } 750 751 static const struct rfkill_ops rfkill_bluetooth_ops = { 752 .set_block = rfkill_bluetooth_set 753 }; 754 755 static const struct rfkill_ops rfkill_wlan_ops = { 756 .set_block = rfkill_wlan_set 757 }; 758 759 static const struct rfkill_ops rfkill_threeg_ops = { 760 .set_block = rfkill_threeg_set 761 }; 762 763 static void rfkill_cleanup(void) 764 { 765 if (rfk_bluetooth) { 766 rfkill_unregister(rfk_bluetooth); 767 rfkill_destroy(rfk_bluetooth); 768 } 769 770 if (rfk_threeg) { 771 rfkill_unregister(rfk_threeg); 772 rfkill_destroy(rfk_threeg); 773 } 774 775 if (rfk_wlan) { 776 rfkill_unregister(rfk_wlan); 777 rfkill_destroy(rfk_wlan); 778 } 779 } 780 781 static bool msi_rfkill_set_state(struct rfkill *rfkill, bool blocked) 782 { 783 if (quirks->ec_read_only) 784 return rfkill_set_hw_state(rfkill, blocked); 785 else 786 return rfkill_set_sw_state(rfkill, blocked); 787 } 788 789 static void msi_update_rfkill(struct work_struct *ignored) 790 { 791 get_wireless_state_ec_standard(); 792 793 if (rfk_wlan) 794 msi_rfkill_set_state(rfk_wlan, !wlan_s); 795 if (rfk_bluetooth) 796 msi_rfkill_set_state(rfk_bluetooth, !bluetooth_s); 797 if (rfk_threeg) 798 msi_rfkill_set_state(rfk_threeg, !threeg_s); 799 } 800 static DECLARE_DELAYED_WORK(msi_rfkill_dwork, msi_update_rfkill); 801 static DECLARE_WORK(msi_rfkill_work, msi_update_rfkill); 802 803 static void msi_send_touchpad_key(struct work_struct *ignored) 804 { 805 u8 rdata; 806 int result; 807 808 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 809 if (result < 0) 810 return; 811 812 sparse_keymap_report_event(msi_laptop_input_dev, 813 (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ? 814 KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true); 815 } 816 static DECLARE_DELAYED_WORK(msi_touchpad_dwork, msi_send_touchpad_key); 817 static DECLARE_WORK(msi_touchpad_work, msi_send_touchpad_key); 818 819 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str, 820 struct serio *port) 821 { 822 static bool extended; 823 824 if (str & I8042_STR_AUXDATA) 825 return false; 826 827 /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/ 828 if (unlikely(data == 0xe0)) { 829 extended = true; 830 return false; 831 } else if (unlikely(extended)) { 832 extended = false; 833 switch (data) { 834 case 0xE4: 835 if (quirks->ec_delay) { 836 schedule_delayed_work(&msi_touchpad_dwork, 837 round_jiffies_relative(0.5 * HZ)); 838 } else 839 schedule_work(&msi_touchpad_work); 840 break; 841 case 0x54: 842 case 0x62: 843 case 0x76: 844 if (quirks->ec_delay) { 845 schedule_delayed_work(&msi_rfkill_dwork, 846 round_jiffies_relative(0.5 * HZ)); 847 } else 848 schedule_work(&msi_rfkill_work); 849 break; 850 } 851 } 852 853 return false; 854 } 855 856 static void msi_init_rfkill(struct work_struct *ignored) 857 { 858 if (rfk_wlan) { 859 rfkill_set_sw_state(rfk_wlan, !wlan_s); 860 rfkill_wlan_set(NULL, !wlan_s); 861 } 862 if (rfk_bluetooth) { 863 rfkill_set_sw_state(rfk_bluetooth, !bluetooth_s); 864 rfkill_bluetooth_set(NULL, !bluetooth_s); 865 } 866 if (rfk_threeg) { 867 rfkill_set_sw_state(rfk_threeg, !threeg_s); 868 rfkill_threeg_set(NULL, !threeg_s); 869 } 870 } 871 static DECLARE_DELAYED_WORK(msi_rfkill_init, msi_init_rfkill); 872 873 static int rfkill_init(struct platform_device *sdev) 874 { 875 /* add rfkill */ 876 int retval; 877 878 /* keep the hardware wireless state */ 879 get_wireless_state_ec_standard(); 880 881 rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev, 882 RFKILL_TYPE_BLUETOOTH, 883 &rfkill_bluetooth_ops, NULL); 884 if (!rfk_bluetooth) { 885 retval = -ENOMEM; 886 goto err_bluetooth; 887 } 888 retval = rfkill_register(rfk_bluetooth); 889 if (retval) 890 goto err_bluetooth; 891 892 rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN, 893 &rfkill_wlan_ops, NULL); 894 if (!rfk_wlan) { 895 retval = -ENOMEM; 896 goto err_wlan; 897 } 898 retval = rfkill_register(rfk_wlan); 899 if (retval) 900 goto err_wlan; 901 902 if (threeg_exists) { 903 rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev, 904 RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL); 905 if (!rfk_threeg) { 906 retval = -ENOMEM; 907 goto err_threeg; 908 } 909 retval = rfkill_register(rfk_threeg); 910 if (retval) 911 goto err_threeg; 912 } 913 914 /* schedule to run rfkill state initial */ 915 if (quirks->ec_delay) { 916 schedule_delayed_work(&msi_rfkill_init, 917 round_jiffies_relative(1 * HZ)); 918 } else 919 schedule_work(&msi_rfkill_work); 920 921 return 0; 922 923 err_threeg: 924 rfkill_destroy(rfk_threeg); 925 if (rfk_wlan) 926 rfkill_unregister(rfk_wlan); 927 err_wlan: 928 rfkill_destroy(rfk_wlan); 929 if (rfk_bluetooth) 930 rfkill_unregister(rfk_bluetooth); 931 err_bluetooth: 932 rfkill_destroy(rfk_bluetooth); 933 934 return retval; 935 } 936 937 #ifdef CONFIG_PM_SLEEP 938 static int msi_laptop_resume(struct device *device) 939 { 940 u8 data; 941 int result; 942 943 if (!quirks->load_scm_model) 944 return 0; 945 946 /* set load SCM to disable hardware control by fn key */ 947 result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data); 948 if (result < 0) 949 return result; 950 951 result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, 952 data | MSI_STANDARD_EC_SCM_LOAD_MASK); 953 if (result < 0) 954 return result; 955 956 return 0; 957 } 958 #endif 959 960 static int __init msi_laptop_input_setup(void) 961 { 962 int err; 963 964 msi_laptop_input_dev = input_allocate_device(); 965 if (!msi_laptop_input_dev) 966 return -ENOMEM; 967 968 msi_laptop_input_dev->name = "MSI Laptop hotkeys"; 969 msi_laptop_input_dev->phys = "msi-laptop/input0"; 970 msi_laptop_input_dev->id.bustype = BUS_HOST; 971 972 err = sparse_keymap_setup(msi_laptop_input_dev, 973 msi_laptop_keymap, NULL); 974 if (err) 975 goto err_free_dev; 976 977 err = input_register_device(msi_laptop_input_dev); 978 if (err) 979 goto err_free_keymap; 980 981 return 0; 982 983 err_free_keymap: 984 sparse_keymap_free(msi_laptop_input_dev); 985 err_free_dev: 986 input_free_device(msi_laptop_input_dev); 987 return err; 988 } 989 990 static void msi_laptop_input_destroy(void) 991 { 992 sparse_keymap_free(msi_laptop_input_dev); 993 input_unregister_device(msi_laptop_input_dev); 994 } 995 996 static int __init load_scm_model_init(struct platform_device *sdev) 997 { 998 u8 data; 999 int result; 1000 1001 if (!quirks->ec_read_only) { 1002 /* allow userland write sysfs file */ 1003 dev_attr_bluetooth.store = store_bluetooth; 1004 dev_attr_wlan.store = store_wlan; 1005 dev_attr_threeg.store = store_threeg; 1006 dev_attr_bluetooth.attr.mode |= S_IWUSR; 1007 dev_attr_wlan.attr.mode |= S_IWUSR; 1008 dev_attr_threeg.attr.mode |= S_IWUSR; 1009 } 1010 1011 /* disable hardware control by fn key */ 1012 result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data); 1013 if (result < 0) 1014 return result; 1015 1016 result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, 1017 data | MSI_STANDARD_EC_SCM_LOAD_MASK); 1018 if (result < 0) 1019 return result; 1020 1021 /* initial rfkill */ 1022 result = rfkill_init(sdev); 1023 if (result < 0) 1024 goto fail_rfkill; 1025 1026 /* setup input device */ 1027 result = msi_laptop_input_setup(); 1028 if (result) 1029 goto fail_input; 1030 1031 result = i8042_install_filter(msi_laptop_i8042_filter); 1032 if (result) { 1033 pr_err("Unable to install key filter\n"); 1034 goto fail_filter; 1035 } 1036 1037 return 0; 1038 1039 fail_filter: 1040 msi_laptop_input_destroy(); 1041 1042 fail_input: 1043 rfkill_cleanup(); 1044 1045 fail_rfkill: 1046 1047 return result; 1048 1049 } 1050 1051 static int __init msi_init(void) 1052 { 1053 int ret; 1054 1055 if (acpi_disabled) 1056 return -ENODEV; 1057 1058 dmi_check_system(msi_dmi_table); 1059 if (!quirks) 1060 /* quirks may be NULL if no match in DMI table */ 1061 quirks = &quirk_load_scm_model; 1062 if (force) 1063 quirks = &quirk_old_ec_model; 1064 1065 if (!quirks->old_ec_model) 1066 get_threeg_exists(); 1067 1068 if (auto_brightness < 0 || auto_brightness > 2) 1069 return -EINVAL; 1070 1071 /* Register backlight stuff */ 1072 1073 if (quirks->old_ec_model || 1074 acpi_video_get_backlight_type() == acpi_backlight_vendor) { 1075 struct backlight_properties props; 1076 memset(&props, 0, sizeof(struct backlight_properties)); 1077 props.type = BACKLIGHT_PLATFORM; 1078 props.max_brightness = MSI_LCD_LEVEL_MAX - 1; 1079 msibl_device = backlight_device_register("msi-laptop-bl", NULL, 1080 NULL, &msibl_ops, 1081 &props); 1082 if (IS_ERR(msibl_device)) 1083 return PTR_ERR(msibl_device); 1084 } 1085 1086 ret = platform_driver_register(&msipf_driver); 1087 if (ret) 1088 goto fail_backlight; 1089 1090 /* Register platform stuff */ 1091 1092 msipf_device = platform_device_alloc("msi-laptop-pf", -1); 1093 if (!msipf_device) { 1094 ret = -ENOMEM; 1095 goto fail_platform_driver; 1096 } 1097 1098 ret = platform_device_add(msipf_device); 1099 if (ret) 1100 goto fail_device_add; 1101 1102 if (quirks->load_scm_model && (load_scm_model_init(msipf_device) < 0)) { 1103 ret = -EINVAL; 1104 goto fail_scm_model_init; 1105 } 1106 1107 ret = sysfs_create_group(&msipf_device->dev.kobj, 1108 &msipf_attribute_group); 1109 if (ret) 1110 goto fail_create_group; 1111 1112 if (!quirks->old_ec_model) { 1113 if (threeg_exists) 1114 ret = device_create_file(&msipf_device->dev, 1115 &dev_attr_threeg); 1116 if (ret) 1117 goto fail_create_attr; 1118 } else { 1119 ret = sysfs_create_group(&msipf_device->dev.kobj, 1120 &msipf_old_attribute_group); 1121 if (ret) 1122 goto fail_create_attr; 1123 1124 /* Disable automatic brightness control by default because 1125 * this module was probably loaded to do brightness control in 1126 * software. */ 1127 1128 if (auto_brightness != 2) 1129 set_auto_brightness(auto_brightness); 1130 } 1131 1132 pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n"); 1133 1134 return 0; 1135 1136 fail_create_attr: 1137 sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group); 1138 fail_create_group: 1139 if (quirks->load_scm_model) { 1140 i8042_remove_filter(msi_laptop_i8042_filter); 1141 cancel_delayed_work_sync(&msi_rfkill_dwork); 1142 cancel_work_sync(&msi_rfkill_work); 1143 rfkill_cleanup(); 1144 } 1145 fail_scm_model_init: 1146 platform_device_del(msipf_device); 1147 fail_device_add: 1148 platform_device_put(msipf_device); 1149 fail_platform_driver: 1150 platform_driver_unregister(&msipf_driver); 1151 fail_backlight: 1152 backlight_device_unregister(msibl_device); 1153 1154 return ret; 1155 } 1156 1157 static void __exit msi_cleanup(void) 1158 { 1159 if (quirks->load_scm_model) { 1160 i8042_remove_filter(msi_laptop_i8042_filter); 1161 msi_laptop_input_destroy(); 1162 cancel_delayed_work_sync(&msi_rfkill_dwork); 1163 cancel_work_sync(&msi_rfkill_work); 1164 rfkill_cleanup(); 1165 } 1166 1167 sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group); 1168 if (!quirks->old_ec_model && threeg_exists) 1169 device_remove_file(&msipf_device->dev, &dev_attr_threeg); 1170 platform_device_unregister(msipf_device); 1171 platform_driver_unregister(&msipf_driver); 1172 backlight_device_unregister(msibl_device); 1173 1174 if (quirks->old_ec_model) { 1175 /* Enable automatic brightness control again */ 1176 if (auto_brightness != 2) 1177 set_auto_brightness(1); 1178 } 1179 1180 pr_info("driver unloaded\n"); 1181 } 1182 1183 module_init(msi_init); 1184 module_exit(msi_cleanup); 1185 1186 MODULE_AUTHOR("Lennart Poettering"); 1187 MODULE_DESCRIPTION("MSI Laptop Support"); 1188 MODULE_VERSION(MSI_DRIVER_VERSION); 1189 MODULE_LICENSE("GPL"); 1190 1191 MODULE_ALIAS("dmi:*:svnMICRO-STARINT'LCO.,LTD:pnMS-1013:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1192 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1058:pvr0581:rvnMSI:rnMS-1058:*:ct10:*"); 1193 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1412:*:rvnMSI:rnMS-1412:*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1194 MODULE_ALIAS("dmi:*:svnNOTEBOOK:pnSAM2000:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1195 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N034:*"); 1196 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N051:*"); 1197 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N014:*"); 1198 MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnCR620:*"); 1199 MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnU270series:*"); 1200 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnU90/U100:*"); 1201