aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/ABI/testing/sysfs-platform-dell-laptop60
-rw-r--r--drivers/platform/x86/dell-laptop.c1055
2 files changed, 6 insertions, 1109 deletions
diff --git a/Documentation/ABI/testing/sysfs-platform-dell-laptop b/Documentation/ABI/testing/sysfs-platform-dell-laptop
deleted file mode 100644
index 7969443ef0ef..000000000000
--- a/Documentation/ABI/testing/sysfs-platform-dell-laptop
+++ /dev/null
@@ -1,60 +0,0 @@
1What: /sys/class/leds/dell::kbd_backlight/als_setting
2Date: December 2014
3KernelVersion: 3.19
4Contact: Gabriele Mazzotta <gabriele.mzt@gmail.com>,
5 Pali Rohár <pali.rohar@gmail.com>
6Description:
7 This file allows to control the automatic keyboard
8 illumination mode on some systems that have an ambient
9 light sensor. Write 1 to this file to enable the auto
10 mode, 0 to disable it.
11
12What: /sys/class/leds/dell::kbd_backlight/start_triggers
13Date: December 2014
14KernelVersion: 3.19
15Contact: Gabriele Mazzotta <gabriele.mzt@gmail.com>,
16 Pali Rohár <pali.rohar@gmail.com>
17Description:
18 This file allows to control the input triggers that
19 turn on the keyboard backlight illumination that is
20 disabled because of inactivity.
21 Read the file to see the triggers available. The ones
22 enabled are preceded by '+', those disabled by '-'.
23
24 To enable a trigger, write its name preceded by '+' to
25 this file. To disable a trigger, write its name preceded
26 by '-' instead.
27
28 For example, to enable the keyboard as trigger run:
29 echo +keyboard > /sys/class/leds/dell::kbd_backlight/start_triggers
30 To disable it:
31 echo -keyboard > /sys/class/leds/dell::kbd_backlight/start_triggers
32
33 Note that not all the available triggers can be configured.
34
35What: /sys/class/leds/dell::kbd_backlight/stop_timeout
36Date: December 2014
37KernelVersion: 3.19
38Contact: Gabriele Mazzotta <gabriele.mzt@gmail.com>,
39 Pali Rohár <pali.rohar@gmail.com>
40Description:
41 This file allows to specify the interval after which the
42 keyboard illumination is disabled because of inactivity.
43 The timeouts are expressed in seconds, minutes, hours and
44 days, for which the symbols are 's', 'm', 'h' and 'd'
45 respectively.
46
47 To configure the timeout, write to this file a value along
48 with any the above units. If no unit is specified, the value
49 is assumed to be expressed in seconds.
50
51 For example, to set the timeout to 10 minutes run:
52 echo 10m > /sys/class/leds/dell::kbd_backlight/stop_timeout
53
54 Note that when this file is read, the returned value might be
55 expressed in a different unit than the one used when the timeout
56 was set.
57
58 Also note that only some timeouts are supported and that
59 some systems might fall back to a specific timeout in case
60 an invalid timeout is written to this file.
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index 9411eae39a4e..3d21efe11d7b 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -2,11 +2,9 @@
2 * Driver for Dell laptop extras 2 * Driver for Dell laptop extras
3 * 3 *
4 * Copyright (c) Red Hat <mjg@redhat.com> 4 * Copyright (c) Red Hat <mjg@redhat.com>
5 * Copyright (c) 2014 Gabriele Mazzotta <gabriele.mzt@gmail.com>
6 * Copyright (c) 2014 Pali Rohár <pali.rohar@gmail.com>
7 * 5 *
8 * Based on documentation in the libsmbios package: 6 * Based on documentation in the libsmbios package, Copyright (C) 2005 Dell
9 * Copyright (C) 2005-2014 Dell Inc. 7 * Inc.
10 * 8 *
11 * This program is free software; you can redistribute it and/or modify 9 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as 10 * it under the terms of the GNU General Public License version 2 as
@@ -34,13 +32,6 @@
34#include "../../firmware/dcdbas.h" 32#include "../../firmware/dcdbas.h"
35 33
36#define BRIGHTNESS_TOKEN 0x7d 34#define BRIGHTNESS_TOKEN 0x7d
37#define KBD_LED_OFF_TOKEN 0x01E1
38#define KBD_LED_ON_TOKEN 0x01E2
39#define KBD_LED_AUTO_TOKEN 0x01E3
40#define KBD_LED_AUTO_25_TOKEN 0x02EA
41#define KBD_LED_AUTO_50_TOKEN 0x02EB
42#define KBD_LED_AUTO_75_TOKEN 0x02EC
43#define KBD_LED_AUTO_100_TOKEN 0x02F6
44 35
45/* This structure will be modified by the firmware when we enter 36/* This structure will be modified by the firmware when we enter
46 * system management mode, hence the volatiles */ 37 * system management mode, hence the volatiles */
@@ -71,13 +62,6 @@ struct calling_interface_structure {
71 62
72struct quirk_entry { 63struct quirk_entry {
73 u8 touchpad_led; 64 u8 touchpad_led;
74
75 int needs_kbd_timeouts;
76 /*
77 * Ordered list of timeouts expressed in seconds.
78 * The list must end with -1
79 */
80 int kbd_timeouts[];
81}; 65};
82 66
83static struct quirk_entry *quirks; 67static struct quirk_entry *quirks;
@@ -92,15 +76,6 @@ static int __init dmi_matched(const struct dmi_system_id *dmi)
92 return 1; 76 return 1;
93} 77}
94 78
95/*
96 * These values come from Windows utility provided by Dell. If any other value
97 * is used then BIOS silently set timeout to 0 without any error message.
98 */
99static struct quirk_entry quirk_dell_xps13_9333 = {
100 .needs_kbd_timeouts = 1,
101 .kbd_timeouts = { 0, 5, 15, 60, 5 * 60, 15 * 60, -1 },
102};
103
104static int da_command_address; 79static int da_command_address;
105static int da_command_code; 80static int da_command_code;
106static int da_num_tokens; 81static int da_num_tokens;
@@ -292,15 +267,6 @@ static const struct dmi_system_id dell_quirks[] __initconst = {
292 }, 267 },
293 .driver_data = &quirk_dell_vostro_v130, 268 .driver_data = &quirk_dell_vostro_v130,
294 }, 269 },
295 {
296 .callback = dmi_matched,
297 .ident = "Dell XPS13 9333",
298 .matches = {
299 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
300 DMI_MATCH(DMI_PRODUCT_NAME, "XPS13 9333"),
301 },
302 .driver_data = &quirk_dell_xps13_9333,
303 },
304 { } 270 { }
305}; 271};
306 272
@@ -365,29 +331,17 @@ static void __init find_tokens(const struct dmi_header *dm, void *dummy)
365 } 331 }
366} 332}
367 333
368static int find_token_id(int tokenid) 334static int find_token_location(int tokenid)
369{ 335{
370 int i; 336 int i;
371
372 for (i = 0; i < da_num_tokens; i++) { 337 for (i = 0; i < da_num_tokens; i++) {
373 if (da_tokens[i].tokenID == tokenid) 338 if (da_tokens[i].tokenID == tokenid)
374 return i; 339 return da_tokens[i].location;
375 } 340 }
376 341
377 return -1; 342 return -1;
378} 343}
379 344
380static int find_token_location(int tokenid)
381{
382 int id;
383
384 id = find_token_id(tokenid);
385 if (id == -1)
386 return -1;
387
388 return da_tokens[id].location;
389}
390
391static struct calling_interface_buffer * 345static struct calling_interface_buffer *
392dell_send_request(struct calling_interface_buffer *buffer, int class, 346dell_send_request(struct calling_interface_buffer *buffer, int class,
393 int select) 347 int select)
@@ -408,20 +362,6 @@ dell_send_request(struct calling_interface_buffer *buffer, int class,
408 return buffer; 362 return buffer;
409} 363}
410 364
411static inline int dell_smi_error(int value)
412{
413 switch (value) {
414 case 0: /* Completed successfully */
415 return 0;
416 case -1: /* Completed with error */
417 return -EIO;
418 case -2: /* Function not supported */
419 return -ENXIO;
420 default: /* Unknown error */
421 return -EINVAL;
422 }
423}
424
425/* Derived from information in DellWirelessCtl.cpp: 365/* Derived from information in DellWirelessCtl.cpp:
426 Class 17, select 11 is radio control. It returns an array of 32-bit values. 366 Class 17, select 11 is radio control. It returns an array of 32-bit values.
427 367
@@ -776,7 +716,7 @@ static int dell_send_intensity(struct backlight_device *bd)
776 else 716 else
777 dell_send_request(buffer, 1, 1); 717 dell_send_request(buffer, 1, 1);
778 718
779 out: 719out:
780 release_buffer(); 720 release_buffer();
781 return ret; 721 return ret;
782} 722}
@@ -800,7 +740,7 @@ static int dell_get_intensity(struct backlight_device *bd)
800 740
801 ret = buffer->output[1]; 741 ret = buffer->output[1];
802 742
803 out: 743out:
804 release_buffer(); 744 release_buffer();
805 return ret; 745 return ret;
806} 746}
@@ -849,984 +789,6 @@ static void touchpad_led_exit(void)
849 led_classdev_unregister(&touchpad_led); 789 led_classdev_unregister(&touchpad_led);
850} 790}
851 791
852/*
853 * Derived from information in smbios-keyboard-ctl:
854 *
855 * cbClass 4
856 * cbSelect 11
857 * Keyboard illumination
858 * cbArg1 determines the function to be performed
859 *
860 * cbArg1 0x0 = Get Feature Information
861 * cbRES1 Standard return codes (0, -1, -2)
862 * cbRES2, word0 Bitmap of user-selectable modes
863 * bit 0 Always off (All systems)
864 * bit 1 Always on (Travis ATG, Siberia)
865 * bit 2 Auto: ALS-based On; ALS-based Off (Travis ATG)
866 * bit 3 Auto: ALS- and input-activity-based On; input-activity based Off
867 * bit 4 Auto: Input-activity-based On; input-activity based Off
868 * bit 5 Auto: Input-activity-based On (illumination level 25%); input-activity based Off
869 * bit 6 Auto: Input-activity-based On (illumination level 50%); input-activity based Off
870 * bit 7 Auto: Input-activity-based On (illumination level 75%); input-activity based Off
871 * bit 8 Auto: Input-activity-based On (illumination level 100%); input-activity based Off
872 * bits 9-15 Reserved for future use
873 * cbRES2, byte2 Reserved for future use
874 * cbRES2, byte3 Keyboard illumination type
875 * 0 Reserved
876 * 1 Tasklight
877 * 2 Backlight
878 * 3-255 Reserved for future use
879 * cbRES3, byte0 Supported auto keyboard illumination trigger bitmap.
880 * bit 0 Any keystroke
881 * bit 1 Touchpad activity
882 * bit 2 Pointing stick
883 * bit 3 Any mouse
884 * bits 4-7 Reserved for future use
885 * cbRES3, byte1 Supported timeout unit bitmap
886 * bit 0 Seconds
887 * bit 1 Minutes
888 * bit 2 Hours
889 * bit 3 Days
890 * bits 4-7 Reserved for future use
891 * cbRES3, byte2 Number of keyboard light brightness levels
892 * cbRES4, byte0 Maximum acceptable seconds value (0 if seconds not supported).
893 * cbRES4, byte1 Maximum acceptable minutes value (0 if minutes not supported).
894 * cbRES4, byte2 Maximum acceptable hours value (0 if hours not supported).
895 * cbRES4, byte3 Maximum acceptable days value (0 if days not supported)
896 *
897 * cbArg1 0x1 = Get Current State
898 * cbRES1 Standard return codes (0, -1, -2)
899 * cbRES2, word0 Bitmap of current mode state
900 * bit 0 Always off (All systems)
901 * bit 1 Always on (Travis ATG, Siberia)
902 * bit 2 Auto: ALS-based On; ALS-based Off (Travis ATG)
903 * bit 3 Auto: ALS- and input-activity-based On; input-activity based Off
904 * bit 4 Auto: Input-activity-based On; input-activity based Off
905 * bit 5 Auto: Input-activity-based On (illumination level 25%); input-activity based Off
906 * bit 6 Auto: Input-activity-based On (illumination level 50%); input-activity based Off
907 * bit 7 Auto: Input-activity-based On (illumination level 75%); input-activity based Off
908 * bit 8 Auto: Input-activity-based On (illumination level 100%); input-activity based Off
909 * bits 9-15 Reserved for future use
910 * Note: Only One bit can be set
911 * cbRES2, byte2 Currently active auto keyboard illumination triggers.
912 * bit 0 Any keystroke
913 * bit 1 Touchpad activity
914 * bit 2 Pointing stick
915 * bit 3 Any mouse
916 * bits 4-7 Reserved for future use
917 * cbRES2, byte3 Current Timeout
918 * bits 7:6 Timeout units indicator:
919 * 00b Seconds
920 * 01b Minutes
921 * 10b Hours
922 * 11b Days
923 * bits 5:0 Timeout value (0-63) in sec/min/hr/day
924 * NOTE: A value of 0 means always on (no timeout) if any bits of RES3 byte
925 * are set upon return from the [Get feature information] call.
926 * cbRES3, byte0 Current setting of ALS value that turns the light on or off.
927 * cbRES3, byte1 Current ALS reading
928 * cbRES3, byte2 Current keyboard light level.
929 *
930 * cbArg1 0x2 = Set New State
931 * cbRES1 Standard return codes (0, -1, -2)
932 * cbArg2, word0 Bitmap of current mode state
933 * bit 0 Always off (All systems)
934 * bit 1 Always on (Travis ATG, Siberia)
935 * bit 2 Auto: ALS-based On; ALS-based Off (Travis ATG)
936 * bit 3 Auto: ALS- and input-activity-based On; input-activity based Off
937 * bit 4 Auto: Input-activity-based On; input-activity based Off
938 * bit 5 Auto: Input-activity-based On (illumination level 25%); input-activity based Off
939 * bit 6 Auto: Input-activity-based On (illumination level 50%); input-activity based Off
940 * bit 7 Auto: Input-activity-based On (illumination level 75%); input-activity based Off
941 * bit 8 Auto: Input-activity-based On (illumination level 100%); input-activity based Off
942 * bits 9-15 Reserved for future use
943 * Note: Only One bit can be set
944 * cbArg2, byte2 Desired auto keyboard illumination triggers. Must remain inactive to allow
945 * keyboard to turn off automatically.
946 * bit 0 Any keystroke
947 * bit 1 Touchpad activity
948 * bit 2 Pointing stick
949 * bit 3 Any mouse
950 * bits 4-7 Reserved for future use
951 * cbArg2, byte3 Desired Timeout
952 * bits 7:6 Timeout units indicator:
953 * 00b Seconds
954 * 01b Minutes
955 * 10b Hours
956 * 11b Days
957 * bits 5:0 Timeout value (0-63) in sec/min/hr/day
958 * cbArg3, byte0 Desired setting of ALS value that turns the light on or off.
959 * cbArg3, byte2 Desired keyboard light level.
960 */
961
962
963enum kbd_timeout_unit {
964 KBD_TIMEOUT_SECONDS = 0,
965 KBD_TIMEOUT_MINUTES,
966 KBD_TIMEOUT_HOURS,
967 KBD_TIMEOUT_DAYS,
968};
969
970enum kbd_mode_bit {
971 KBD_MODE_BIT_OFF = 0,
972 KBD_MODE_BIT_ON,
973 KBD_MODE_BIT_ALS,
974 KBD_MODE_BIT_TRIGGER_ALS,
975 KBD_MODE_BIT_TRIGGER,
976 KBD_MODE_BIT_TRIGGER_25,
977 KBD_MODE_BIT_TRIGGER_50,
978 KBD_MODE_BIT_TRIGGER_75,
979 KBD_MODE_BIT_TRIGGER_100,
980};
981
982#define kbd_is_als_mode_bit(bit) \
983 ((bit) == KBD_MODE_BIT_ALS || (bit) == KBD_MODE_BIT_TRIGGER_ALS)
984#define kbd_is_trigger_mode_bit(bit) \
985 ((bit) >= KBD_MODE_BIT_TRIGGER_ALS && (bit) <= KBD_MODE_BIT_TRIGGER_100)
986#define kbd_is_level_mode_bit(bit) \
987 ((bit) >= KBD_MODE_BIT_TRIGGER_25 && (bit) <= KBD_MODE_BIT_TRIGGER_100)
988
989struct kbd_info {
990 u16 modes;
991 u8 type;
992 u8 triggers;
993 u8 levels;
994 u8 seconds;
995 u8 minutes;
996 u8 hours;
997 u8 days;
998};
999
1000struct kbd_state {
1001 u8 mode_bit;
1002 u8 triggers;
1003 u8 timeout_value;
1004 u8 timeout_unit;
1005 u8 als_setting;
1006 u8 als_value;
1007 u8 level;
1008};
1009
1010static const int kbd_tokens[] = {
1011 KBD_LED_OFF_TOKEN,
1012 KBD_LED_AUTO_25_TOKEN,
1013 KBD_LED_AUTO_50_TOKEN,
1014 KBD_LED_AUTO_75_TOKEN,
1015 KBD_LED_AUTO_100_TOKEN,
1016 KBD_LED_ON_TOKEN,
1017};
1018
1019static u16 kbd_token_bits;
1020
1021static struct kbd_info kbd_info;
1022static bool kbd_als_supported;
1023static bool kbd_triggers_supported;
1024
1025static u8 kbd_mode_levels[16];
1026static int kbd_mode_levels_count;
1027
1028static u8 kbd_previous_level;
1029static u8 kbd_previous_mode_bit;
1030
1031static bool kbd_led_present;
1032
1033/*
1034 * NOTE: there are three ways to set the keyboard backlight level.
1035 * First, via kbd_state.mode_bit (assigning KBD_MODE_BIT_TRIGGER_* value).
1036 * Second, via kbd_state.level (assigning numerical value <= kbd_info.levels).
1037 * Third, via SMBIOS tokens (KBD_LED_* in kbd_tokens)
1038 *
1039 * There are laptops which support only one of these methods. If we want to
1040 * support as many machines as possible we need to implement all three methods.
1041 * The first two methods use the kbd_state structure. The third uses SMBIOS
1042 * tokens. If kbd_info.levels == 0, the machine does not support setting the
1043 * keyboard backlight level via kbd_state.level.
1044 */
1045
1046static int kbd_get_info(struct kbd_info *info)
1047{
1048 u8 units;
1049 int ret;
1050
1051 get_buffer();
1052
1053 buffer->input[0] = 0x0;
1054 dell_send_request(buffer, 4, 11);
1055 ret = buffer->output[0];
1056
1057 if (ret) {
1058 ret = dell_smi_error(ret);
1059 goto out;
1060 }
1061
1062 info->modes = buffer->output[1] & 0xFFFF;
1063 info->type = (buffer->output[1] >> 24) & 0xFF;
1064 info->triggers = buffer->output[2] & 0xFF;
1065 units = (buffer->output[2] >> 8) & 0xFF;
1066 info->levels = (buffer->output[2] >> 16) & 0xFF;
1067
1068 if (units & BIT(0))
1069 info->seconds = (buffer->output[3] >> 0) & 0xFF;
1070 if (units & BIT(1))
1071 info->minutes = (buffer->output[3] >> 8) & 0xFF;
1072 if (units & BIT(2))
1073 info->hours = (buffer->output[3] >> 16) & 0xFF;
1074 if (units & BIT(3))
1075 info->days = (buffer->output[3] >> 24) & 0xFF;
1076
1077 out:
1078 release_buffer();
1079 return ret;
1080}
1081
1082static unsigned int kbd_get_max_level(void)
1083{
1084 if (kbd_info.levels != 0)
1085 return kbd_info.levels;
1086 if (kbd_mode_levels_count > 0)
1087 return kbd_mode_levels_count - 1;
1088 return 0;
1089}
1090
1091static int kbd_get_level(struct kbd_state *state)
1092{
1093 int i;
1094
1095 if (kbd_info.levels != 0)
1096 return state->level;
1097
1098 if (kbd_mode_levels_count > 0) {
1099 for (i = 0; i < kbd_mode_levels_count; ++i)
1100 if (kbd_mode_levels[i] == state->mode_bit)
1101 return i;
1102 return 0;
1103 }
1104
1105 return -EINVAL;
1106}
1107
1108static int kbd_set_level(struct kbd_state *state, u8 level)
1109{
1110 if (kbd_info.levels != 0) {
1111 if (level != 0)
1112 kbd_previous_level = level;
1113 if (state->level == level)
1114 return 0;
1115 state->level = level;
1116 if (level != 0 && state->mode_bit == KBD_MODE_BIT_OFF)
1117 state->mode_bit = kbd_previous_mode_bit;
1118 else if (level == 0 && state->mode_bit != KBD_MODE_BIT_OFF) {
1119 kbd_previous_mode_bit = state->mode_bit;
1120 state->mode_bit = KBD_MODE_BIT_OFF;
1121 }
1122 return 0;
1123 }
1124
1125 if (kbd_mode_levels_count > 0 && level < kbd_mode_levels_count) {
1126 if (level != 0)
1127 kbd_previous_level = level;
1128 state->mode_bit = kbd_mode_levels[level];
1129 return 0;
1130 }
1131
1132 return -EINVAL;
1133}
1134
1135static int kbd_get_state(struct kbd_state *state)
1136{
1137 int ret;
1138
1139 get_buffer();
1140
1141 buffer->input[0] = 0x1;
1142 dell_send_request(buffer, 4, 11);
1143 ret = buffer->output[0];
1144
1145 if (ret) {
1146 ret = dell_smi_error(ret);
1147 goto out;
1148 }
1149
1150 state->mode_bit = ffs(buffer->output[1] & 0xFFFF);
1151 if (state->mode_bit != 0)
1152 state->mode_bit--;
1153
1154 state->triggers = (buffer->output[1] >> 16) & 0xFF;
1155 state->timeout_value = (buffer->output[1] >> 24) & 0x3F;
1156 state->timeout_unit = (buffer->output[1] >> 30) & 0x3;
1157 state->als_setting = buffer->output[2] & 0xFF;
1158 state->als_value = (buffer->output[2] >> 8) & 0xFF;
1159 state->level = (buffer->output[2] >> 16) & 0xFF;
1160
1161 out:
1162 release_buffer();
1163 return ret;
1164}
1165
1166static int kbd_set_state(struct kbd_state *state)
1167{
1168 int ret;
1169
1170 get_buffer();
1171 buffer->input[0] = 0x2;
1172 buffer->input[1] = BIT(state->mode_bit) & 0xFFFF;
1173 buffer->input[1] |= (state->triggers & 0xFF) << 16;
1174 buffer->input[1] |= (state->timeout_value & 0x3F) << 24;
1175 buffer->input[1] |= (state->timeout_unit & 0x3) << 30;
1176 buffer->input[2] = state->als_setting & 0xFF;
1177 buffer->input[2] |= (state->level & 0xFF) << 16;
1178 dell_send_request(buffer, 4, 11);
1179 ret = buffer->output[0];
1180 release_buffer();
1181
1182 return dell_smi_error(ret);
1183}
1184
1185static int kbd_set_state_safe(struct kbd_state *state, struct kbd_state *old)
1186{
1187 int ret;
1188
1189 ret = kbd_set_state(state);
1190 if (ret == 0)
1191 return 0;
1192
1193 /*
1194 * When setting the new state fails,try to restore the previous one.
1195 * This is needed on some machines where BIOS sets a default state when
1196 * setting a new state fails. This default state could be all off.
1197 */
1198
1199 if (kbd_set_state(old))
1200 pr_err("Setting old previous keyboard state failed\n");
1201
1202 return ret;
1203}
1204
1205static int kbd_set_token_bit(u8 bit)
1206{
1207 int id;
1208 int ret;
1209
1210 if (bit >= ARRAY_SIZE(kbd_tokens))
1211 return -EINVAL;
1212
1213 id = find_token_id(kbd_tokens[bit]);
1214 if (id == -1)
1215 return -EINVAL;
1216
1217 get_buffer();
1218 buffer->input[0] = da_tokens[id].location;
1219 buffer->input[1] = da_tokens[id].value;
1220 dell_send_request(buffer, 1, 0);
1221 ret = buffer->output[0];
1222 release_buffer();
1223
1224 return dell_smi_error(ret);
1225}
1226
1227static int kbd_get_token_bit(u8 bit)
1228{
1229 int id;
1230 int ret;
1231 int val;
1232
1233 if (bit >= ARRAY_SIZE(kbd_tokens))
1234 return -EINVAL;
1235
1236 id = find_token_id(kbd_tokens[bit]);
1237 if (id == -1)
1238 return -EINVAL;
1239
1240 get_buffer();
1241 buffer->input[0] = da_tokens[id].location;
1242 dell_send_request(buffer, 0, 0);
1243 ret = buffer->output[0];
1244 val = buffer->output[1];
1245 release_buffer();
1246
1247 if (ret)
1248 return dell_smi_error(ret);
1249
1250 return (val == da_tokens[id].value);
1251}
1252
1253static int kbd_get_first_active_token_bit(void)
1254{
1255 int i;
1256 int ret;
1257
1258 for (i = 0; i < ARRAY_SIZE(kbd_tokens); ++i) {
1259 ret = kbd_get_token_bit(i);
1260 if (ret == 1)
1261 return i;
1262 }
1263
1264 return ret;
1265}
1266
1267static int kbd_get_valid_token_counts(void)
1268{
1269 return hweight16(kbd_token_bits);
1270}
1271
1272static inline int kbd_init_info(void)
1273{
1274 struct kbd_state state;
1275 int ret;
1276 int i;
1277
1278 ret = kbd_get_info(&kbd_info);
1279 if (ret)
1280 return ret;
1281
1282 kbd_get_state(&state);
1283
1284 /* NOTE: timeout value is stored in 6 bits so max value is 63 */
1285 if (kbd_info.seconds > 63)
1286 kbd_info.seconds = 63;
1287 if (kbd_info.minutes > 63)
1288 kbd_info.minutes = 63;
1289 if (kbd_info.hours > 63)
1290 kbd_info.hours = 63;
1291 if (kbd_info.days > 63)
1292 kbd_info.days = 63;
1293
1294 /* NOTE: On tested machines ON mode did not work and caused
1295 * problems (turned backlight off) so do not use it
1296 */
1297 kbd_info.modes &= ~BIT(KBD_MODE_BIT_ON);
1298
1299 kbd_previous_level = kbd_get_level(&state);
1300 kbd_previous_mode_bit = state.mode_bit;
1301
1302 if (kbd_previous_level == 0 && kbd_get_max_level() != 0)
1303 kbd_previous_level = 1;
1304
1305 if (kbd_previous_mode_bit == KBD_MODE_BIT_OFF) {
1306 kbd_previous_mode_bit =
1307 ffs(kbd_info.modes & ~BIT(KBD_MODE_BIT_OFF));
1308 if (kbd_previous_mode_bit != 0)
1309 kbd_previous_mode_bit--;
1310 }
1311
1312 if (kbd_info.modes & (BIT(KBD_MODE_BIT_ALS) |
1313 BIT(KBD_MODE_BIT_TRIGGER_ALS)))
1314 kbd_als_supported = true;
1315
1316 if (kbd_info.modes & (
1317 BIT(KBD_MODE_BIT_TRIGGER_ALS) | BIT(KBD_MODE_BIT_TRIGGER) |
1318 BIT(KBD_MODE_BIT_TRIGGER_25) | BIT(KBD_MODE_BIT_TRIGGER_50) |
1319 BIT(KBD_MODE_BIT_TRIGGER_75) | BIT(KBD_MODE_BIT_TRIGGER_100)
1320 ))
1321 kbd_triggers_supported = true;
1322
1323 /* kbd_mode_levels[0] is reserved, see below */
1324 for (i = 0; i < 16; ++i)
1325 if (kbd_is_level_mode_bit(i) && (BIT(i) & kbd_info.modes))
1326 kbd_mode_levels[1 + kbd_mode_levels_count++] = i;
1327
1328 /*
1329 * Find the first supported mode and assign to kbd_mode_levels[0].
1330 * This should be 0 (off), but we cannot depend on the BIOS to
1331 * support 0.
1332 */
1333 if (kbd_mode_levels_count > 0) {
1334 for (i = 0; i < 16; ++i) {
1335 if (BIT(i) & kbd_info.modes) {
1336 kbd_mode_levels[0] = i;
1337 break;
1338 }
1339 }
1340 kbd_mode_levels_count++;
1341 }
1342
1343 return 0;
1344
1345}
1346
1347static inline void kbd_init_tokens(void)
1348{
1349 int i;
1350
1351 for (i = 0; i < ARRAY_SIZE(kbd_tokens); ++i)
1352 if (find_token_id(kbd_tokens[i]) != -1)
1353 kbd_token_bits |= BIT(i);
1354}
1355
1356static void kbd_init(void)
1357{
1358 int ret;
1359
1360 ret = kbd_init_info();
1361 kbd_init_tokens();
1362
1363 if (kbd_token_bits != 0 || ret == 0)
1364 kbd_led_present = true;
1365}
1366
1367static ssize_t kbd_led_timeout_store(struct device *dev,
1368 struct device_attribute *attr,
1369 const char *buf, size_t count)
1370{
1371 struct kbd_state new_state;
1372 struct kbd_state state;
1373 bool convert;
1374 int value;
1375 int ret;
1376 char ch;
1377 u8 unit;
1378 int i;
1379
1380 ret = sscanf(buf, "%d %c", &value, &ch);
1381 if (ret < 1)
1382 return -EINVAL;
1383 else if (ret == 1)
1384 ch = 's';
1385
1386 if (value < 0)
1387 return -EINVAL;
1388
1389 convert = false;
1390
1391 switch (ch) {
1392 case 's':
1393 if (value > kbd_info.seconds)
1394 convert = true;
1395 unit = KBD_TIMEOUT_SECONDS;
1396 break;
1397 case 'm':
1398 if (value > kbd_info.minutes)
1399 convert = true;
1400 unit = KBD_TIMEOUT_MINUTES;
1401 break;
1402 case 'h':
1403 if (value > kbd_info.hours)
1404 convert = true;
1405 unit = KBD_TIMEOUT_HOURS;
1406 break;
1407 case 'd':
1408 if (value > kbd_info.days)
1409 convert = true;
1410 unit = KBD_TIMEOUT_DAYS;
1411 break;
1412 default:
1413 return -EINVAL;
1414 }
1415
1416 if (quirks && quirks->needs_kbd_timeouts)
1417 convert = true;
1418
1419 if (convert) {
1420 /* Convert value from current units to seconds */
1421 switch (unit) {
1422 case KBD_TIMEOUT_DAYS:
1423 value *= 24;
1424 case KBD_TIMEOUT_HOURS:
1425 value *= 60;
1426 case KBD_TIMEOUT_MINUTES:
1427 value *= 60;
1428 unit = KBD_TIMEOUT_SECONDS;
1429 }
1430
1431 if (quirks && quirks->needs_kbd_timeouts) {
1432 for (i = 0; quirks->kbd_timeouts[i] != -1; i++) {
1433 if (value <= quirks->kbd_timeouts[i]) {
1434 value = quirks->kbd_timeouts[i];
1435 break;
1436 }
1437 }
1438 }
1439
1440 if (value <= kbd_info.seconds && kbd_info.seconds) {
1441 unit = KBD_TIMEOUT_SECONDS;
1442 } else if (value / 60 <= kbd_info.minutes && kbd_info.minutes) {
1443 value /= 60;
1444 unit = KBD_TIMEOUT_MINUTES;
1445 } else if (value / (60 * 60) <= kbd_info.hours && kbd_info.hours) {
1446 value /= (60 * 60);
1447 unit = KBD_TIMEOUT_HOURS;
1448 } else if (value / (60 * 60 * 24) <= kbd_info.days && kbd_info.days) {
1449 value /= (60 * 60 * 24);
1450 unit = KBD_TIMEOUT_DAYS;
1451 } else {
1452 return -EINVAL;
1453 }
1454 }
1455
1456 ret = kbd_get_state(&state);
1457 if (ret)
1458 return ret;
1459
1460 new_state = state;
1461 new_state.timeout_value = value;
1462 new_state.timeout_unit = unit;
1463
1464 ret = kbd_set_state_safe(&new_state, &state);
1465 if (ret)
1466 return ret;
1467
1468 return count;
1469}
1470
1471static ssize_t kbd_led_timeout_show(struct device *dev,
1472 struct device_attribute *attr, char *buf)
1473{
1474 struct kbd_state state;
1475 int ret;
1476 int len;
1477
1478 ret = kbd_get_state(&state);
1479 if (ret)
1480 return ret;
1481
1482 len = sprintf(buf, "%d", state.timeout_value);
1483
1484 switch (state.timeout_unit) {
1485 case KBD_TIMEOUT_SECONDS:
1486 return len + sprintf(buf+len, "s\n");
1487 case KBD_TIMEOUT_MINUTES:
1488 return len + sprintf(buf+len, "m\n");
1489 case KBD_TIMEOUT_HOURS:
1490 return len + sprintf(buf+len, "h\n");
1491 case KBD_TIMEOUT_DAYS:
1492 return len + sprintf(buf+len, "d\n");
1493 default:
1494 return -EINVAL;
1495 }
1496
1497 return len;
1498}
1499
1500static DEVICE_ATTR(stop_timeout, S_IRUGO | S_IWUSR,
1501 kbd_led_timeout_show, kbd_led_timeout_store);
1502
1503static const char * const kbd_led_triggers[] = {
1504 "keyboard",
1505 "touchpad",
1506 /*"trackstick"*/ NULL, /* NOTE: trackstick is just alias for touchpad */
1507 "mouse",
1508};
1509
1510static ssize_t kbd_led_triggers_store(struct device *dev,
1511 struct device_attribute *attr,
1512 const char *buf, size_t count)
1513{
1514 struct kbd_state new_state;
1515 struct kbd_state state;
1516 bool triggers_enabled = false;
1517 bool als_enabled = false;
1518 bool disable_als = false;
1519 bool enable_als = false;
1520 int trigger_bit = -1;
1521 char trigger[21];
1522 int i, ret;
1523
1524 ret = sscanf(buf, "%20s", trigger);
1525 if (ret != 1)
1526 return -EINVAL;
1527
1528 if (trigger[0] != '+' && trigger[0] != '-')
1529 return -EINVAL;
1530
1531 ret = kbd_get_state(&state);
1532 if (ret)
1533 return ret;
1534
1535 if (kbd_als_supported)
1536 als_enabled = kbd_is_als_mode_bit(state.mode_bit);
1537
1538 if (kbd_triggers_supported)
1539 triggers_enabled = kbd_is_trigger_mode_bit(state.mode_bit);
1540
1541 if (kbd_als_supported) {
1542 if (strcmp(trigger, "+als") == 0) {
1543 if (als_enabled)
1544 return count;
1545 enable_als = true;
1546 } else if (strcmp(trigger, "-als") == 0) {
1547 if (!als_enabled)
1548 return count;
1549 disable_als = true;
1550 }
1551 }
1552
1553 if (enable_als || disable_als) {
1554 new_state = state;
1555 if (enable_als) {
1556 if (triggers_enabled)
1557 new_state.mode_bit = KBD_MODE_BIT_TRIGGER_ALS;
1558 else
1559 new_state.mode_bit = KBD_MODE_BIT_ALS;
1560 } else {
1561 if (triggers_enabled) {
1562 new_state.mode_bit = KBD_MODE_BIT_TRIGGER;
1563 kbd_set_level(&new_state, kbd_previous_level);
1564 } else {
1565 new_state.mode_bit = KBD_MODE_BIT_ON;
1566 }
1567 }
1568 if (!(kbd_info.modes & BIT(new_state.mode_bit)))
1569 return -EINVAL;
1570 ret = kbd_set_state_safe(&new_state, &state);
1571 if (ret)
1572 return ret;
1573 kbd_previous_mode_bit = new_state.mode_bit;
1574 return count;
1575 }
1576
1577 if (kbd_triggers_supported) {
1578 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); ++i) {
1579 if (!(kbd_info.triggers & BIT(i)))
1580 continue;
1581 if (!kbd_led_triggers[i])
1582 continue;
1583 if (strcmp(trigger+1, kbd_led_triggers[i]) != 0)
1584 continue;
1585 if (trigger[0] == '+' &&
1586 triggers_enabled && (state.triggers & BIT(i)))
1587 return count;
1588 if (trigger[0] == '-' &&
1589 (!triggers_enabled || !(state.triggers & BIT(i))))
1590 return count;
1591 trigger_bit = i;
1592 break;
1593 }
1594 }
1595
1596 if (trigger_bit != -1) {
1597 new_state = state;
1598 if (trigger[0] == '+')
1599 new_state.triggers |= BIT(trigger_bit);
1600 else {
1601 new_state.triggers &= ~BIT(trigger_bit);
1602 /* NOTE: trackstick bit (2) must be disabled when
1603 * disabling touchpad bit (1), otherwise touchpad
1604 * bit (1) will not be disabled */
1605 if (trigger_bit == 1)
1606 new_state.triggers &= ~BIT(2);
1607 }
1608 if ((kbd_info.triggers & new_state.triggers) !=
1609 new_state.triggers)
1610 return -EINVAL;
1611 if (new_state.triggers && !triggers_enabled) {
1612 if (als_enabled)
1613 new_state.mode_bit = KBD_MODE_BIT_TRIGGER_ALS;
1614 else {
1615 new_state.mode_bit = KBD_MODE_BIT_TRIGGER;
1616 kbd_set_level(&new_state, kbd_previous_level);
1617 }
1618 } else if (new_state.triggers == 0) {
1619 if (als_enabled)
1620 new_state.mode_bit = KBD_MODE_BIT_ALS;
1621 else
1622 kbd_set_level(&new_state, 0);
1623 }
1624 if (!(kbd_info.modes & BIT(new_state.mode_bit)))
1625 return -EINVAL;
1626 ret = kbd_set_state_safe(&new_state, &state);
1627 if (ret)
1628 return ret;
1629 if (new_state.mode_bit != KBD_MODE_BIT_OFF)
1630 kbd_previous_mode_bit = new_state.mode_bit;
1631 return count;
1632 }
1633
1634 return -EINVAL;
1635}
1636
1637static ssize_t kbd_led_triggers_show(struct device *dev,
1638 struct device_attribute *attr, char *buf)
1639{
1640 struct kbd_state state;
1641 bool triggers_enabled;
1642 int level, i, ret;
1643 int len = 0;
1644
1645 ret = kbd_get_state(&state);
1646 if (ret)
1647 return ret;
1648
1649 len = 0;
1650
1651 if (kbd_triggers_supported) {
1652 triggers_enabled = kbd_is_trigger_mode_bit(state.mode_bit);
1653 level = kbd_get_level(&state);
1654 for (i = 0; i < ARRAY_SIZE(kbd_led_triggers); ++i) {
1655 if (!(kbd_info.triggers & BIT(i)))
1656 continue;
1657 if (!kbd_led_triggers[i])
1658 continue;
1659 if ((triggers_enabled || level <= 0) &&
1660 (state.triggers & BIT(i)))
1661 buf[len++] = '+';
1662 else
1663 buf[len++] = '-';
1664 len += sprintf(buf+len, "%s ", kbd_led_triggers[i]);
1665 }
1666 }
1667
1668 if (kbd_als_supported) {
1669 if (kbd_is_als_mode_bit(state.mode_bit))
1670 len += sprintf(buf+len, "+als ");
1671 else
1672 len += sprintf(buf+len, "-als ");
1673 }
1674
1675 if (len)
1676 buf[len - 1] = '\n';
1677
1678 return len;
1679}
1680
1681static DEVICE_ATTR(start_triggers, S_IRUGO | S_IWUSR,
1682 kbd_led_triggers_show, kbd_led_triggers_store);
1683
1684static ssize_t kbd_led_als_store(struct device *dev,
1685 struct device_attribute *attr,
1686 const char *buf, size_t count)
1687{
1688 struct kbd_state state;
1689 struct kbd_state new_state;
1690 u8 setting;
1691 int ret;
1692
1693 ret = kstrtou8(buf, 10, &setting);
1694 if (ret)
1695 return ret;
1696
1697 ret = kbd_get_state(&state);
1698 if (ret)
1699 return ret;
1700
1701 new_state = state;
1702 new_state.als_setting = setting;
1703
1704 ret = kbd_set_state_safe(&new_state, &state);
1705 if (ret)
1706 return ret;
1707
1708 return count;
1709}
1710
1711static ssize_t kbd_led_als_show(struct device *dev,
1712 struct device_attribute *attr, char *buf)
1713{
1714 struct kbd_state state;
1715 int ret;
1716
1717 ret = kbd_get_state(&state);
1718 if (ret)
1719 return ret;
1720
1721 return sprintf(buf, "%d\n", state.als_setting);
1722}
1723
1724static DEVICE_ATTR(als_setting, S_IRUGO | S_IWUSR,
1725 kbd_led_als_show, kbd_led_als_store);
1726
1727static struct attribute *kbd_led_attrs[] = {
1728 &dev_attr_stop_timeout.attr,
1729 &dev_attr_start_triggers.attr,
1730 &dev_attr_als_setting.attr,
1731 NULL,
1732};
1733ATTRIBUTE_GROUPS(kbd_led);
1734
1735static enum led_brightness kbd_led_level_get(struct led_classdev *led_cdev)
1736{
1737 int ret;
1738 u16 num;
1739 struct kbd_state state;
1740
1741 if (kbd_get_max_level()) {
1742 ret = kbd_get_state(&state);
1743 if (ret)
1744 return 0;
1745 ret = kbd_get_level(&state);
1746 if (ret < 0)
1747 return 0;
1748 return ret;
1749 }
1750
1751 if (kbd_get_valid_token_counts()) {
1752 ret = kbd_get_first_active_token_bit();
1753 if (ret < 0)
1754 return 0;
1755 for (num = kbd_token_bits; num != 0 && ret > 0; --ret)
1756 num &= num - 1; /* clear the first bit set */
1757 if (num == 0)
1758 return 0;
1759 return ffs(num) - 1;
1760 }
1761
1762 pr_warn("Keyboard brightness level control not supported\n");
1763 return 0;
1764}
1765
1766static void kbd_led_level_set(struct led_classdev *led_cdev,
1767 enum led_brightness value)
1768{
1769 struct kbd_state state;
1770 struct kbd_state new_state;
1771 u16 num;
1772
1773 if (kbd_get_max_level()) {
1774 if (kbd_get_state(&state))
1775 return;
1776 new_state = state;
1777 if (kbd_set_level(&new_state, value))
1778 return;
1779 kbd_set_state_safe(&new_state, &state);
1780 return;
1781 }
1782
1783 if (kbd_get_valid_token_counts()) {
1784 for (num = kbd_token_bits; num != 0 && value > 0; --value)
1785 num &= num - 1; /* clear the first bit set */
1786 if (num == 0)
1787 return;
1788 kbd_set_token_bit(ffs(num) - 1);
1789 return;
1790 }
1791
1792 pr_warn("Keyboard brightness level control not supported\n");
1793}
1794
1795static struct led_classdev kbd_led = {
1796 .name = "dell::kbd_backlight",
1797 .brightness_set = kbd_led_level_set,
1798 .brightness_get = kbd_led_level_get,
1799 .groups = kbd_led_groups,
1800};
1801
1802static int __init kbd_led_init(struct device *dev)
1803{
1804 kbd_init();
1805 if (!kbd_led_present)
1806 return -ENODEV;
1807 kbd_led.max_brightness = kbd_get_max_level();
1808 if (!kbd_led.max_brightness) {
1809 kbd_led.max_brightness = kbd_get_valid_token_counts();
1810 if (kbd_led.max_brightness)
1811 kbd_led.max_brightness--;
1812 }
1813 return led_classdev_register(dev, &kbd_led);
1814}
1815
1816static void brightness_set_exit(struct led_classdev *led_cdev,
1817 enum led_brightness value)
1818{
1819 /* Don't change backlight level on exit */
1820};
1821
1822static void kbd_led_exit(void)
1823{
1824 if (!kbd_led_present)
1825 return;
1826 kbd_led.brightness_set = brightness_set_exit;
1827 led_classdev_unregister(&kbd_led);
1828}
1829
1830static int __init dell_init(void) 792static int __init dell_init(void)
1831{ 793{
1832 int max_intensity = 0; 794 int max_intensity = 0;
@@ -1879,8 +841,6 @@ static int __init dell_init(void)
1879 if (quirks && quirks->touchpad_led) 841 if (quirks && quirks->touchpad_led)
1880 touchpad_led_init(&platform_device->dev); 842 touchpad_led_init(&platform_device->dev);
1881 843
1882 kbd_led_init(&platform_device->dev);
1883
1884 dell_laptop_dir = debugfs_create_dir("dell_laptop", NULL); 844 dell_laptop_dir = debugfs_create_dir("dell_laptop", NULL);
1885 if (dell_laptop_dir != NULL) 845 if (dell_laptop_dir != NULL)
1886 debugfs_create_file("rfkill", 0444, dell_laptop_dir, NULL, 846 debugfs_create_file("rfkill", 0444, dell_laptop_dir, NULL,
@@ -1948,7 +908,6 @@ static void __exit dell_exit(void)
1948 debugfs_remove_recursive(dell_laptop_dir); 908 debugfs_remove_recursive(dell_laptop_dir);
1949 if (quirks && quirks->touchpad_led) 909 if (quirks && quirks->touchpad_led)
1950 touchpad_led_exit(); 910 touchpad_led_exit();
1951 kbd_led_exit();
1952 i8042_remove_filter(dell_laptop_i8042_filter); 911 i8042_remove_filter(dell_laptop_i8042_filter);
1953 cancel_delayed_work_sync(&dell_rfkill_work); 912 cancel_delayed_work_sync(&dell_rfkill_work);
1954 backlight_device_unregister(dell_backlight_device); 913 backlight_device_unregister(dell_backlight_device);
@@ -1965,7 +924,5 @@ module_init(dell_init);
1965module_exit(dell_exit); 924module_exit(dell_exit);
1966 925
1967MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>"); 926MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
1968MODULE_AUTHOR("Gabriele Mazzotta <gabriele.mzt@gmail.com>");
1969MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
1970MODULE_DESCRIPTION("Dell laptop driver"); 927MODULE_DESCRIPTION("Dell laptop driver");
1971MODULE_LICENSE("GPL"); 928MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-08 02:48:17 -0500