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 101static int msi_laptop_resume(struct device *device); 102#endif 103static SIMPLE_DEV_PM_OPS(msi_laptop_pm, NULL, msi_laptop_resume); 104 105#define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS 0x2f 106 107static bool force; 108module_param(force, bool, 0); 109MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); 110 111static int auto_brightness; 112module_param(auto_brightness, int, 0); 113MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)"); 114 115static 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 121static struct input_dev *msi_laptop_input_dev; 122 123static int wlan_s, bluetooth_s, threeg_s; 124static int threeg_exists; 125static struct rfkill *rfk_wlan, *rfk_bluetooth, *rfk_threeg; 126 127/* MSI laptop quirks */ 128struct 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 153static struct quirk_entry *quirks; 154 155/* Hardware access */ 156 157static 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 171static 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 184static 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 197static 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 216static 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 248static 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 266static 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 284static 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 300static int bl_get_brightness(struct backlight_device *b) 301{ 302 return get_lcd_level(); 303} 304 305 306static int bl_update_status(struct backlight_device *b) 307{ 308 return set_lcd_level(b->props.brightness); 309} 310 311static const struct backlight_ops msibl_ops = { 312 .get_brightness = bl_get_brightness, 313 .update_status = bl_update_status, 314}; 315 316static struct backlight_device *msibl_device; 317 318/* Platform device */ 319 320static 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 338static 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 344static 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 362static 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 368static 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 385static 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 391static 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 404static 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 421static 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 434static 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 450static 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 464static 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 478static 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 492static 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 507static 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 521static 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 537static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level); 538static DEVICE_ATTR(auto_brightness, 0644, show_auto_brightness, 539 store_auto_brightness); 540static DEVICE_ATTR(bluetooth, 0444, show_bluetooth, NULL); 541static DEVICE_ATTR(wlan, 0444, show_wlan, NULL); 542static DEVICE_ATTR(threeg, 0444, show_threeg, NULL); 543static DEVICE_ATTR(touchpad, 0444, show_touchpad, NULL); 544static DEVICE_ATTR(turbo_mode, 0444, show_turbo, NULL); 545static DEVICE_ATTR(eco_mode, 0444, show_eco, NULL); 546static DEVICE_ATTR(turbo_cooldown, 0444, show_turbo_cooldown, NULL); 547static DEVICE_ATTR(auto_fan, 0644, show_auto_fan, store_auto_fan); 548 549static 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 560static struct attribute *msipf_old_attributes[] = { 561 &dev_attr_lcd_level.attr, 562 &dev_attr_auto_brightness.attr, 563 NULL 564}; 565 566static struct attribute_group msipf_attribute_group = { 567 .attrs = msipf_attributes 568}; 569 570static struct attribute_group msipf_old_attribute_group = { 571 .attrs = msipf_old_attributes 572}; 573 574static struct platform_driver msipf_driver = { 575 .driver = { 576 .name = "msi-laptop-pf", 577 .pm = &msi_laptop_pm, 578 }, 579}; 580 581static struct platform_device *msipf_device; 582 583/* Initialization */ 584 585static struct quirk_entry quirk_old_ec_model = { 586 .old_ec_model = true, 587}; 588 589static struct quirk_entry quirk_load_scm_model = { 590 .load_scm_model = true, 591 .ec_delay = true, 592}; 593 594static struct quirk_entry quirk_load_scm_ro_model = { 595 .load_scm_model = true, 596 .ec_read_only = true, 597}; 598 599static 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 608static 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 722static 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 735static 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 743static 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 751static const struct rfkill_ops rfkill_bluetooth_ops = { 752 .set_block = rfkill_bluetooth_set 753}; 754 755static const struct rfkill_ops rfkill_wlan_ops = { 756 .set_block = rfkill_wlan_set 757}; 758 759static const struct rfkill_ops rfkill_threeg_ops = { 760 .set_block = rfkill_threeg_set 761}; 762 763static 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 781static 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 789static 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} 800static DECLARE_DELAYED_WORK(msi_rfkill_dwork, msi_update_rfkill); 801static DECLARE_WORK(msi_rfkill_work, msi_update_rfkill); 802 803static 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} 816static DECLARE_DELAYED_WORK(msi_touchpad_dwork, msi_send_touchpad_key); 817static DECLARE_WORK(msi_touchpad_work, msi_send_touchpad_key); 818 819static 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 856static 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} 871static DECLARE_DELAYED_WORK(msi_rfkill_init, msi_init_rfkill); 872 873static 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 923err_threeg: 924 rfkill_destroy(rfk_threeg); 925 if (rfk_wlan) 926 rfkill_unregister(rfk_wlan); 927err_wlan: 928 rfkill_destroy(rfk_wlan); 929 if (rfk_bluetooth) 930 rfkill_unregister(rfk_bluetooth); 931err_bluetooth: 932 rfkill_destroy(rfk_bluetooth); 933 934 return retval; 935} 936 937#ifdef CONFIG_PM_SLEEP 938static 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 960static 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 983err_free_keymap: 984 sparse_keymap_free(msi_laptop_input_dev); 985err_free_dev: 986 input_free_device(msi_laptop_input_dev); 987 return err; 988} 989 990static 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 996static 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 1039fail_filter: 1040 msi_laptop_input_destroy(); 1041 1042fail_input: 1043 rfkill_cleanup(); 1044 1045fail_rfkill: 1046 1047 return result; 1048 1049} 1050 1051static 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 1136fail_create_attr: 1137 sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group); 1138fail_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 } 1145fail_scm_model_init: 1146 platform_device_del(msipf_device); 1147fail_device_add: 1148 platform_device_put(msipf_device); 1149fail_platform_driver: 1150 platform_driver_unregister(&msipf_driver); 1151fail_backlight: 1152 backlight_device_unregister(msibl_device); 1153 1154 return ret; 1155} 1156 1157static 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 1183module_init(msi_init); 1184module_exit(msi_cleanup); 1185 1186MODULE_AUTHOR("Lennart Poettering"); 1187MODULE_DESCRIPTION("MSI Laptop Support"); 1188MODULE_VERSION(MSI_DRIVER_VERSION); 1189MODULE_LICENSE("GPL"); 1190 1191MODULE_ALIAS("dmi:*:svnMICRO-STARINT'LCO.,LTD:pnMS-1013:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1192MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1058:pvr0581:rvnMSI:rnMS-1058:*:ct10:*"); 1193MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1412:*:rvnMSI:rnMS-1412:*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1194MODULE_ALIAS("dmi:*:svnNOTEBOOK:pnSAM2000:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*"); 1195MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N034:*"); 1196MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N051:*"); 1197MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N014:*"); 1198MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnCR620:*"); 1199MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnU270series:*"); 1200MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnU90/U100:*"); 1201