xref: /openbmc/linux/drivers/platform/x86/hp/hp-wmi.c (revision 5b44abbc)
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 */
encode_outsize_for_pvsz(int outsize)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  */
hp_wmi_perform_query(int query,enum hp_wmi_command command,void * buffer,int insize,int outsize)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 
hp_wmi_get_fan_speed(int fan)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 
hp_wmi_read_int(int query)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 
hp_wmi_get_dock_state(void)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 
hp_wmi_get_tablet_mode(void)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 
omen_thermal_profile_set(int mode)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 
is_omen_thermal_profile(void)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 
omen_get_thermal_policy_version(void)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 
omen_thermal_profile_get(void)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 
hp_wmi_fan_speed_max_set(int enabled)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 
hp_wmi_fan_speed_max_get(void)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 
hp_wmi_bios_2008_later(void)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 
hp_wmi_bios_2009_later(void)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 
hp_wmi_enable_hotkeys(void)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 
hp_wmi_set_block(void * data,bool blocked)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 
hp_wmi_get_sw_state(enum hp_wmi_radio r)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 
hp_wmi_get_hw_state(enum hp_wmi_radio r)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 
hp_wmi_rfkill2_set_block(void * data,bool blocked)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 
hp_wmi_rfkill2_refresh(void)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 
display_show(struct device * dev,struct device_attribute * attr,char * buf)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 
hddtemp_show(struct device * dev,struct device_attribute * attr,char * buf)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 
als_show(struct device * dev,struct device_attribute * attr,char * buf)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 
dock_show(struct device * dev,struct device_attribute * attr,char * buf)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 
tablet_show(struct device * dev,struct device_attribute * attr,char * buf)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 
postcode_show(struct device * dev,struct device_attribute * attr,char * buf)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 
als_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 
postcode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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 
camera_shutter_input_setup(void)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 
hp_wmi_notify(u32 value,void * context)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 
hp_wmi_input_setup(void)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 
hp_wmi_input_destroy(void)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 
hp_wmi_rfkill_setup(struct platform_device * device)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 
hp_wmi_rfkill2_setup(struct platform_device * device)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 
platform_profile_omen_get(struct platform_profile_handler * pprof,enum platform_profile_option * profile)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 
platform_profile_omen_set(struct platform_profile_handler * pprof,enum platform_profile_option profile)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 
thermal_profile_get(void)1244 static int thermal_profile_get(void)
1245 {
1246 	return hp_wmi_read_int(HPWMI_THERMAL_PROFILE_QUERY);
1247 }
1248 
thermal_profile_set(int thermal_profile)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 
hp_wmi_platform_profile_get(struct platform_profile_handler * pprof,enum platform_profile_option * profile)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 
hp_wmi_platform_profile_set(struct platform_profile_handler * pprof,enum platform_profile_option profile)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 
is_victus_thermal_profile(void)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 
platform_profile_victus_get(struct platform_profile_handler * pprof,enum platform_profile_option * profile)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 
platform_profile_victus_set(struct platform_profile_handler * pprof,enum platform_profile_option profile)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 
thermal_profile_setup(void)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 
hp_wmi_bios_setup(struct platform_device * device)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 
hp_wmi_bios_remove(struct platform_device * device)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 
hp_wmi_resume_handler(struct device * device)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 
hp_wmi_hwmon_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)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 
hp_wmi_hwmon_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)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 
hp_wmi_hwmon_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)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 
hp_wmi_hwmon_init(void)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 
hp_wmi_init(void)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 
hp_wmi_exit(void)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);
1730