drivers/platform/x86/hp/hp-wmi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * HP WMI hotkeys
   4  *
   5  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
   6  * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
   7  *
   8  * Portions based on wistron_btns.c:
   9  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
  10  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  11  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/slab.h>
  20 #include <linux/types.h>
  21 #include <linux/input.h>
  22 #include <linux/input/sparse-keymap.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/platform_profile.h>
  25 #include <linux/hwmon.h>
  26 #include <linux/acpi.h>
  27 #include <linux/rfkill.h>
  28 #include <linux/string.h>
  29 #include <linux/dmi.h>
  30
  31 MODULE_AUTHOR("Matthew Garrett <mjg59@srcf.ucam.org>");
  32 MODULE_DESCRIPTION("HP laptop WMI hotkeys driver");
  33 MODULE_LICENSE("GPL");
  34
  35 MODULE_ALIAS("wmi:95F24279-4D7B-4334-9387-ACCDC67EF61C");
  36 MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
  37
  38 #define HPWMI_EVENT_GUID "95F24279-4D7B-4334-9387-ACCDC67EF61C"
  39 #define HPWMI_BIOS_GUID "5FB7F034-2C63-45e9-BE91-3D44E2C707E4"
  40 #define HP_OMEN_EC_THERMAL_PROFILE_OFFSET 0x95
  41 #define zero_if_sup(tmp) (zero_insize_support?0:sizeof(tmp)) // use when zero insize is required
  42
  43 /* DMI board names of devices that should use the omen specific path for
  44  * thermal profiles.
  45  * This was obtained by taking a look in the windows omen command center
  46  * app and parsing a json file that they use to figure out what capabilities
  47  * the device should have.
  48  * A device is considered an omen if the DisplayName in that list contains
  49  * "OMEN", and it can use the thermal profile stuff if the "Feature" array
  50  * contains "PerformanceControl".
  51  */
  52 static const char * const omen_thermal_profile_boards[] = {
  53         "84DA", "84DB", "84DC", "8574", "8575", "860A", "87B5", "8572", "8573",
  54         "8600", "8601", "8602", "8605", "8606", "8607", "8746", "8747", "8749",
  55         "874A", "8603", "8604", "8748", "886B", "886C", "878A", "878B", "878C",
  56         "88C8", "88CB", "8786", "8787", "8788", "88D1", "88D2", "88F4", "88FD",
  57         "88F5", "88F6", "88F7", "88FE", "88FF", "8900", "8901", "8902", "8912",
  58         "8917", "8918", "8949", "894A", "89EB"
  59 };
  60
  61 /* DMI Board names of Omen laptops that are specifically set to be thermal
  62  * profile version 0 by the Omen Command Center app, regardless of what
  63  * the get system design information WMI call returns
  64  */
  65 static const char *const omen_thermal_profile_force_v0_boards[] = {
  66         "8607", "8746", "8747", "8749", "874A", "8748"
  67 };
  68
  69 /* DMI Board names of Victus laptops */
  70 static const char * const victus_thermal_profile_boards[] = {
  71         "8A25"
  72 };
  73
  74 enum hp_wmi_radio {
  75         HPWMI_WIFI      = 0x0,
  76         HPWMI_BLUETOOTH = 0x1,
  77         HPWMI_WWAN      = 0x2,
  78         HPWMI_GPS       = 0x3,
  79 };
  80
  81 enum hp_wmi_event_ids {
  82         HPWMI_DOCK_EVENT                = 0x01,
  83         HPWMI_PARK_HDD                  = 0x02,
  84         HPWMI_SMART_ADAPTER             = 0x03,
  85         HPWMI_BEZEL_BUTTON              = 0x04,
  86         HPWMI_WIRELESS                  = 0x05,
  87         HPWMI_CPU_BATTERY_THROTTLE      = 0x06,
  88         HPWMI_LOCK_SWITCH               = 0x07,
  89         HPWMI_LID_SWITCH                = 0x08,
  90         HPWMI_SCREEN_ROTATION           = 0x09,
  91         HPWMI_COOLSENSE_SYSTEM_MOBILE   = 0x0A,
  92         HPWMI_COOLSENSE_SYSTEM_HOT      = 0x0B,
  93         HPWMI_PROXIMITY_SENSOR          = 0x0C,
  94         HPWMI_BACKLIT_KB_BRIGHTNESS     = 0x0D,
  95         HPWMI_PEAKSHIFT_PERIOD          = 0x0F,
  96         HPWMI_BATTERY_CHARGE_PERIOD     = 0x10,
  97         HPWMI_SANITIZATION_MODE         = 0x17,
  98         HPWMI_CAMERA_TOGGLE             = 0x1A,
  99         HPWMI_OMEN_KEY                  = 0x1D,
 100         HPWMI_SMART_EXPERIENCE_APP      = 0x21,
 101 };
 102
 103 /*
 104  * struct bios_args buffer is dynamically allocated.  New WMI command types
 105  * were introduced that exceeds 128-byte data size.  Changes to handle
 106  * the data size allocation scheme were kept in hp_wmi_perform_qurey function.
 107  */
 108 struct bios_args {
 109         u32 signature;
 110         u32 command;
 111         u32 commandtype;
 112         u32 datasize;
 113         u8 data[];
 114 };
 115
 116 enum hp_wmi_commandtype {
 117         HPWMI_DISPLAY_QUERY             = 0x01,
 118         HPWMI_HDDTEMP_QUERY             = 0x02,
 119         HPWMI_ALS_QUERY                 = 0x03,
 120         HPWMI_HARDWARE_QUERY            = 0x04,
 121         HPWMI_WIRELESS_QUERY            = 0x05,
 122         HPWMI_BATTERY_QUERY             = 0x07,
 123         HPWMI_BIOS_QUERY                = 0x09,
 124         HPWMI_FEATURE_QUERY             = 0x0b,
 125         HPWMI_HOTKEY_QUERY              = 0x0c,
 126         HPWMI_FEATURE2_QUERY            = 0x0d,
 127         HPWMI_WIRELESS2_QUERY           = 0x1b,
 128         HPWMI_POSTCODEERROR_QUERY       = 0x2a,
 129         HPWMI_SYSTEM_DEVICE_MODE        = 0x40,
 130         HPWMI_THERMAL_PROFILE_QUERY     = 0x4c,
 131 };
 132
 133 enum hp_wmi_gm_commandtype {
 134         HPWMI_FAN_SPEED_GET_QUERY = 0x11,
 135         HPWMI_SET_PERFORMANCE_MODE = 0x1A,
 136         HPWMI_FAN_SPEED_MAX_GET_QUERY = 0x26,
 137         HPWMI_FAN_SPEED_MAX_SET_QUERY = 0x27,
 138         HPWMI_GET_SYSTEM_DESIGN_DATA = 0x28,
 139 };
 140
 141 enum hp_wmi_command {
 142         HPWMI_READ      = 0x01,
 143         HPWMI_WRITE     = 0x02,
 144         HPWMI_ODM       = 0x03,
 145         HPWMI_GM        = 0x20008,
 146 };
 147
 148 enum hp_wmi_hardware_mask {
 149         HPWMI_DOCK_MASK         = 0x01,
 150         HPWMI_TABLET_MASK       = 0x04,
 151 };
 152
 153 struct bios_return {
 154         u32 sigpass;
 155         u32 return_code;
 156 };
 157
 158 enum hp_return_value {
 159         HPWMI_RET_WRONG_SIGNATURE       = 0x02,
 160         HPWMI_RET_UNKNOWN_COMMAND       = 0x03,
 161         HPWMI_RET_UNKNOWN_CMDTYPE       = 0x04,
 162         HPWMI_RET_INVALID_PARAMETERS    = 0x05,
 163 };
 164
 165 enum hp_wireless2_bits {
 166         HPWMI_POWER_STATE       = 0x01,
 167         HPWMI_POWER_SOFT        = 0x02,
 168         HPWMI_POWER_BIOS        = 0x04,
 169         HPWMI_POWER_HARD        = 0x08,
 170         HPWMI_POWER_FW_OR_HW    = HPWMI_POWER_BIOS | HPWMI_POWER_HARD,
 171 };
 172
 173 enum hp_thermal_profile_omen_v0 {
 174         HP_OMEN_V0_THERMAL_PROFILE_DEFAULT     = 0x00,
 175         HP_OMEN_V0_THERMAL_PROFILE_PERFORMANCE = 0x01,
 176         HP_OMEN_V0_THERMAL_PROFILE_COOL        = 0x02,
 177 };
 178
 179 enum hp_thermal_profile_omen_v1 {
 180         HP_OMEN_V1_THERMAL_PROFILE_DEFAULT      = 0x30,
 181         HP_OMEN_V1_THERMAL_PROFILE_PERFORMANCE  = 0x31,
 182         HP_OMEN_V1_THERMAL_PROFILE_COOL         = 0x50,
 183 };
 184
 185 enum hp_thermal_profile_victus {
 186         HP_VICTUS_THERMAL_PROFILE_DEFAULT               = 0x00,
 187         HP_VICTUS_THERMAL_PROFILE_PERFORMANCE           = 0x01,
 188         HP_VICTUS_THERMAL_PROFILE_QUIET                 = 0x03,
 189 };
 190
 191 enum hp_thermal_profile {
 192         HP_THERMAL_PROFILE_PERFORMANCE  = 0x00,
 193         HP_THERMAL_PROFILE_DEFAULT              = 0x01,
 194         HP_THERMAL_PROFILE_COOL                 = 0x02,
 195         HP_THERMAL_PROFILE_QUIET                = 0x03,
 196 };
 197
 198 #define IS_HWBLOCKED(x) ((x & HPWMI_POWER_FW_OR_HW) != HPWMI_POWER_FW_OR_HW)
 199 #define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
 200
 201 struct bios_rfkill2_device_state {
 202         u8 radio_type;
 203         u8 bus_type;
 204         u16 vendor_id;
 205         u16 product_id;
 206         u16 subsys_vendor_id;
 207         u16 subsys_product_id;
 208         u8 rfkill_id;
 209         u8 power;
 210         u8 unknown[4];
 211 };
 212
 213 /* 7 devices fit into the 128 byte buffer */
 214 #define HPWMI_MAX_RFKILL2_DEVICES       7
 215
 216 struct bios_rfkill2_state {
 217         u8 unknown[7];
 218         u8 count;
 219         u8 pad[8];
 220         struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
 221 };
 222
 223 static const struct key_entry hp_wmi_keymap[] = {
 224         { KE_KEY, 0x02,    { KEY_BRIGHTNESSUP } },
 225         { KE_KEY, 0x03,    { KEY_BRIGHTNESSDOWN } },
 226         { KE_KEY, 0x270,   { KEY_MICMUTE } },
 227         { KE_KEY, 0x20e6,  { KEY_PROG1 } },
 228         { KE_KEY, 0x20e8,  { KEY_MEDIA } },
 229         { KE_KEY, 0x2142,  { KEY_MEDIA } },
 230         { KE_KEY, 0x213b,  { KEY_INFO } },
 231         { KE_KEY, 0x2169,  { KEY_ROTATE_DISPLAY } },
 232         { KE_KEY, 0x216a,  { KEY_SETUP } },
 233         { KE_IGNORE, 0x21a4,  }, /* Win Lock On */
 234         { KE_IGNORE, 0x121a4, }, /* Win Lock Off */
 235         { KE_KEY, 0x21a5,  { KEY_PROG2 } }, /* HP Omen Key */
 236         { KE_KEY, 0x21a7,  { KEY_FN_ESC } },
 237         { KE_KEY, 0x21a8,  { KEY_PROG2 } }, /* HP Envy x360 programmable key */
 238         { KE_KEY, 0x21a9,  { KEY_TOUCHPAD_OFF } },
 239         { KE_KEY, 0x121a9, { KEY_TOUCHPAD_ON } },
 240         { KE_KEY, 0x231b,  { KEY_HELP } },
 241         { KE_END, 0 }
 242 };
 243
 244 static struct input_dev *hp_wmi_input_dev;
 245 static struct input_dev *camera_shutter_input_dev;
 246 static struct platform_device *hp_wmi_platform_dev;
 247 static struct platform_profile_handler platform_profile_handler;
 248 static bool platform_profile_support;
 249 static bool zero_insize_support;
 250
 251 static struct rfkill *wifi_rfkill;
 252 static struct rfkill *bluetooth_rfkill;
 253 static struct rfkill *wwan_rfkill;
 254
 255 struct rfkill2_device {
 256         u8 id;
 257         int num;
 258         struct rfkill *rfkill;
 259 };
 260
 261 static int rfkill2_count;
 262 static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
 263
 264 /*
 265  * Chassis Types values were obtained from SMBIOS reference
 266  * specification version 3.00. A complete list of system enclosures
 267  * and chassis types is available on Table 17.
 268  */
 269 static const char * const tablet_chassis_types[] = {
 270         "30", /* Tablet*/
 271         "31", /* Convertible */
 272         "32"  /* Detachable */
 273 };
 274
 275 #define DEVICE_MODE_TABLET      0x06
 276
 277 /* map output size to the corresponding WMI method id */
 278 static inline int encode_outsize_for_pvsz(int outsize)
 279 {
 280         if (outsize > 4096)
 281                 return -EINVAL;
 282         if (outsize > 1024)
 283                 return 5;
 284         if (outsize > 128)
 285                 return 4;
 286         if (outsize > 4)
 287                 return 3;
 288         if (outsize > 0)
 289                 return 2;
 290         return 1;
 291 }
 292
 293 /*
 294  * hp_wmi_perform_query
 295  *
 296  * query:       The commandtype (enum hp_wmi_commandtype)
 297  * write:       The command (enum hp_wmi_command)
 298  * buffer:      Buffer used as input and/or output
 299  * insize:      Size of input buffer
 300  * outsize:     Size of output buffer
 301  *
 302  * returns zero on success
 303  *         an HP WMI query specific error code (which is positive)
 304  *         -EINVAL if the query was not successful at all
 305  *         -EINVAL if the output buffer size exceeds buffersize
 306  *
 307  * Note: The buffersize must at least be the maximum of the input and output
 308  *       size. E.g. Battery info query is defined to have 1 byte input
 309  *       and 128 byte output. The caller would do:
 310  *       buffer = kzalloc(128, GFP_KERNEL);
 311  *       ret = hp_wmi_perform_query(HPWMI_BATTERY_QUERY, HPWMI_READ, buffer, 1, 128)
 312  */
 313 static int hp_wmi_perform_query(int query, enum hp_wmi_command command,
 314                                 void *buffer, int insize, int outsize)
 315 {
 316         struct acpi_buffer input, output = { ACPI_ALLOCATE_BUFFER, NULL };
 317         struct bios_return *bios_return;
 318         union acpi_object *obj = NULL;
 319         struct bios_args *args = NULL;
 320         int mid, actual_insize, actual_outsize;
 321         size_t bios_args_size;
 322         int ret;
 323
 324         mid = encode_outsize_for_pvsz(outsize);
 325         if (WARN_ON(mid < 0))
 326                 return mid;
 327
 328         actual_insize = max(insize, 128);
 329         bios_args_size = struct_size(args, data, actual_insize);
 330         args = kmalloc(bios_args_size, GFP_KERNEL);
 331         if (!args)
 332                 return -ENOMEM;
 333
 334         input.length = bios_args_size;
 335         input.pointer = args;
 336
 337         args->signature = 0x55434553;
 338         args->command = command;
 339         args->commandtype = query;
 340         args->datasize = insize;
 341         memcpy(args->data, buffer, flex_array_size(args, data, insize));
 342
 343         ret = wmi_evaluate_method(HPWMI_BIOS_GUID, 0, mid, &input, &output);
 344         if (ret)
 345                 goto out_free;
 346
 347         obj = output.pointer;
 348         if (!obj) {
 349                 ret = -EINVAL;
 350                 goto out_free;
 351         }
 352
 353         if (obj->type != ACPI_TYPE_BUFFER) {
 354                 pr_warn("query 0x%x returned an invalid object 0x%x\n", query, ret);
 355                 ret = -EINVAL;
 356                 goto out_free;
 357         }
 358
 359         bios_return = (struct bios_return *)obj->buffer.pointer;
 360         ret = bios_return->return_code;
 361
 362         if (ret) {
 363                 if (ret != HPWMI_RET_UNKNOWN_COMMAND &&
 364                     ret != HPWMI_RET_UNKNOWN_CMDTYPE)
 365                         pr_warn("query 0x%x returned error 0x%x\n", query, ret);
 366                 goto out_free;
 367         }
 368
 369         /* Ignore output data of zero size */
 370         if (!outsize)
 371                 goto out_free;
 372
 373         actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
 374         memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
 375         memset(buffer + actual_outsize, 0, outsize - actual_outsize);
 376
 377 out_free:
 378         kfree(obj);
 379         kfree(args);
 380         return ret;
 381 }
 382
 383 static int hp_wmi_get_fan_speed(int fan)
 384 {
 385         u8 fsh, fsl;
 386         char fan_data[4] = { fan, 0, 0, 0 };
 387
 388         int ret = hp_wmi_perform_query(HPWMI_FAN_SPEED_GET_QUERY, HPWMI_GM,
 389                                        &fan_data, sizeof(char),
 390                                        sizeof(fan_data));
 391
 392         if (ret != 0)
 393                 return -EINVAL;
 394
 395         fsh = fan_data[2];
 396         fsl = fan_data[3];
 397
 398         return (fsh << 8) | fsl;
 399 }
 400
 401 static int hp_wmi_read_int(int query)
 402 {
 403         int val = 0, ret;
 404
 405         ret = hp_wmi_perform_query(query, HPWMI_READ, &val,
 406                                    zero_if_sup(val), sizeof(val));
 407
 408         if (ret)
 409                 return ret < 0 ? ret : -EINVAL;
 410
 411         return val;
 412 }
 413
 414 static int hp_wmi_get_dock_state(void)
 415 {
 416         int state = hp_wmi_read_int(HPWMI_HARDWARE_QUERY);
 417
 418         if (state < 0)
 419                 return state;
 420
 421         return !!(state & HPWMI_DOCK_MASK);
 422 }
 423
 424 static int hp_wmi_get_tablet_mode(void)
 425 {
 426         char system_device_mode[4] = { 0 };
 427         const char *chassis_type;
 428         bool tablet_found;
 429         int ret;
 430
 431         chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
 432         if (!chassis_type)
 433                 return -ENODEV;
 434
 435         tablet_found = match_string(tablet_chassis_types,
 436                                     ARRAY_SIZE(tablet_chassis_types),
 437                                     chassis_type) >= 0;
 438         if (!tablet_found)
 439                 return -ENODEV;
 440
 441         ret = hp_wmi_perform_query(HPWMI_SYSTEM_DEVICE_MODE, HPWMI_READ,
 442                                    system_device_mode, zero_if_sup(system_device_mode),
 443                                    sizeof(system_device_mode));
 444         if (ret < 0)
 445                 return ret;
 446
 447         return system_device_mode[0] == DEVICE_MODE_TABLET;
 448 }
 449
 450 static int omen_thermal_profile_set(int mode)
 451 {
 452         char buffer[2] = {0, mode};
 453         int ret;
 454
 455         ret = hp_wmi_perform_query(HPWMI_SET_PERFORMANCE_MODE, HPWMI_GM,
 456                                    &buffer, sizeof(buffer), 0);
 457
 458         if (ret)
 459                 return ret < 0 ? ret : -EINVAL;
 460
 461         return mode;
 462 }
 463
 464 static bool is_omen_thermal_profile(void)
 465 {
 466         const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);
 467
 468         if (!board_name)
 469                 return false;
 470
 471         return match_string(omen_thermal_profile_boards,
 472                             ARRAY_SIZE(omen_thermal_profile_boards),
 473                             board_name) >= 0;
 474 }
 475
 476 static int omen_get_thermal_policy_version(void)
 477 {
 478         unsigned char buffer[8] = { 0 };
 479         int ret;
 480
 481         const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);
 482
 483         if (board_name) {
 484                 int matches = match_string(omen_thermal_profile_force_v0_boards,
 485                         ARRAY_SIZE(omen_thermal_profile_force_v0_boards),
 486                         board_name);
 487                 if (matches >= 0)
 488                         return 0;
 489         }
 490
 491         ret = hp_wmi_perform_query(HPWMI_GET_SYSTEM_DESIGN_DATA, HPWMI_GM,
 492                                    &buffer, sizeof(buffer), sizeof(buffer));
 493
 494         if (ret)
 495                 return ret < 0 ? ret : -EINVAL;
 496
 497         return buffer[3];
 498 }
 499
 500 static int omen_thermal_profile_get(void)
 501 {
 502         u8 data;
 503
 504         int ret = ec_read(HP_OMEN_EC_THERMAL_PROFILE_OFFSET, &data);
 505
 506         if (ret)
 507                 return ret;
 508
 509         return data;
 510 }
 511
 512 static int hp_wmi_fan_speed_max_set(int enabled)
 513 {
 514         int ret;
 515
 516         ret = hp_wmi_perform_query(HPWMI_FAN_SPEED_MAX_SET_QUERY, HPWMI_GM,
 517                                    &enabled, sizeof(enabled), 0);
 518
 519         if (ret)
 520                 return ret < 0 ? ret : -EINVAL;
 521
 522         return enabled;
 523 }
 524
 525 static int hp_wmi_fan_speed_max_get(void)
 526 {
 527         int val = 0, ret;
 528
 529         ret = hp_wmi_perform_query(HPWMI_FAN_SPEED_MAX_GET_QUERY, HPWMI_GM,
 530                                    &val, zero_if_sup(val), sizeof(val));
 531
 532         if (ret)
 533                 return ret < 0 ? ret : -EINVAL;
 534
 535         return val;
 536 }
 537
 538 static int __init hp_wmi_bios_2008_later(void)
 539 {
 540         int state = 0;
 541         int ret = hp_wmi_perform_query(HPWMI_FEATURE_QUERY, HPWMI_READ, &state,
 542                                        zero_if_sup(state), sizeof(state));
 543         if (!ret)
 544                 return 1;
 545
 546         return (ret == HPWMI_RET_UNKNOWN_CMDTYPE) ? 0 : -ENXIO;
 547 }
 548
 549 static int __init hp_wmi_bios_2009_later(void)
 550 {
 551         u8 state[128];
 552         int ret = hp_wmi_perform_query(HPWMI_FEATURE2_QUERY, HPWMI_READ, &state,
 553                                        zero_if_sup(state), sizeof(state));
 554         if (!ret)
 555                 return 1;
 556
 557         return (ret == HPWMI_RET_UNKNOWN_CMDTYPE) ? 0 : -ENXIO;
 558 }
 559
 560 static int __init hp_wmi_enable_hotkeys(void)
 561 {
 562         int value = 0x6e;
 563         int ret = hp_wmi_perform_query(HPWMI_BIOS_QUERY, HPWMI_WRITE, &value,
 564                                        sizeof(value), 0);
 565
 566         return ret <= 0 ? ret : -EINVAL;
 567 }
 568
 569 static int hp_wmi_set_block(void *data, bool blocked)
 570 {
 571         enum hp_wmi_radio r = (long)data;
 572         int query = BIT(r + 8) | ((!blocked) << r);
 573         int ret;
 574
 575         ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, HPWMI_WRITE,
 576                                    &query, sizeof(query), 0);
 577
 578         return ret <= 0 ? ret : -EINVAL;
 579 }
 580
 581 static const struct rfkill_ops hp_wmi_rfkill_ops = {
 582         .set_block = hp_wmi_set_block,
 583 };
 584
 585 static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
 586 {
 587         int mask = 0x200 << (r * 8);
 588
 589         int wireless = hp_wmi_read_int(HPWMI_WIRELESS_QUERY);
 590
 591         /* TBD: Pass error */
 592         WARN_ONCE(wireless < 0, "error executing HPWMI_WIRELESS_QUERY");
 593
 594         return !(wireless & mask);
 595 }
 596
 597 static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
 598 {
 599         int mask = 0x800 << (r * 8);
 600
 601         int wireless = hp_wmi_read_int(HPWMI_WIRELESS_QUERY);
 602
 603         /* TBD: Pass error */
 604         WARN_ONCE(wireless < 0, "error executing HPWMI_WIRELESS_QUERY");
 605
 606         return !(wireless & mask);
 607 }
 608
 609 static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
 610 {
 611         int rfkill_id = (int)(long)data;
 612         char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
 613         int ret;
 614
 615         ret = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, HPWMI_WRITE,
 616                                    buffer, sizeof(buffer), 0);
 617
 618         return ret <= 0 ? ret : -EINVAL;
 619 }
 620
 621 static const struct rfkill_ops hp_wmi_rfkill2_ops = {
 622         .set_block = hp_wmi_rfkill2_set_block,
 623 };
 624
 625 static int hp_wmi_rfkill2_refresh(void)
 626 {
 627         struct bios_rfkill2_state state;
 628         int err, i;
 629
 630         err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, HPWMI_READ, &state,
 631                                    zero_if_sup(state), sizeof(state));
 632         if (err)
 633                 return err;
 634
 635         for (i = 0; i < rfkill2_count; i++) {
 636                 int num = rfkill2[i].num;
 637                 struct bios_rfkill2_device_state *devstate;
 638
 639                 devstate = &state.device[num];
 640
 641                 if (num >= state.count ||
 642                     devstate->rfkill_id != rfkill2[i].id) {
 643                         pr_warn("power configuration of the wireless devices unexpectedly changed\n");
 644                         continue;
 645                 }
 646
 647                 rfkill_set_states(rfkill2[i].rfkill,
 648                                   IS_SWBLOCKED(devstate->power),
 649                                   IS_HWBLOCKED(devstate->power));
 650         }
 651
 652         return 0;
 653 }
 654
 655 static ssize_t display_show(struct device *dev, struct device_attribute *attr,
 656                             char *buf)
 657 {
 658         int value = hp_wmi_read_int(HPWMI_DISPLAY_QUERY);
 659
 660         if (value < 0)
 661                 return value;
 662         return sprintf(buf, "%d\n", value);
 663 }
 664
 665 static ssize_t hddtemp_show(struct device *dev, struct device_attribute *attr,
 666                             char *buf)
 667 {
 668         int value = hp_wmi_read_int(HPWMI_HDDTEMP_QUERY);
 669
 670         if (value < 0)
 671                 return value;
 672         return sprintf(buf, "%d\n", value);
 673 }
 674
 675 static ssize_t als_show(struct device *dev, struct device_attribute *attr,
 676                         char *buf)
 677 {
 678         int value = hp_wmi_read_int(HPWMI_ALS_QUERY);
 679
 680         if (value < 0)
 681                 return value;
 682         return sprintf(buf, "%d\n", value);
 683 }
 684
 685 static ssize_t dock_show(struct device *dev, struct device_attribute *attr,
 686                          char *buf)
 687 {
 688         int value = hp_wmi_get_dock_state();
 689
 690         if (value < 0)
 691                 return value;
 692         return sprintf(buf, "%d\n", value);
 693 }
 694
 695 static ssize_t tablet_show(struct device *dev, struct device_attribute *attr,
 696                            char *buf)
 697 {
 698         int value = hp_wmi_get_tablet_mode();
 699
 700         if (value < 0)
 701                 return value;
 702         return sprintf(buf, "%d\n", value);
 703 }
 704
 705 static ssize_t postcode_show(struct device *dev, struct device_attribute *attr,
 706                              char *buf)
 707 {
 708         /* Get the POST error code of previous boot failure. */
 709         int value = hp_wmi_read_int(HPWMI_POSTCODEERROR_QUERY);
 710
 711         if (value < 0)
 712                 return value;
 713         return sprintf(buf, "0x%x\n", value);
 714 }
 715
 716 static ssize_t als_store(struct device *dev, struct device_attribute *attr,
 717                          const char *buf, size_t count)
 718 {
 719         u32 tmp;
 720         int ret;
 721
 722         ret = kstrtou32(buf, 10, &tmp);
 723         if (ret)
 724                 return ret;
 725
 726         ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, HPWMI_WRITE, &tmp,
 727                                        sizeof(tmp), 0);
 728         if (ret)
 729                 return ret < 0 ? ret : -EINVAL;
 730
 731         return count;
 732 }
 733
 734 static ssize_t postcode_store(struct device *dev, struct device_attribute *attr,
 735                               const char *buf, size_t count)
 736 {
 737         u32 tmp = 1;
 738         bool clear;
 739         int ret;
 740
 741         ret = kstrtobool(buf, &clear);
 742         if (ret)
 743                 return ret;
 744
 745         if (clear == false)
 746                 return -EINVAL;
 747
 748         /* Clear the POST error code. It is kept until cleared. */
 749         ret = hp_wmi_perform_query(HPWMI_POSTCODEERROR_QUERY, HPWMI_WRITE, &tmp,
 750                                        sizeof(tmp), 0);
 751         if (ret)
 752                 return ret < 0 ? ret : -EINVAL;
 753
 754         return count;
 755 }
 756
 757 static int camera_shutter_input_setup(void)
 758 {
 759         int err;
 760
 761         camera_shutter_input_dev = input_allocate_device();
 762         if (!camera_shutter_input_dev)
 763                 return -ENOMEM;
 764
 765         camera_shutter_input_dev->name = "HP WMI camera shutter";
 766         camera_shutter_input_dev->phys = "wmi/input1";
 767         camera_shutter_input_dev->id.bustype = BUS_HOST;
 768
 769         __set_bit(EV_SW, camera_shutter_input_dev->evbit);
 770         __set_bit(SW_CAMERA_LENS_COVER, camera_shutter_input_dev->swbit);
 771
 772         err = input_register_device(camera_shutter_input_dev);
 773         if (err)
 774                 goto err_free_dev;
 775
 776         return 0;
 777
 778  err_free_dev:
 779         input_free_device(camera_shutter_input_dev);
 780         camera_shutter_input_dev = NULL;
 781         return err;
 782 }
 783
 784 static DEVICE_ATTR_RO(display);
 785 static DEVICE_ATTR_RO(hddtemp);
 786 static DEVICE_ATTR_RW(als);
 787 static DEVICE_ATTR_RO(dock);
 788 static DEVICE_ATTR_RO(tablet);
 789 static DEVICE_ATTR_RW(postcode);
 790
 791 static struct attribute *hp_wmi_attrs[] = {
 792         &dev_attr_display.attr,
 793         &dev_attr_hddtemp.attr,
 794         &dev_attr_als.attr,
 795         &dev_attr_dock.attr,
 796         &dev_attr_tablet.attr,
 797         &dev_attr_postcode.attr,
 798         NULL,
 799 };
 800 ATTRIBUTE_GROUPS(hp_wmi);
 801
 802 static void hp_wmi_notify(u32 value, void *context)
 803 {
 804         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
 805         u32 event_id, event_data;
 806         union acpi_object *obj;
 807         acpi_status status;
 808         u32 *location;
 809         int key_code;
 810
 811         status = wmi_get_event_data(value, &response);
 812         if (status != AE_OK) {
 813                 pr_info("bad event status 0x%x\n", status);
 814                 return;
 815         }
 816
 817         obj = (union acpi_object *)response.pointer;
 818
 819         if (!obj)
 820                 return;
 821         if (obj->type != ACPI_TYPE_BUFFER) {
 822                 pr_info("Unknown response received %d\n", obj->type);
 823                 kfree(obj);
 824                 return;
 825         }
 826
 827         /*
 828          * Depending on ACPI version the concatenation of id and event data
 829          * inside _WED function will result in a 8 or 16 byte buffer.
 830          */
 831         location = (u32 *)obj->buffer.pointer;
 832         if (obj->buffer.length == 8) {
 833                 event_id = *location;
 834                 event_data = *(location + 1);
 835         } else if (obj->buffer.length == 16) {
 836                 event_id = *location;
 837                 event_data = *(location + 2);
 838         } else {
 839                 pr_info("Unknown buffer length %d\n", obj->buffer.length);
 840                 kfree(obj);
 841                 return;
 842         }
 843         kfree(obj);
 844
 845         switch (event_id) {
 846         case HPWMI_DOCK_EVENT:
 847                 if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit))
 848                         input_report_switch(hp_wmi_input_dev, SW_DOCK,
 849                                             hp_wmi_get_dock_state());
 850                 if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit))
 851                         input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
 852                                             hp_wmi_get_tablet_mode());
 853                 input_sync(hp_wmi_input_dev);
 854                 break;
 855         case HPWMI_PARK_HDD:
 856                 break;
 857         case HPWMI_SMART_ADAPTER:
 858                 break;
 859         case HPWMI_BEZEL_BUTTON:
 860                 key_code = hp_wmi_read_int(HPWMI_HOTKEY_QUERY);
 861                 if (key_code < 0)
 862                         break;
 863
 864                 if (!sparse_keymap_report_event(hp_wmi_input_dev,
 865                                                 key_code, 1, true))
 866                         pr_info("Unknown key code - 0x%x\n", key_code);
 867                 break;
 868         case HPWMI_OMEN_KEY:
 869                 if (event_data) /* Only should be true for HP Omen */
 870                         key_code = event_data;
 871                 else
 872                         key_code = hp_wmi_read_int(HPWMI_HOTKEY_QUERY);
 873
 874                 if (!sparse_keymap_report_event(hp_wmi_input_dev,
 875                                                 key_code, 1, true))
 876                         pr_info("Unknown key code - 0x%x\n", key_code);
 877                 break;
 878         case HPWMI_WIRELESS:
 879                 if (rfkill2_count) {
 880                         hp_wmi_rfkill2_refresh();
 881                         break;
 882                 }
 883
 884                 if (wifi_rfkill)
 885                         rfkill_set_states(wifi_rfkill,
 886                                           hp_wmi_get_sw_state(HPWMI_WIFI),
 887                                           hp_wmi_get_hw_state(HPWMI_WIFI));
 888                 if (bluetooth_rfkill)
 889                         rfkill_set_states(bluetooth_rfkill,
 890                                           hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
 891                                           hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
 892                 if (wwan_rfkill)
 893                         rfkill_set_states(wwan_rfkill,
 894                                           hp_wmi_get_sw_state(HPWMI_WWAN),
 895                                           hp_wmi_get_hw_state(HPWMI_WWAN));
 896                 break;
 897         case HPWMI_CPU_BATTERY_THROTTLE:
 898                 pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n");
 899                 break;
 900         case HPWMI_LOCK_SWITCH:
 901                 break;
 902         case HPWMI_LID_SWITCH:
 903                 break;
 904         case HPWMI_SCREEN_ROTATION:
 905                 break;
 906         case HPWMI_COOLSENSE_SYSTEM_MOBILE:
 907                 break;
 908         case HPWMI_COOLSENSE_SYSTEM_HOT:
 909                 break;
 910         case HPWMI_PROXIMITY_SENSOR:
 911                 break;
 912         case HPWMI_BACKLIT_KB_BRIGHTNESS:
 913                 break;
 914         case HPWMI_PEAKSHIFT_PERIOD:
 915                 break;
 916         case HPWMI_BATTERY_CHARGE_PERIOD:
 917                 break;
 918         case HPWMI_SANITIZATION_MODE:
 919                 break;
 920         case HPWMI_CAMERA_TOGGLE:
 921                 if (!camera_shutter_input_dev)
 922                         if (camera_shutter_input_setup()) {
 923                                 pr_err("Failed to setup camera shutter input device\n");
 924                                 break;
 925                         }
 926                 if (event_data == 0xff)
 927                         input_report_switch(camera_shutter_input_dev, SW_CAMERA_LENS_COVER, 1);
 928                 else if (event_data == 0xfe)
 929                         input_report_switch(camera_shutter_input_dev, SW_CAMERA_LENS_COVER, 0);
 930                 else
 931                         pr_warn("Unknown camera shutter state - 0x%x\n", event_data);
 932                 input_sync(camera_shutter_input_dev);
 933                 break;
 934         case HPWMI_SMART_EXPERIENCE_APP:
 935                 break;
 936         default:
 937                 pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
 938                 break;
 939         }
 940 }
 941
 942 static int __init hp_wmi_input_setup(void)
 943 {
 944         acpi_status status;
 945         int err, val;
 946
 947         hp_wmi_input_dev = input_allocate_device();
 948         if (!hp_wmi_input_dev)
 949                 return -ENOMEM;
 950
 951         hp_wmi_input_dev->name = "HP WMI hotkeys";
 952         hp_wmi_input_dev->phys = "wmi/input0";
 953         hp_wmi_input_dev->id.bustype = BUS_HOST;
 954
 955         __set_bit(EV_SW, hp_wmi_input_dev->evbit);
 956
 957         /* Dock */
 958         val = hp_wmi_get_dock_state();
 959         if (!(val < 0)) {
 960                 __set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
 961                 input_report_switch(hp_wmi_input_dev, SW_DOCK, val);
 962         }
 963
 964         /* Tablet mode */
 965         val = hp_wmi_get_tablet_mode();
 966         if (!(val < 0)) {
 967                 __set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
 968                 input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE, val);
 969         }
 970
 971         err = sparse_keymap_setup(hp_wmi_input_dev, hp_wmi_keymap, NULL);
 972         if (err)
 973                 goto err_free_dev;
 974
 975         /* Set initial hardware state */
 976         input_sync(hp_wmi_input_dev);
 977
 978         if (!hp_wmi_bios_2009_later() && hp_wmi_bios_2008_later())
 979                 hp_wmi_enable_hotkeys();
 980
 981         status = wmi_install_notify_handler(HPWMI_EVENT_GUID, hp_wmi_notify, NULL);
 982         if (ACPI_FAILURE(status)) {
 983                 err = -EIO;
 984                 goto err_free_dev;
 985         }
 986
 987         err = input_register_device(hp_wmi_input_dev);
 988         if (err)
 989                 goto err_uninstall_notifier;
 990
 991         return 0;
 992
 993  err_uninstall_notifier:
 994         wmi_remove_notify_handler(HPWMI_EVENT_GUID);
 995  err_free_dev:
 996         input_free_device(hp_wmi_input_dev);
 997         return err;
 998 }
 999
