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 68 #define MSI_DRIVER_VERSION "0.5" 69 70 #define MSI_LCD_LEVEL_MAX 9 71 72 #define MSI_EC_COMMAND_WIRELESS 0x10 73 #define MSI_EC_COMMAND_LCD_LEVEL 0x11 74 75 #define MSI_STANDARD_EC_COMMAND_ADDRESS 0x2e 76 #define MSI_STANDARD_EC_BLUETOOTH_MASK (1 << 0) 77 #define MSI_STANDARD_EC_WEBCAM_MASK (1 << 1) 78 #define MSI_STANDARD_EC_WLAN_MASK (1 << 3) 79 #define MSI_STANDARD_EC_3G_MASK (1 << 4) 80 81 /* For set SCM load flag to disable BIOS fn key */ 82 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS 0x2d 83 #define MSI_STANDARD_EC_SCM_LOAD_MASK (1 << 0) 84 85 #define MSI_STANDARD_EC_FUNCTIONS_ADDRESS 0xe4 86 /* Power LED is orange - Turbo mode */ 87 #define MSI_STANDARD_EC_TURBO_MASK (1 << 1) 88 /* Power LED is green - ECO mode */ 89 #define MSI_STANDARD_EC_ECO_MASK (1 << 3) 90 /* Touchpad is turned on */ 91 #define MSI_STANDARD_EC_TOUCHPAD_MASK (1 << 4) 92 /* If this bit != bit 1, turbo mode can't be toggled */ 93 #define MSI_STANDARD_EC_TURBO_COOLDOWN_MASK (1 << 7) 94 95 #define MSI_STANDARD_EC_FAN_ADDRESS 0x33 96 /* If zero, fan rotates at maximal speed */ 97 #define MSI_STANDARD_EC_AUTOFAN_MASK (1 << 0) 98 99 #ifdef CONFIG_PM_SLEEP 100 static int msi_laptop_resume(struct device *device); 101 #endif 102 static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume); 103 104 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS 0x2f 105 106 static bool force; 107 module_param(force, bool, 0); 108 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); 109 110 static int auto_brightness; 111 module_param(auto_brightness, int, 0); 112 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)"); 113 114 static const struct key_entry msi_laptop_keymap[] = { 115 {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} }, /* Touch Pad On */ 116 {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */ 117 {KE_END, 0} 118 }; 119 120 static struct input_dev *msi_laptop_input_dev; 121 122 static int wlan_s, bluetooth_s, threeg_s; 123 static int threeg_exists; 124 static struct rfkill *rfk_wlan, *rfk_bluetooth, *rfk_threeg; 125 126 /* MSI laptop quirks */ 127 struct quirk_entry { 128 bool old_ec_model; 129 130 /* Some MSI 3G netbook only have one fn key to control 131 * Wlan/Bluetooth/3G, those netbook will load the SCM (windows app) to 132 * disable the original Wlan/Bluetooth control by BIOS when user press 133 * fn key, then control Wlan/Bluetooth/3G by SCM (software control by 134 * OS). Without SCM, user cann't on/off 3G module on those 3G netbook. 135 * On Linux, msi-laptop driver will do the same thing to disable the 136 * original BIOS control, then might need use HAL or other userland 137 * application to do the software control that simulate with SCM. 138 * e.g. MSI N034 netbook 139 */ 140 bool load_scm_model; 141 142 /* Some MSI laptops need delay before reading from EC */ 143 bool ec_delay; 144 145 /* Some MSI Wind netbooks (e.g. MSI Wind U100) need loading SCM to get 146 * some features working (e.g. ECO mode), but we cannot change 147 * Wlan/Bluetooth state in software and we can only read its state. 148 */ 149 bool ec_read_only; 150 }; 151 152 static struct quirk_entry *quirks; 153 154 /* Hardware access */ 155 156 static int set_lcd_level(int level) 157 { 158 u8 buf[2]; 159 160 if (level < 0 || level >= MSI_LCD_LEVEL_MAX) 161 return -EINVAL; 162 163 buf[0] = 0x80; 164 buf[1] = (u8) (level*31); 165 166 return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf), 167 NULL, 0); 168 } 169 170 static int get_lcd_level(void) 171 { 172 u8 wdata = 0, rdata; 173 int result; 174 175 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1, 176 &rdata, 1); 177 if (result < 0) 178 return result; 179 180 return (int) rdata / 31; 181 } 182 183 static int get_auto_brightness(void) 184 { 185 u8 wdata = 4, rdata; 186 int result; 187 188 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1, 189 &rdata, 1); 190 if (result < 0) 191 return result; 192 193 return !!(rdata & 8); 194 } 195 196 static int set_auto_brightness(int enable) 197 { 198 u8 wdata[2], rdata; 199 int result; 200 201 wdata[0] = 4; 202 203 result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1, 204 &rdata, 1); 205 if (result < 0) 206 return result; 207 208 wdata[0] = 0x84; 209 wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0); 210 211 return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2, 212 NULL, 0); 213 } 214 215 static ssize_t set_device_state(const char *buf, size_t count, u8 mask) 216 { 217 int status; 218 u8 wdata = 0, rdata; 219 int result; 220 221 if (sscanf(buf, "%i", &status) != 1 || (status < 0 || status > 1)) 222 return -EINVAL; 223 224 if (quirks->ec_read_only) 225 return -EOPNOTSUPP; 226 227 /* read current device state */ 228 result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata); 229 if (result < 0) 230 return result; 231 232 if (!!(rdata & mask) != status) { 233 /* reverse device bit */ 234 if (rdata & mask) 235 wdata = rdata & ~mask; 236 else 237 wdata = rdata | mask; 238 239 result = ec_write(MSI_STANDARD_EC_COMMAND_ADDRESS, wdata); 240 if (result < 0) 241 return result; 242 } 243 244 return count; 245 } 246 247 static int get_wireless_state(int *wlan, int *bluetooth) 248 { 249 u8 wdata = 0, rdata; 250 int result; 251 252 result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1); 253 if (result < 0) 254 return result; 255 256 if (wlan) 257 *wlan = !!(rdata & 8); 258 259 if (bluetooth) 260 *bluetooth = !!(rdata & 128); 261 262 return 0; 263 } 264 265 static int get_wireless_state_ec_standard(void) 266 { 267 u8 rdata; 268 int result; 269 270 result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata); 271 if (result < 0) 272 return result; 273 274 wlan_s = !!(rdata & MSI_STANDARD_EC_WLAN_MASK); 275 276 bluetooth_s = !!(rdata & MSI_STANDARD_EC_BLUETOOTH_MASK); 277 278 threeg_s = !!(rdata & MSI_STANDARD_EC_3G_MASK); 279 280 return 0; 281 } 282 283 static int get_threeg_exists(void) 284 { 285 u8 rdata; 286 int result; 287 288 result = ec_read(MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS, &rdata); 289 if (result < 0) 290 return result; 291 292 threeg_exists = !!(rdata & MSI_STANDARD_EC_3G_MASK); 293 294 return 0; 295 } 296 297 /* Backlight device stuff */ 298 299 static int bl_get_brightness(struct backlight_device *b) 300 { 301 return get_lcd_level(); 302 } 303 304 305 static int bl_update_status(struct backlight_device *b) 306 { 307 return set_lcd_level(b->props.brightness); 308 } 309 310 static const struct backlight_ops msibl_ops = { 311 .get_brightness = bl_get_brightness, 312 .update_status = bl_update_status, 313 }; 314 315 static struct backlight_device *msibl_device; 316 317 /* Platform device */ 318 319 static ssize_t show_wlan(struct device *dev, 320 struct device_attribute *attr, char *buf) 321 { 322 323 int ret, enabled = 0; 324 325 if (quirks->old_ec_model) { 326 ret = get_wireless_state(&enabled, NULL); 327 } else { 328 ret = get_wireless_state_ec_standard(); 329 enabled = wlan_s; 330 } 331 if (ret < 0) 332 return ret; 333 334 return sprintf(buf, "%i\n", enabled); 335 } 336 337 static ssize_t store_wlan(struct device *dev, 338 struct device_attribute *attr, const char *buf, size_t count) 339 { 340 return set_device_state(buf, count, MSI_STANDARD_EC_WLAN_MASK); 341 } 342 343 static ssize_t show_bluetooth(struct device *dev, 344 struct device_attribute *attr, char *buf) 345 { 346 347 int ret, enabled = 0; 348 349 if (quirks->old_ec_model) { 350 ret = get_wireless_state(NULL, &enabled); 351 } else { 352 ret = get_wireless_state_ec_standard(); 353 enabled = bluetooth_s; 354 } 355 if (ret < 0) 356 return ret; 357 358 return sprintf(buf, "%i\n", enabled); 359 } 360 361 static ssize_t store_bluetooth(struct device *dev, 362 struct device_attribute *attr, const char *buf, size_t count) 363 { 364 return set_device_state(buf, count, MSI_STANDARD_EC_BLUETOOTH_MASK); 365 } 366 367 static ssize_t show_threeg(struct device *dev, 368 struct device_attribute *attr, char *buf) 369 { 370 371 int ret; 372 373 /* old msi ec not support 3G */ 374 if (quirks->old_ec_model) 375 return -ENODEV; 376 377 ret = get_wireless_state_ec_standard(); 378 if (ret < 0) 379 return ret; 380 381 return sprintf(buf, "%i\n", threeg_s); 382 } 383 384 static ssize_t store_threeg(struct device *dev, 385 struct device_attribute *attr, const char *buf, size_t count) 386 { 387 return set_device_state(buf, count, MSI_STANDARD_EC_3G_MASK); 388 } 389 390 static ssize_t show_lcd_level(struct device *dev, 391 struct device_attribute *attr, char *buf) 392 { 393 394 int ret; 395 396 ret = get_lcd_level(); 397 if (ret < 0) 398 return ret; 399 400 return sprintf(buf, "%i\n", ret); 401 } 402 403 static ssize_t store_lcd_level(struct device *dev, 404 struct device_attribute *attr, const char *buf, size_t count) 405 { 406 407 int level, ret; 408 409 if (sscanf(buf, "%i", &level) != 1 || 410 (level < 0 || level >= MSI_LCD_LEVEL_MAX)) 411 return -EINVAL; 412 413 ret = set_lcd_level(level); 414 if (ret < 0) 415 return ret; 416 417 return count; 418 } 419 420 static ssize_t show_auto_brightness(struct device *dev, 421 struct device_attribute *attr, char *buf) 422 { 423 424 int ret; 425 426 ret = get_auto_brightness(); 427 if (ret < 0) 428 return ret; 429 430 return sprintf(buf, "%i\n", ret); 431 } 432 433 static ssize_t store_auto_brightness(struct device *dev, 434 struct device_attribute *attr, const char *buf, size_t count) 435 { 436 437 int enable, ret; 438 439 if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1))) 440 return -EINVAL; 441 442 ret = set_auto_brightness(enable); 443 if (ret < 0) 444 return ret; 445 446 return count; 447 } 448 449 static ssize_t show_touchpad(struct device *dev, 450 struct device_attribute *attr, char *buf) 451 { 452 453 u8 rdata; 454 int result; 455 456 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 457 if (result < 0) 458 return result; 459 460 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TOUCHPAD_MASK)); 461 } 462 463 static ssize_t show_turbo(struct device *dev, 464 struct device_attribute *attr, char *buf) 465 { 466 467 u8 rdata; 468 int result; 469 470 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 471 if (result < 0) 472 return result; 473 474 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_TURBO_MASK)); 475 } 476 477 static ssize_t show_eco(struct device *dev, 478 struct device_attribute *attr, char *buf) 479 { 480 481 u8 rdata; 482 int result; 483 484 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 485 if (result < 0) 486 return result; 487 488 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_ECO_MASK)); 489 } 490 491 static ssize_t show_turbo_cooldown(struct device *dev, 492 struct device_attribute *attr, char *buf) 493 { 494 495 u8 rdata; 496 int result; 497 498 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 499 if (result < 0) 500 return result; 501 502 return sprintf(buf, "%i\n", (!!(rdata & MSI_STANDARD_EC_TURBO_MASK)) | 503 (!!(rdata & MSI_STANDARD_EC_TURBO_COOLDOWN_MASK) << 1)); 504 } 505 506 static ssize_t show_auto_fan(struct device *dev, 507 struct device_attribute *attr, char *buf) 508 { 509 510 u8 rdata; 511 int result; 512 513 result = ec_read(MSI_STANDARD_EC_FAN_ADDRESS, &rdata); 514 if (result < 0) 515 return result; 516 517 return sprintf(buf, "%i\n", !!(rdata & MSI_STANDARD_EC_AUTOFAN_MASK)); 518 } 519 520 static ssize_t store_auto_fan(struct device *dev, 521 struct device_attribute *attr, const char *buf, size_t count) 522 { 523 524 int enable, result; 525 526 if (sscanf(buf, "%i", &enable) != 1 || (enable != (enable & 1))) 527 return -EINVAL; 528 529 result = ec_write(MSI_STANDARD_EC_FAN_ADDRESS, enable); 530 if (result < 0) 531 return result; 532 533 return count; 534 } 535 536 static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level); 537 static DEVICE_ATTR(auto_brightness, 0644, show_auto_brightness, 538 store_auto_brightness); 539 static DEVICE_ATTR(bluetooth, 0444, show_bluetooth, NULL); 540 static DEVICE_ATTR(wlan, 0444, show_wlan, NULL); 541 static DEVICE_ATTR(threeg, 0444, show_threeg, NULL); 542 static DEVICE_ATTR(touchpad, 0444, show_touchpad, NULL); 543 static DEVICE_ATTR(turbo_mode, 0444, show_turbo, NULL); 544 static DEVICE_ATTR(eco_mode, 0444, show_eco, NULL); 545 static DEVICE_ATTR(turbo_cooldown, 0444, show_turbo_cooldown, NULL); 546 static DEVICE_ATTR(auto_fan, 0644, show_auto_fan, store_auto_fan); 547 548 static struct attribute *msipf_attributes[] = { 549 &dev_attr_bluetooth.attr, 550 &dev_attr_wlan.attr, 551 &dev_attr_touchpad.attr, 552 &dev_attr_turbo_mode.attr, 553 &dev_attr_eco_mode.attr, 554 &dev_attr_turbo_cooldown.attr, 555 &dev_attr_auto_fan.attr, 556 NULL 557 }; 558 559 static struct attribute *msipf_old_attributes[] = { 560 &dev_attr_lcd_level.attr, 561 &dev_attr_auto_brightness.attr, 562 NULL 563 }; 564 565 static struct attribute_group msipf_attribute_group = { 566 .attrs = msipf_attributes 567 }; 568 569 static struct attribute_group msipf_old_attribute_group = { 570 .attrs = msipf_old_attributes 571 }; 572 573 static struct platform_driver msipf_driver = { 574 .driver = { 575 .name = "msi-laptop-pf", 576 .pm = &msi_laptop_pm, 577 }, 578 }; 579 580 static struct platform_device *msipf_device; 581 582 /* Initialization */ 583 584 static struct quirk_entry quirk_old_ec_model = { 585 .old_ec_model = true, 586 }; 587 588 static struct quirk_entry quirk_load_scm_model = { 589 .load_scm_model = true, 590 .ec_delay = true, 591 }; 592 593 static struct quirk_entry quirk_load_scm_ro_model = { 594 .load_scm_model = true, 595 .ec_read_only = true, 596 }; 597 598 static int dmi_check_cb(const struct dmi_system_id *dmi) 599 { 600 pr_info("Identified laptop model '%s'\n", dmi->ident); 601 602 quirks = dmi->driver_data; 603 604 return 1; 605 } 606 607 static struct dmi_system_id __initdata msi_dmi_table[] = { 608 { 609 .ident = "MSI S270", 610 .matches = { 611 DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT'L CO.,LTD"), 612 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1013"), 613 DMI_MATCH(DMI_PRODUCT_VERSION, "0131"), 614 DMI_MATCH(DMI_CHASSIS_VENDOR, 615 "MICRO-STAR INT'L CO.,LTD") 616 }, 617 .driver_data = &quirk_old_ec_model, 618 .callback = dmi_check_cb 619 }, 620 { 621 .ident = "MSI S271", 622 .matches = { 623 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), 624 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1058"), 625 DMI_MATCH(DMI_PRODUCT_VERSION, "0581"), 626 DMI_MATCH(DMI_BOARD_NAME, "MS-1058") 627 }, 628 .driver_data = &quirk_old_ec_model, 629 .callback = dmi_check_cb 630 }, 631 { 632 .ident = "MSI S420", 633 .matches = { 634 DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"), 635 DMI_MATCH(DMI_PRODUCT_NAME, "MS-1412"), 636 DMI_MATCH(DMI_BOARD_VENDOR, "MSI"), 637 DMI_MATCH(DMI_BOARD_NAME, "MS-1412") 638 }, 639 .driver_data = &quirk_old_ec_model, 640 .callback = dmi_check_cb 641 }, 642 { 643 .ident = "Medion MD96100", 644 .matches = { 645 DMI_MATCH(DMI_SYS_VENDOR, "NOTEBOOK"), 646 DMI_MATCH(DMI_PRODUCT_NAME, "SAM2000"), 647 DMI_MATCH(DMI_PRODUCT_VERSION, "0131"), 648 DMI_MATCH(DMI_CHASSIS_VENDOR, 649 "MICRO-STAR INT'L CO.,LTD") 650 }, 651 .driver_data = &quirk_old_ec_model, 652 .callback = dmi_check_cb 653 }, 654 { 655 .ident = "MSI N034", 656 .matches = { 657 DMI_MATCH(DMI_SYS_VENDOR, 658 "MICRO-STAR INTERNATIONAL CO., LTD"), 659 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N034"), 660 DMI_MATCH(DMI_CHASSIS_VENDOR, 661 "MICRO-STAR INTERNATIONAL CO., LTD") 662 }, 663 .driver_data = &quirk_load_scm_model, 664 .callback = dmi_check_cb 665 }, 666 { 667 .ident = "MSI N051", 668 .matches = { 669 DMI_MATCH(DMI_SYS_VENDOR, 670 "MICRO-STAR INTERNATIONAL CO., LTD"), 671 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N051"), 672 DMI_MATCH(DMI_CHASSIS_VENDOR, 673 "MICRO-STAR INTERNATIONAL CO., LTD") 674 }, 675 .driver_data = &quirk_load_scm_model, 676 .callback = dmi_check_cb 677 }, 678 { 679 .ident = "MSI N014", 680 .matches = { 681 DMI_MATCH(DMI_SYS_VENDOR, 682 "MICRO-STAR INTERNATIONAL CO., LTD"), 683 DMI_MATCH(DMI_PRODUCT_NAME, "MS-N014"), 684 }, 685 .driver_data = &quirk_load_scm_model, 686 .callback = dmi_check_cb 687 }, 688 { 689 .ident = "MSI CR620", 690 .matches = { 691 DMI_MATCH(DMI_SYS_VENDOR, 692 "Micro-Star International"), 693 DMI_MATCH(DMI_PRODUCT_NAME, "CR620"), 694 }, 695 .driver_data = &quirk_load_scm_model, 696 .callback = dmi_check_cb 697 }, 698 { 699 .ident = "MSI U270", 700 .matches = { 701 DMI_MATCH(DMI_SYS_VENDOR, 702 "Micro-Star International Co., Ltd."), 703 DMI_MATCH(DMI_PRODUCT_NAME, "U270 series"), 704 }, 705 .driver_data = &quirk_load_scm_model, 706 .callback = dmi_check_cb 707 }, 708 { 709 .ident = "MSI U90/U100", 710 .matches = { 711 DMI_MATCH(DMI_SYS_VENDOR, 712 "MICRO-STAR INTERNATIONAL CO., LTD"), 713 DMI_MATCH(DMI_PRODUCT_NAME, "U90/U100"), 714 }, 715 .driver_data = &quirk_load_scm_ro_model, 716 .callback = dmi_check_cb 717 }, 718 { } 719 }; 720 721 static int rfkill_bluetooth_set(void *data, bool blocked) 722 { 723 /* Do something with blocked...*/ 724 /* 725 * blocked == false is on 726 * blocked == true is off 727 */ 728 int result = set_device_state(blocked ? "0" : "1", 0, 729 MSI_STANDARD_EC_BLUETOOTH_MASK); 730 731 return min(result, 0); 732 } 733 734 static int rfkill_wlan_set(void *data, bool blocked) 735 { 736 int result = set_device_state(blocked ? "0" : "1", 0, 737 MSI_STANDARD_EC_WLAN_MASK); 738 739 return min(result, 0); 740 } 741 742 static int rfkill_threeg_set(void *data, bool blocked) 743 { 744 int result = set_device_state(blocked ? "0" : "1", 0, 745 MSI_STANDARD_EC_3G_MASK); 746 747 return min(result, 0); 748 } 749 750 static const struct rfkill_ops rfkill_bluetooth_ops = { 751 .set_block = rfkill_bluetooth_set 752 }; 753 754 static const struct rfkill_ops rfkill_wlan_ops = { 755 .set_block = rfkill_wlan_set 756 }; 757 758 static const struct rfkill_ops rfkill_threeg_ops = { 759 .set_block = rfkill_threeg_set 760 }; 761 762 static void rfkill_cleanup(void) 763 { 764 if (rfk_bluetooth) { 765 rfkill_unregister(rfk_bluetooth); 766 rfkill_destroy(rfk_bluetooth); 767 } 768 769 if (rfk_threeg) { 770 rfkill_unregister(rfk_threeg); 771 rfkill_destroy(rfk_threeg); 772 } 773 774 if (rfk_wlan) { 775 rfkill_unregister(rfk_wlan); 776 rfkill_destroy(rfk_wlan); 777 } 778 } 779 780 static bool msi_rfkill_set_state(struct rfkill *rfkill, bool blocked) 781 { 782 if (quirks->ec_read_only) 783 return rfkill_set_hw_state(rfkill, blocked); 784 else 785 return rfkill_set_sw_state(rfkill, blocked); 786 } 787 788 static void msi_update_rfkill(struct work_struct *ignored) 789 { 790 get_wireless_state_ec_standard(); 791 792 if (rfk_wlan) 793 msi_rfkill_set_state(rfk_wlan, !wlan_s); 794 if (rfk_bluetooth) 795 msi_rfkill_set_state(rfk_bluetooth, !bluetooth_s); 796 if (rfk_threeg) 797 msi_rfkill_set_state(rfk_threeg, !threeg_s); 798 } 799 static DECLARE_DELAYED_WORK(msi_rfkill_dwork, msi_update_rfkill); 800 static DECLARE_WORK(msi_rfkill_work, msi_update_rfkill); 801 802 static void msi_send_touchpad_key(struct work_struct *ignored) 803 { 804 u8 rdata; 805 int result; 806 807 result = ec_read(MSI_STANDARD_EC_FUNCTIONS_ADDRESS, &rdata); 808 if (result < 0) 809 return; 810 811 sparse_keymap_report_event(msi_laptop_input_dev, 812 (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ? 813 KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true); 814 } 815 static DECLARE_DELAYED_WORK(msi_touchpad_dwork, msi_send_touchpad_key); 816 static DECLARE_WORK(msi_touchpad_work, msi_send_touchpad_key); 817 818 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str, 819 struct serio *port) 820 { 821 static bool extended; 822 823 if (str & I8042_STR_AUXDATA) 824 return false; 825 826 /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/ 827 if (unlikely(data == 0xe0)) { 828 extended = true; 829 return false; 830 } else if (unlikely(extended)) { 831 extended = false; 832 switch (data) { 833 case 0xE4: 834 if (quirks->ec_delay) { 835 schedule_delayed_work(&msi_touchpad_dwork, 836 round_jiffies_relative(0.5 * HZ)); 837 } else 838 schedule_work(&msi_touchpad_work); 839 break; 840 case 0x54: 841 case 0x62: 842 case 0x76: 843 if (quirks->ec_delay) { 844 schedule_delayed_work(&msi_rfkill_dwork, 845 round_jiffies_relative(0.5 * HZ)); 846 } else 847 schedule_work(&msi_rfkill_work); 848 break; 849 } 850 } 851 852 return false; 853 } 854 855 static void msi_init_rfkill(struct work_struct *ignored) 856 { 857 if (rfk_wlan) { 858 rfkill_set_sw_state(rfk_wlan, !wlan_s); 859 rfkill_wlan_set(NULL, !wlan_s); 860 } 861 if (rfk_bluetooth) { 862 rfkill_set_sw_state(rfk_bluetooth, !bluetooth_s); 863 rfkill_bluetooth_set(NULL, !bluetooth_s); 864 } 865 if (rfk_threeg) { 866 rfkill_set_sw_state(rfk_threeg, !threeg_s); 867 rfkill_threeg_set(NULL, !threeg_s); 868 } 869 } 870 static DECLARE_DELAYED_WORK(msi_rfkill_init, msi_init_rfkill); 871 872 static int rfkill_init(struct platform_device *sdev) 873 { 874 /* add rfkill */ 875 int retval; 876 877 /* keep the hardware wireless state */ 878 get_wireless_state_ec_standard(); 879 880 rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev, 881 RFKILL_TYPE_BLUETOOTH, 882 &rfkill_bluetooth_ops, NULL); 883 if (!rfk_bluetooth) { 884 retval = -ENOMEM; 885 goto err_bluetooth; 886 } 887 retval = rfkill_register(rfk_bluetooth); 888 if (retval) 889 goto err_bluetooth; 890 891 rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN, 892 &rfkill_wlan_ops, NULL); 893 if (!rfk_wlan) { 894 retval = -ENOMEM; 895 goto err_wlan; 896 } 897 retval = rfkill_register(rfk_wlan); 898 if (retval) 899 goto err_wlan; 900 901 if (threeg_exists) { 902 rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev, 903 RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL); 904 if (!rfk_threeg) { 905 retval = -ENOMEM; 906 goto err_threeg; 907 } 908 retval = rfkill_register(rfk_threeg); 909 if (retval) 910 goto err_threeg; 911 } 912 913 /* schedule to run rfkill state initial */ 914 if (quirks->ec_delay) { 915 schedule_delayed_work(&msi_rfkill_init, 916 round_jiffies_relative(1 * HZ)); 917 } else 918 schedule_work(&msi_rfkill_work); 919 920 return 0; 921 922 err_threeg: 923 rfkill_destroy(rfk_threeg); 924 if (rfk_wlan) 925 rfkill_unregister(rfk_wlan); 926 err_wlan: 927 rfkill_destroy(rfk_wlan); 928 if (rfk_bluetooth) 929 rfkill_unregister(rfk_bluetooth); 930 err_bluetooth: 931 rfkill_destroy(rfk_bluetooth); 932 933 return retval; 934 } 935 936 #ifdef CONFIG_PM_SLEEP 937 static int msi_laptop_resume(struct device *device) 938 { 939 u8 data; 940 int result; 941 942 if (!quirks->load_scm_model) 943 return 0; 944 945 /* set load SCM to disable hardware control by fn key */ 946 result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data); 947 if (result < 0) 948 return result; 949 950 result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, 951 data | MSI_STANDARD_EC_SCM_LOAD_MASK); 952 if (result < 0) 953 return result; 954 955 return 0; 956 } 957 #endif 958 959 static int __init msi_laptop_input_setup(void) 960 { 961 int err; 962 963 msi_laptop_input_dev = input_allocate_device(); 964 if (!msi_laptop_input_dev) 965 return -ENOMEM; 966 967 msi_laptop_input_dev->name = "MSI Laptop hotkeys"; 968 msi_laptop_input_dev->phys = "msi-laptop/input0"; 969 msi_laptop_input_dev->id.bustype = BUS_HOST; 970 971 err = sparse_keymap_setup(msi_laptop_input_dev, 972 msi_laptop_keymap, NULL); 973 if (err) 974 goto err_free_dev; 975 976 err = input_register_device(msi_laptop_input_dev); 977 if (err) 978 goto err_free_keymap; 979 980 return 0; 981 982 err_free_keymap: 983 sparse_keymap_free(msi_laptop_input_dev); 984 err_free_dev: 985 input_free_device(msi_laptop_input_dev); 986 return err; 987 } 988 989 static void msi_laptop_input_destroy(void) 990 { 991 sparse_keymap_free(msi_laptop_input_dev); 992 input_unregister_device(msi_laptop_input_dev); 993 } 994 995 static int __init load_scm_model_init(struct platform_device *sdev) 996 { 997 u8 data; 998 int result; 999 1000 if (!quirks->ec_read_only) { 1001 /* allow userland write sysfs file */ 1002 dev_attr_bluetooth.store = store_bluetooth; 1003 dev_attr_wlan.store = store_wlan; 1004 dev_attr_threeg.store = store_threeg; 1005 dev_attr_bluetooth.attr.mode |= S_IWUSR; 1006 dev_attr_wlan.attr.mode |= S_IWUSR; 1007 dev_attr_threeg.attr.mode |= S_IWUSR; 1008 } 1009 1010 /* disable hardware control by fn key */ 1011 result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data); 1012 if (result < 0) 1013 return result; 1014 1015 result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, 1016 data | MSI_STANDARD_EC_SCM_LOAD_MASK); 1017 if (result < 0) 1018 return result; 1019 1020 /* initial rfkill */ 1021 result = rfkill_init(sdev); 1022 if (result < 0) 1023 goto fail_rfkill; 1024 1025 /* setup input device */ 1026 result = msi_laptop_input_setup(); 1027 if (result) 1028 goto fail_input; 1029 1030 result = i8042_install_filter(msi_laptop_i8042_filter); 1031 if (result) { 1032 pr_err("Unable to install key filter\n"); 1033 goto fail_filter; 1034 } 1035 1036 return 0; 1037 1038 fail_filter: 1039 msi_laptop_input_destroy(); 1040 1041 fail_input: 1042 rfkill_cleanup(); 1043 1044 fail_rfkill: 1045 1046 return result; 1047 1048 } 1049 1050 static int __init msi_init(void) 1051 { 1052 int ret; 1053 1054 if (acpi_disabled) 1055 return -ENODEV; 1056 1057 dmi_check_system(msi_dmi_table); 1058 if (!quirks) 1059 /* quirks may be NULL if no match in DMI table */ 1060 quirks = &quirk_load_scm_model; 1061 if (force) 1062 quirks = &quirk_old_ec_model; 1063 1064 if (!quirks->old_ec_model) 1065 get_threeg_exists(); 1066 1067 if (auto_brightness < 0 || auto_brightness > 2) 1068 return -EINVAL; 1069 1070 /* Register backlight stuff */ 1071 1072 if (!quirks->old_ec_model || acpi_video_backlight_support()) { 1073 pr_info("Brightness ignored, must be controlled by ACPI video driver\n"); 1074 } else { 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