drivers/platform/x86/msi-laptop.c

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