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 .owner = THIS_MODULE, 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 & 0x20) 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 || acpi_video_backlight_support()) { 1074 pr_info("Brightness ignored, must be controlled by ACPI video driver\n"); 1075 } else { 1076 struct backlight_properties props; 1077 memset(&props, 0, sizeof(struct backlight_properties)); 1078 props.type = BACKLIGHT_PLATFORM; 1079 props.max_brightness = MSI_LCD_LEVEL_MAX - 1; 1080 msibl_device = backlight_device_register("msi-laptop-bl", NULL, 1081 NULL, &msibl_ops, 1082 &props); 1083 if (IS_ERR(msibl_device)) 1084 return PTR_ERR(msibl_device); 1085 } 1086 1087 ret = platform_driver_register(&msipf_driver); 1088 if (ret) 1089 goto fail_backlight; 1090 1091 /* Register platform stuff */ 1092 1093 msipf_device = platform_device_alloc("msi-laptop-pf", -1); 1094 if (!msipf_device) { 1095 ret = -ENOMEM; 1096 goto fail_platform_driver; 1097 } 1098 1099 ret = platform_device_add(msipf_device); 1100 if (ret) 1101 goto fail_device_add; 1102 1103 if (quirks->load_scm_model && (load_scm_model_init(msipf_device) < 0)) { 1104 ret = -EINVAL; 1105 goto fail_scm_model_init; 1106 } 1107 1108 ret = sysfs_create_group(&msipf_device->dev.kobj, 1109 &msipf_attribute_group); 1110 if (ret) 1111 goto fail_create_group; 1112 1113 if (!quirks->old_ec_model) { 1114 if (threeg_exists) 1115 ret = device_create_file(&msipf_device->dev, 1116 &dev_attr_threeg); 1117 if (ret) 1118 goto fail_create_attr; 1119 } else { 1120 ret = sysfs_create_group(&msipf_device->dev.kobj, 1121 &msipf_old_attribute_group); 1122 if (ret) 1123 goto fail_create_attr; 1124 1125 /* Disable automatic brightness control by default because 1126 * this module was probably loaded to do brightness control in 1127 * software. */ 1128 1129 if (auto_brightness != 2) 1130 set_auto_brightness(auto_brightness); 1131 } 1132 1133 pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n"); 1134 1135 return 0; 1136 1137 fail_create_attr: 1138 sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group); 1139 fail_create_group: 1140 if (quirks->load_scm_model) { 1141 i8042_remove_filter(msi_laptop_i8042_filter); 1142 cancel_delayed_work_sync(&msi_rfkill_dwork); 1143 cancel_work_sync(&msi_rfkill_work); 1144 rfkill_cleanup(); 1145 } 1146 fail_scm_model_init: 1147 platform_device_del(msipf_device); 1148 fail_device_add: 1149 platform_device_put(msipf_device); 1150 fail_platform_driver: 1151 platform_driver_unregister(&msipf_driver); 1152 fail_backlight: 1153 backlight_device_unregister(msibl_device); 1154 1155 return ret; 1156 } 1157 1158 static void __exit msi_cleanup(void) 1159 { 1160 if (quirks->load_scm_model) { 1161 i8042_remove_filter(msi_laptop_i8042_filter); 1162 msi_laptop_input_destroy(); 1163 cancel_delayed_work_sync(&msi_rfkill_dwork); 1164 cancel_work_sync(&msi_rfkill_work); 1165 rfkill_cleanup(); 1166 } 1167 1168 sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group); 1169 if (!quirks->old_ec_model && threeg_exists) 1170 device_remove_file(&msipf_device->dev, &dev_attr_threeg); 1171 platform_device_unregister(msipf_device); 1172 platform_driver_unregister(&msipf_driver); 1173 backlight_device_unregister(msibl_device); 1174 1175 if (quirks->old_ec_model) { 1176 /* Enable automatic brightness control again */ 1177 if (auto_brightness != 2) 1178 set_auto_brightness(1); 1179 } 1180 1181 pr_info("driver unloaded\n"); 1182 } 1183 1184 module_init(msi_init); 1185 module_exit(msi_cleanup); 1186 1187 MODULE_AUTHOR("Lennart Poettering"); 1188 MODULE_DESCRIPTION("MSI Laptop Support"); 1189 MODULE_VERSION(MSI_DRIVER_VERSION); 1190 MODULE_LICENSE("GPL"); 1191 1192 MODULE_ALIAS("dmi:*:svnMICRO-STARINT'LCO.,LTD:pnMS-1013:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1193 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1058:pvr0581:rvnMSI:rnMS-1058:*:ct10:*"); 1194 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1412:*:rvnMSI:rnMS-1412:*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1195 MODULE_ALIAS("dmi:*:svnNOTEBOOK:pnSAM2000:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1196 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N034:*"); 1197 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N051:*"); 1198 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N014:*"); 1199 MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnCR620:*"); 1200 MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnU270series:*"); 1201 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnU90/U100:*"); 1202