1000 static void hp_wmi_input_destroy(void)
1001 {
1002         wmi_remove_notify_handler(HPWMI_EVENT_GUID);
1003         input_unregister_device(hp_wmi_input_dev);
1004 }
1005
1006 static int __init hp_wmi_rfkill_setup(struct platform_device *device)
1007 {
1008         int err, wireless;
1009
1010         wireless = hp_wmi_read_int(HPWMI_WIRELESS_QUERY);
1011         if (wireless < 0)
1012                 return wireless;
1013
1014         err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, HPWMI_WRITE, &wireless,
1015                                    sizeof(wireless), 0);
1016         if (err)
1017                 return err;
1018
1019         if (wireless & 0x1) {
1020                 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
1021                                            RFKILL_TYPE_WLAN,
1022                                            &hp_wmi_rfkill_ops,
1023                                            (void *) HPWMI_WIFI);
1024                 if (!wifi_rfkill)
1025                         return -ENOMEM;
1026                 rfkill_init_sw_state(wifi_rfkill,
1027                                      hp_wmi_get_sw_state(HPWMI_WIFI));
1028                 rfkill_set_hw_state(wifi_rfkill,
1029                                     hp_wmi_get_hw_state(HPWMI_WIFI));
1030                 err = rfkill_register(wifi_rfkill);
1031                 if (err)
1032                         goto register_wifi_error;
1033         }
1034
1035         if (wireless & 0x2) {
1036                 bluetooth_rfkill = rfkill_alloc("hp-bluetooth", &device->dev,
1037                                                 RFKILL_TYPE_BLUETOOTH,
1038                                                 &hp_wmi_rfkill_ops,
1039                                                 (void *) HPWMI_BLUETOOTH);
1040                 if (!bluetooth_rfkill) {
1041                         err = -ENOMEM;
1042                         goto register_bluetooth_error;
1043                 }
1044                 rfkill_init_sw_state(bluetooth_rfkill,
1045                                      hp_wmi_get_sw_state(HPWMI_BLUETOOTH));
1046                 rfkill_set_hw_state(bluetooth_rfkill,
1047                                     hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
1048                 err = rfkill_register(bluetooth_rfkill);
1049                 if (err)
1050                         goto register_bluetooth_error;
1051         }
1052
1053         if (wireless & 0x4) {
1054                 wwan_rfkill = rfkill_alloc("hp-wwan", &device->dev,
1055                                            RFKILL_TYPE_WWAN,
1056                                            &hp_wmi_rfkill_ops,
1057                                            (void *) HPWMI_WWAN);
1058                 if (!wwan_rfkill) {
1059                         err = -ENOMEM;
1060                         goto register_wwan_error;
1061                 }
1062                 rfkill_init_sw_state(wwan_rfkill,
1063                                      hp_wmi_get_sw_state(HPWMI_WWAN));
1064                 rfkill_set_hw_state(wwan_rfkill,
1065                                     hp_wmi_get_hw_state(HPWMI_WWAN));
1066                 err = rfkill_register(wwan_rfkill);
1067                 if (err)
1068                         goto register_wwan_error;
1069         }
1070
1071         return 0;
1072
1073 register_wwan_error:
1074         rfkill_destroy(wwan_rfkill);
1075         wwan_rfkill = NULL;
1076         if (bluetooth_rfkill)
1077                 rfkill_unregister(bluetooth_rfkill);
1078 register_bluetooth_error:
1079         rfkill_destroy(bluetooth_rfkill);
1080         bluetooth_rfkill = NULL;
1081         if (wifi_rfkill)
1082                 rfkill_unregister(wifi_rfkill);
1083 register_wifi_error:
1084         rfkill_destroy(wifi_rfkill);
1085         wifi_rfkill = NULL;
1086         return err;
1087 }
1088
1089 static int __init hp_wmi_rfkill2_setup(struct platform_device *device)
1090 {
1091         struct bios_rfkill2_state state;
1092         int err, i;
1093
1094         err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, HPWMI_READ, &state,
1095                                    zero_if_sup(state), sizeof(state));
1096         if (err)
1097                 return err < 0 ? err : -EINVAL;
1098
1099         if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
1100                 pr_warn("unable to parse 0x1b query output\n");
1101                 return -EINVAL;
1102         }
1103
1104         for (i = 0; i < state.count; i++) {
1105                 struct rfkill *rfkill;
1106                 enum rfkill_type type;
1107                 char *name;
1108
1109                 switch (state.device[i].radio_type) {
1110                 case HPWMI_WIFI:
1111                         type = RFKILL_TYPE_WLAN;
1112                         name = "hp-wifi";
1113                         break;
1114                 case HPWMI_BLUETOOTH:
1115                         type = RFKILL_TYPE_BLUETOOTH;
1116                         name = "hp-bluetooth";
1117                         break;
1118                 case HPWMI_WWAN:
1119                         type = RFKILL_TYPE_WWAN;
1120                         name = "hp-wwan";
1121                         break;
1122                 case HPWMI_GPS:
1123                         type = RFKILL_TYPE_GPS;
1124                         name = "hp-gps";
1125                         break;
1126                 default:
1127                         pr_warn("unknown device type 0x%x\n",
1128                                 state.device[i].radio_type);
1129                         continue;
1130                 }
1131
1132                 if (!state.device[i].vendor_id) {
1133                         pr_warn("zero device %d while %d reported\n",
1134                                 i, state.count);
1135                         continue;
1136                 }
1137
1138                 rfkill = rfkill_alloc(name, &device->dev, type,
1139                                       &hp_wmi_rfkill2_ops, (void *)(long)i);
1140                 if (!rfkill) {
1141                         err = -ENOMEM;
1142                         goto fail;
1143                 }
1144
1145                 rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
1146                 rfkill2[rfkill2_count].num = i;
1147                 rfkill2[rfkill2_count].rfkill = rfkill;
1148
1149                 rfkill_init_sw_state(rfkill,
1150                                      IS_SWBLOCKED(state.device[i].power));
1151                 rfkill_set_hw_state(rfkill,
1152                                     IS_HWBLOCKED(state.device[i].power));
1153
1154                 if (!(state.device[i].power & HPWMI_POWER_BIOS))
1155                         pr_info("device %s blocked by BIOS\n", name);
1156
1157                 err = rfkill_register(rfkill);
1158                 if (err) {
1159                         rfkill_destroy(rfkill);
1160                         goto fail;
1161                 }
1162
1163                 rfkill2_count++;
1164         }
1165
1166         return 0;
1167 fail:
1168         for (; rfkill2_count > 0; rfkill2_count--) {
1169                 rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
1170                 rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
1171         }
1172         return err;
1173 }
1174
1175 static int platform_profile_omen_get(struct platform_profile_handler *pprof,
1176                                      enum platform_profile_option *profile)
1177 {
1178         int tp;
1179
1180         tp = omen_thermal_profile_get();
1181         if (tp < 0)
1182                 return tp;
1183
1184         switch (tp) {
1185         case HP_OMEN_V0_THERMAL_PROFILE_PERFORMANCE:
1186         case HP_OMEN_V1_THERMAL_PROFILE_PERFORMANCE:
1187                 *profile = PLATFORM_PROFILE_PERFORMANCE;
1188                 break;
1189         case HP_OMEN_V0_THERMAL_PROFILE_DEFAULT:
1190         case HP_OMEN_V1_THERMAL_PROFILE_DEFAULT:
1191                 *profile = PLATFORM_PROFILE_BALANCED;
1192                 break;
1193         case HP_OMEN_V0_THERMAL_PROFILE_COOL:
1194         case HP_OMEN_V1_THERMAL_PROFILE_COOL:
1195                 *profile = PLATFORM_PROFILE_COOL;
1196                 break;
1197         default:
1198                 return -EINVAL;
1199         }
1200
1201         return 0;
1202 }
1203
1204 static int platform_profile_omen_set(struct platform_profile_handler *pprof,
1205                                      enum platform_profile_option profile)
1206 {
1207         int err, tp, tp_version;
1208
1209         tp_version = omen_get_thermal_policy_version();
1210
1211         if (tp_version < 0 || tp_version > 1)
1212                 return -EOPNOTSUPP;
1213
1214         switch (profile) {
1215         case PLATFORM_PROFILE_PERFORMANCE:
1216                 if (tp_version == 0)
1217                         tp = HP_OMEN_V0_THERMAL_PROFILE_PERFORMANCE;
1218                 else
1219                         tp = HP_OMEN_V1_THERMAL_PROFILE_PERFORMANCE;
1220                 break;
1221         case PLATFORM_PROFILE_BALANCED:
1222                 if (tp_version == 0)
1223                         tp = HP_OMEN_V0_THERMAL_PROFILE_DEFAULT;
1224                 else
1225                         tp = HP_OMEN_V1_THERMAL_PROFILE_DEFAULT;
1226                 break;
1227         case PLATFORM_PROFILE_COOL:
1228                 if (tp_version == 0)
1229                         tp = HP_OMEN_V0_THERMAL_PROFILE_COOL;
1230                 else
1231                         tp = HP_OMEN_V1_THERMAL_PROFILE_COOL;
1232                 break;
1233         default:
1234                 return -EOPNOTSUPP;
1235         }
1236
1237         err = omen_thermal_profile_set(tp);
1238         if (err < 0)
1239                 return err;
1240
1241         return 0;
1242 }
1243
1244 static int thermal_profile_get(void)
1245 {
1246         return hp_wmi_read_int(HPWMI_THERMAL_PROFILE_QUERY);
1247 }
1248
1249 static int thermal_profile_set(int thermal_profile)
1250 {
1251         return hp_wmi_perform_query(HPWMI_THERMAL_PROFILE_QUERY, HPWMI_WRITE, &thermal_profile,
1252                                                            sizeof(thermal_profile), 0);
1253 }
1254
1255 static int hp_wmi_platform_profile_get(struct platform_profile_handler *pprof,
1256                                         enum platform_profile_option *profile)
1257 {
1258         int tp;
1259
1260         tp = thermal_profile_get();
1261         if (tp < 0)
1262                 return tp;
1263
1264         switch (tp) {
1265         case HP_THERMAL_PROFILE_PERFORMANCE:
1266                 *profile =  PLATFORM_PROFILE_PERFORMANCE;
1267                 break;
1268         case HP_THERMAL_PROFILE_DEFAULT:
1269                 *profile =  PLATFORM_PROFILE_BALANCED;
1270                 break;
1271         case HP_THERMAL_PROFILE_COOL:
1272                 *profile =  PLATFORM_PROFILE_COOL;
1273                 break;
1274         case HP_THERMAL_PROFILE_QUIET:
1275                 *profile = PLATFORM_PROFILE_QUIET;
1276                 break;
1277         default:
1278                 return -EINVAL;
1279         }
1280
1281         return 0;
1282 }
1283
1284 static int hp_wmi_platform_profile_set(struct platform_profile_handler *pprof,
1285                                         enum platform_profile_option profile)
1286 {
1287         int err, tp;
1288
1289         switch (profile) {
1290         case PLATFORM_PROFILE_PERFORMANCE:
1291                 tp =  HP_THERMAL_PROFILE_PERFORMANCE;
1292                 break;
1293         case PLATFORM_PROFILE_BALANCED:
1294                 tp =  HP_THERMAL_PROFILE_DEFAULT;
1295                 break;
1296         case PLATFORM_PROFILE_COOL:
1297                 tp =  HP_THERMAL_PROFILE_COOL;
1298                 break;
1299         case PLATFORM_PROFILE_QUIET:
1300                 tp = HP_THERMAL_PROFILE_QUIET;
1301                 break;
1302         default:
1303                 return -EOPNOTSUPP;
1304         }
1305
1306         err = thermal_profile_set(tp);
1307         if (err)
1308                 return err;
1309
1310         return 0;
1311 }
1312
1313 static bool is_victus_thermal_profile(void)
1314 {
1315         const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);
1316
1317         if (!board_name)
1318                 return false;
1319
1320         return match_string(victus_thermal_profile_boards,
1321                             ARRAY_SIZE(victus_thermal_profile_boards),
1322                             board_name) >= 0;
1323 }
1324
1325 static int platform_profile_victus_get(struct platform_profile_handler *pprof,
1326                                      enum platform_profile_option *profile)
1327 {
1328         int tp;
1329
1330         tp = omen_thermal_profile_get();
1331         if (tp < 0)
1332                 return tp;
1333
1334         switch (tp) {
1335         case HP_VICTUS_THERMAL_PROFILE_PERFORMANCE:
1336                 *profile = PLATFORM_PROFILE_PERFORMANCE;
1337                 break;
1338         case HP_VICTUS_THERMAL_PROFILE_DEFAULT:
1339                 *profile = PLATFORM_PROFILE_BALANCED;
1340                 break;
1341         case HP_VICTUS_THERMAL_PROFILE_QUIET:
1342                 *profile = PLATFORM_PROFILE_QUIET;
1343                 break;
1344         default:
1345                 return -EOPNOTSUPP;
1346         }
1347
1348         return 0;
1349 }
1350
1351 static int platform_profile_victus_set(struct platform_profile_handler *pprof,
1352                                      enum platform_profile_option profile)
1353 {
1354         int err, tp;
1355
1356         switch (profile) {
1357         case PLATFORM_PROFILE_PERFORMANCE:
1358                 tp = HP_VICTUS_THERMAL_PROFILE_PERFORMANCE;
1359                 break;
1360         case PLATFORM_PROFILE_BALANCED:
1361                 tp = HP_VICTUS_THERMAL_PROFILE_DEFAULT;
1362                 break;
1363         case PLATFORM_PROFILE_QUIET:
1364                 tp = HP_VICTUS_THERMAL_PROFILE_QUIET;
1365                 break;
1366         default:
1367                 return -EOPNOTSUPP;
1368         }
1369
1370         err = omen_thermal_profile_set(tp);
1371         if (err < 0)
1372                 return err;
1373
1374         return 0;
1375 }
1376
1377 static int thermal_profile_setup(void)
1378 {
1379         int err, tp;
1380
1381         if (is_omen_thermal_profile()) {
1382                 tp = omen_thermal_profile_get();
1383                 if (tp < 0)
1384                         return tp;
1385
1386                 /*
1387                  * call thermal profile write command to ensure that the
1388                  * firmware correctly sets the OEM variables
1389                  */
1390
1391                 err = omen_thermal_profile_set(tp);
1392                 if (err < 0)
1393                         return err;
1394
1395                 platform_profile_handler.profile_get = platform_profile_omen_get;
1396                 platform_profile_handler.profile_set = platform_profile_omen_set;
1397
1398                 set_bit(PLATFORM_PROFILE_COOL, platform_profile_handler.choices);
1399         } else if (is_victus_thermal_profile()) {
1400                 tp = omen_thermal_profile_get();
1401                 if (tp < 0)
1402                         return tp;
1403
1404                 /*
1405                  * call thermal profile write command to ensure that the
1406                  * firmware correctly sets the OEM variables
1407                  */
1408                 err = omen_thermal_profile_set(tp);
1409                 if (err < 0)
1410                         return err;
1411
1412                 platform_profile_handler.profile_get = platform_profile_victus_get;
1413                 platform_profile_handler.profile_set = platform_profile_victus_set;
1414
1415                 set_bit(PLATFORM_PROFILE_QUIET, platform_profile_handler.choices);
1416         } else {
1417                 tp = thermal_profile_get();
1418
1419                 if (tp < 0)
1420                         return tp;
1421
1422                 /*
1423                  * call thermal profile write command to ensure that the
1424                  * firmware correctly sets the OEM variables for the DPTF
1425                  */
1426                 err = thermal_profile_set(tp);
1427                 if (err)
1428                         return err;
1429
1430                 platform_profile_handler.profile_get = hp_wmi_platform_profile_get;
1431                 platform_profile_handler.profile_set = hp_wmi_platform_profile_set;
1432
1433                 set_bit(PLATFORM_PROFILE_QUIET, platform_profile_handler.choices);
1434                 set_bit(PLATFORM_PROFILE_COOL, platform_profile_handler.choices);
1435         }
1436
1437         set_bit(PLATFORM_PROFILE_BALANCED, platform_profile_handler.choices);
1438         set_bit(PLATFORM_PROFILE_PERFORMANCE, platform_profile_handler.choices);
1439
1440         err = platform_profile_register(&platform_profile_handler);
1441         if (err)
1442                 return err;
1443
1444         platform_profile_support = true;
1445
1446         return 0;
1447 }
1448
1449 static int hp_wmi_hwmon_init(void);
1450
1451 static int __init hp_wmi_bios_setup(struct platform_device *device)
1452 {
1453         int err;
1454         /* clear detected rfkill devices */
1455         wifi_rfkill = NULL;
1456         bluetooth_rfkill = NULL;
1457         wwan_rfkill = NULL;
1458         rfkill2_count = 0;
1459
1460         /*
1461          * In pre-2009 BIOS, command 1Bh return 0x4 to indicate that
1462          * BIOS no longer controls the power for the wireless
1463          * devices. All features supported by this command will no
1464          * longer be supported.
1465          */
1466         if (!hp_wmi_bios_2009_later()) {
1467                 if (hp_wmi_rfkill_setup(device))
1468                         hp_wmi_rfkill2_setup(device);
1469         }
1470
1471         err = hp_wmi_hwmon_init();
1472
1473         if (err < 0)
1474                 return err;
1475
1476         thermal_profile_setup();
1477
1478         return 0;
1479 }
1480
1481 static int __exit hp_wmi_bios_remove(struct platform_device *device)
1482 {
1483         int i;
1484
1485         for (i = 0; i < rfkill2_count; i++) {
1486                 rfkill_unregister(rfkill2[i].rfkill);
1487                 rfkill_destroy(rfkill2[i].rfkill);
1488         }
1489
1490         if (wifi_rfkill) {
1491                 rfkill_unregister(wifi_rfkill);
1492                 rfkill_destroy(wifi_rfkill);
1493         }
1494         if (bluetooth_rfkill) {
1495                 rfkill_unregister(bluetooth_rfkill);
1496                 rfkill_destroy(bluetooth_rfkill);
1497         }
1498         if (wwan_rfkill) {
1499                 rfkill_unregister(wwan_rfkill);
1500                 rfkill_destroy(wwan_rfkill);
1501         }
1502
1503         if (platform_profile_support)
1504                 platform_profile_remove();
1505
1506         return 0;
1507 }
1508
1509 static int hp_wmi_resume_handler(struct device *device)
1510 {
1511         /*
1512          * Hardware state may have changed while suspended, so trigger
1513          * input events for the current state. As this is a switch,
1514          * the input layer will only actually pass it on if the state
1515          * changed.
1516          */
1517         if (hp_wmi_input_dev) {
1518                 if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit))
1519                         input_report_switch(hp_wmi_input_dev, SW_DOCK,
1520                                             hp_wmi_get_dock_state());
1521                 if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit))
1522                         input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
1523                                             hp_wmi_get_tablet_mode());
1524                 input_sync(hp_wmi_input_dev);
1525         }
1526
1527         if (rfkill2_count)
1528                 hp_wmi_rfkill2_refresh();
1529
1530         if (wifi_rfkill)
1531                 rfkill_set_states(wifi_rfkill,
1532                                   hp_wmi_get_sw_state(HPWMI_WIFI),
1533                                   hp_wmi_get_hw_state(HPWMI_WIFI));
1534         if (bluetooth_rfkill)
1535                 rfkill_set_states(bluetooth_rfkill,
1536                                   hp_wmi_get_sw_state(HPWMI_BLUETOOTH),
1537                                   hp_wmi_get_hw_state(HPWMI_BLUETOOTH));
1538         if (wwan_rfkill)
1539                 rfkill_set_states(wwan_rfkill,
1540                                   hp_wmi_get_sw_state(HPWMI_WWAN),
1541                                   hp_wmi_get_hw_state(HPWMI_WWAN));
1542
1543         return 0;
1544 }
1545
1546 static const struct dev_pm_ops hp_wmi_pm_ops = {
1547         .resume  = hp_wmi_resume_handler,
1548         .restore  = hp_wmi_resume_handler,
1549 };
1550
1551 /*
1552  * hp_wmi_bios_remove() lives in .exit.text. For drivers registered via
1553  * module_platform_driver_probe() this is ok because they cannot get unbound at
1554  * runtime. So mark the driver struct with __refdata to prevent modpost
1555  * triggering a section mismatch warning.
1556  */
1557 static struct platform_driver hp_wmi_driver __refdata = {
1558         .driver = {
1559                 .name = "hp-wmi",
1560                 .pm = &hp_wmi_pm_ops,
1561                 .dev_groups = hp_wmi_groups,
1562         },
1563         .remove = __exit_p(hp_wmi_bios_remove),
1564 };
1565
1566 static umode_t hp_wmi_hwmon_is_visible(const void *data,
1567                                        enum hwmon_sensor_types type,
1568                                        u32 attr, int channel)
1569 {
1570         switch (type) {
1571         case hwmon_pwm:
1572                 return 0644;
1573         case hwmon_fan:
1574                 if (hp_wmi_get_fan_speed(channel) >= 0)
1575                         return 0444;
1576                 break;
1577         default:
1578                 return 0;
1579         }
1580
1581         return 0;
1582 }
1583
1584 static int hp_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
1585                              u32 attr, int channel, long *val)
1586 {
1587         int ret;
1588
1589         switch (type) {
1590         case hwmon_fan:
1591                 ret = hp_wmi_get_fan_speed(channel);
1592
1593                 if (ret < 0)
1594                         return ret;
1595                 *val = ret;
1596                 return 0;
1597         case hwmon_pwm:
1598                 switch (hp_wmi_fan_speed_max_get()) {
1599                 case 0:
1600                         /* 0 is automatic fan, which is 2 for hwmon */
1601                         *val = 2;
1602                         return 0;
1603                 case 1:
1604                         /* 1 is max fan, which is 0
1605                          * (no fan speed control) for hwmon
1606                          */
1607                         *val = 0;
1608                         return 0;
1609                 default:
1610                         /* shouldn't happen */
1611                         return -ENODATA;
1612                 }
1613         default:
1614                 return -EINVAL;
1615         }
1616 }
1617
1618 static int hp_wmi_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
1619                               u32 attr, int channel, long val)
1620 {
1621         switch (type) {
1622         case hwmon_pwm:
1623                 switch (val) {
1624                 case 0:
1625                         /* 0 is no fan speed control (max), which is 1 for us */
1626                         return hp_wmi_fan_speed_max_set(1);
1627                 case 2:
1628                         /* 2 is automatic speed control, which is 0 for us */
1629                         return hp_wmi_fan_speed_max_set(0);
1630                 default:
1631                         /* we don't support manual fan speed control */
1632                         return -EINVAL;
1633                 }
1634         default:
1635                 return -EOPNOTSUPP;
1636         }
1637 }
1638
1639 static const struct hwmon_channel_info * const info[] = {
1640         HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT, HWMON_F_INPUT),
1641         HWMON_CHANNEL_INFO(pwm, HWMON_PWM_ENABLE),
1642         NULL
1643 };
1644
1645 static const struct hwmon_ops ops = {
1646         .is_visible = hp_wmi_hwmon_is_visible,
1647         .read = hp_wmi_hwmon_read,
1648         .write = hp_wmi_hwmon_write,
1649 };
1650
1651 static const struct hwmon_chip_info chip_info = {
1652         .ops = &ops,
1653         .info = info,
1654 };
1655
1656 static int hp_wmi_hwmon_init(void)
1657 {
1658         struct device *dev = &hp_wmi_platform_dev->dev;
1659         struct device *hwmon;
1660
1661         hwmon = devm_hwmon_device_register_with_info(dev, "hp", &hp_wmi_driver,
1662                                                      &chip_info, NULL);
1663
1664         if (IS_ERR(hwmon)) {
1665                 dev_err(dev, "Could not register hp hwmon device\n");
1666                 return PTR_ERR(hwmon);
1667         }
1668
1669         return 0;
1670 }
1671
1672 static int __init hp_wmi_init(void)
1673 {
1674         int event_capable = wmi_has_guid(HPWMI_EVENT_GUID);
1675         int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);
1676         int err, tmp = 0;
1677
1678         if (!bios_capable && !event_capable)
1679                 return -ENODEV;
1680
1681         if (hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, HPWMI_READ, &tmp,
1682                                  sizeof(tmp), sizeof(tmp)) == HPWMI_RET_INVALID_PARAMETERS)
1683                 zero_insize_support = true;
1684
1685         if (event_capable) {
1686                 err = hp_wmi_input_setup();
1687                 if (err)
1688                         return err;
1689         }
1690
1691         if (bios_capable) {
1692                 hp_wmi_platform_dev =
1693                         platform_device_register_simple("hp-wmi", PLATFORM_DEVID_NONE, NULL, 0);
1694                 if (IS_ERR(hp_wmi_platform_dev)) {
1695                         err = PTR_ERR(hp_wmi_platform_dev);
1696                         goto err_destroy_input;
1697                 }
1698
1699                 err = platform_driver_probe(&hp_wmi_driver, hp_wmi_bios_setup);
1700                 if (err)
1701                         goto err_unregister_device;
1702         }
1703
1704         return 0;
1705
1706 err_unregister_device:
1707         platform_device_unregister(hp_wmi_platform_dev);
1708 err_destroy_input:
1709         if (event_capable)
1710                 hp_wmi_input_destroy();
1711
1712         return err;
1713 }
1714 module_init(hp_wmi_init);
1715
1716 static void __exit hp_wmi_exit(void)
1717 {
1718         if (wmi_has_guid(HPWMI_EVENT_GUID))
1719                 hp_wmi_input_destroy();
1720
1721         if (camera_shutter_input_dev)
1722                 input_unregister_device(camera_shutter_input_dev);
1723
1724         if (hp_wmi_platform_dev) {
1725                 platform_device_unregister(hp_wmi_platform_dev);
1726                 platform_driver_unregister(&hp_wmi_driver);
1727         }
1728 }
1729 module_exit(hp_wmi_exit);