Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'fixes' into 'for-next'
Allows uniwill-laptop feature work that depends on changes in the fixes
branch proceed.
+407
-71
+5
-5
Documentation/ABI/testing/sysfs-driver-uniwill-laptop
+5
-5
Documentation/ABI/testing/sysfs-driver-uniwill-laptop
···
1
-
What: /sys/bus/platform/devices/INOU0000:XX/fn_lock_toggle_enable
1
+
What: /sys/bus/platform/devices/INOU0000:XX/fn_lock
2
2
Date: November 2025
3
3
KernelVersion: 6.19
4
4
Contact: Armin Wolf <W_Armin@gmx.de>
···
8
8
9
9
Reading this file returns the current enable status of the FN lock functionality.
10
10
11
-
What: /sys/bus/platform/devices/INOU0000:XX/super_key_toggle_enable
11
+
What: /sys/bus/platform/devices/INOU0000:XX/super_key_enable
12
12
Date: November 2025
13
13
KernelVersion: 6.19
14
14
Contact: Armin Wolf <W_Armin@gmx.de>
15
15
Description:
16
-
Allows userspace applications to enable/disable the super key functionality
17
-
of the integrated keyboard by writing "1"/"0" into this file.
16
+
Allows userspace applications to enable/disable the super key of the integrated
17
+
keyboard by writing "1"/"0" into this file.
18
18
19
-
Reading this file returns the current enable status of the super key functionality.
19
+
Reading this file returns the current enable status of the super key.
20
20
21
21
What: /sys/bus/platform/devices/INOU0000:XX/touchpad_toggle_enable
22
22
Date: November 2025
+1
-1
Documentation/admin-guide/laptops/uniwill-laptop.rst
+1
-1
Documentation/admin-guide/laptops/uniwill-laptop.rst
···
24
24
25
25
The ``uniwill-laptop`` driver allows the user to enable/disable:
26
26
27
-
- the FN and super key lock functionality of the integrated keyboard
27
+
- the FN lock and super key of the integrated keyboard
28
28
- the touchpad toggle functionality of the integrated touchpad
29
29
30
30
See Documentation/ABI/testing/sysfs-driver-uniwill-laptop for details.
+1
-1
MAINTAINERS
+1
-1
MAINTAINERS
···
3989
3989
ASUS NOTEBOOKS AND EEEPC ACPI/WMI EXTRAS DRIVERS
3990
3990
M: Corentin Chary <corentin.chary@gmail.com>
3991
3991
M: Luke D. Jones <luke@ljones.dev>
3992
-
M: Denis Benato <benato.denis96@gmail.com>
3992
+
M: Denis Benato <denis.benato@linux.dev>
3993
3993
L: platform-driver-x86@vger.kernel.org
3994
3994
S: Maintained
3995
3995
W: https://asus-linux.org/
+1
-1
drivers/platform/olpc/olpc-xo175-ec.c
+1
-1
drivers/platform/olpc/olpc-xo175-ec.c
+1
-1
drivers/platform/x86/amd/hsmp/hsmp.c
+1
-1
drivers/platform/x86/amd/hsmp/hsmp.c
···
117
117
}
118
118
119
119
if (unlikely(mbox_status == HSMP_STATUS_NOT_READY)) {
120
-
dev_err(sock->dev, "Message ID 0x%X failure : SMU tmeout (status = 0x%X)\n",
120
+
dev_err(sock->dev, "Message ID 0x%X failure : SMU timeout (status = 0x%X)\n",
121
121
msg->msg_id, mbox_status);
122
122
return -ETIMEDOUT;
123
123
} else if (unlikely(mbox_status == HSMP_ERR_INVALID_MSG)) {
+152
drivers/platform/x86/asus-armoury.h
+152
drivers/platform/x86/asus-armoury.h
···
348
348
static const struct dmi_system_id power_limits[] = {
349
349
{
350
350
.matches = {
351
+
DMI_MATCH(DMI_BOARD_NAME, "FA401UM"),
352
+
},
353
+
.driver_data = &(struct power_data) {
354
+
.ac_data = &(struct power_limits) {
355
+
.ppt_pl1_spl_min = 15,
356
+
.ppt_pl1_spl_max = 80,
357
+
.ppt_pl2_sppt_min = 35,
358
+
.ppt_pl2_sppt_max = 80,
359
+
.ppt_pl3_fppt_min = 35,
360
+
.ppt_pl3_fppt_max = 80,
361
+
.nv_dynamic_boost_min = 5,
362
+
.nv_dynamic_boost_max = 15,
363
+
.nv_temp_target_min = 75,
364
+
.nv_temp_target_max = 87,
365
+
},
366
+
.dc_data = &(struct power_limits) {
367
+
.ppt_pl1_spl_min = 25,
368
+
.ppt_pl1_spl_max = 35,
369
+
.ppt_pl2_sppt_min = 31,
370
+
.ppt_pl2_sppt_max = 44,
371
+
.ppt_pl3_fppt_min = 45,
372
+
.ppt_pl3_fppt_max = 65,
373
+
.nv_temp_target_min = 75,
374
+
.nv_temp_target_max = 87,
375
+
},
376
+
},
377
+
},
378
+
{
379
+
.matches = {
351
380
DMI_MATCH(DMI_BOARD_NAME, "FA401UV"),
352
381
},
353
382
.driver_data = &(struct power_data) {
···
1082
1053
},
1083
1054
{
1084
1055
.matches = {
1056
+
DMI_MATCH(DMI_BOARD_NAME, "GA503QM"),
1057
+
},
1058
+
.driver_data = &(struct power_data) {
1059
+
.ac_data = &(struct power_limits) {
1060
+
.ppt_pl1_spl_min = 15,
1061
+
.ppt_pl1_spl_def = 35,
1062
+
.ppt_pl1_spl_max = 80,
1063
+
.ppt_pl2_sppt_min = 65,
1064
+
.ppt_pl2_sppt_max = 80,
1065
+
},
1066
+
},
1067
+
},
1068
+
{
1069
+
.matches = {
1085
1070
DMI_MATCH(DMI_BOARD_NAME, "GA503QR"),
1086
1071
},
1087
1072
.driver_data = &(struct power_data) {
···
1502
1459
},
1503
1460
{
1504
1461
.matches = {
1462
+
DMI_MATCH(DMI_BOARD_NAME, "GX650RX"),
1463
+
},
1464
+
.driver_data = &(struct power_data) {
1465
+
.ac_data = &(struct power_limits) {
1466
+
.ppt_pl1_spl_min = 28,
1467
+
.ppt_pl1_spl_def = 70,
1468
+
.ppt_pl1_spl_max = 90,
1469
+
.ppt_pl2_sppt_min = 28,
1470
+
.ppt_pl2_sppt_def = 70,
1471
+
.ppt_pl2_sppt_max = 100,
1472
+
.ppt_pl3_fppt_min = 28,
1473
+
.ppt_pl3_fppt_def = 110,
1474
+
.ppt_pl3_fppt_max = 125,
1475
+
.nv_dynamic_boost_min = 5,
1476
+
.nv_dynamic_boost_max = 25,
1477
+
.nv_temp_target_min = 76,
1478
+
.nv_temp_target_max = 87,
1479
+
},
1480
+
.dc_data = &(struct power_limits) {
1481
+
.ppt_pl1_spl_min = 28,
1482
+
.ppt_pl1_spl_max = 50,
1483
+
.ppt_pl2_sppt_min = 28,
1484
+
.ppt_pl2_sppt_max = 50,
1485
+
.ppt_pl3_fppt_min = 28,
1486
+
.ppt_pl3_fppt_max = 65,
1487
+
.nv_temp_target_min = 76,
1488
+
.nv_temp_target_max = 87,
1489
+
},
1490
+
},
1491
+
},
1492
+
{
1493
+
.matches = {
1494
+
DMI_MATCH(DMI_BOARD_NAME, "GZ302EA"),
1495
+
},
1496
+
.driver_data = &(struct power_data) {
1497
+
.ac_data = &(struct power_limits) {
1498
+
.ppt_pl1_spl_min = 28,
1499
+
.ppt_pl1_spl_def = 60,
1500
+
.ppt_pl1_spl_max = 80,
1501
+
.ppt_pl2_sppt_min = 32,
1502
+
.ppt_pl2_sppt_def = 75,
1503
+
.ppt_pl2_sppt_max = 92,
1504
+
.ppt_pl3_fppt_min = 45,
1505
+
.ppt_pl3_fppt_def = 86,
1506
+
.ppt_pl3_fppt_max = 93,
1507
+
},
1508
+
.dc_data = &(struct power_limits) {
1509
+
.ppt_pl1_spl_min = 28,
1510
+
.ppt_pl1_spl_def = 45,
1511
+
.ppt_pl1_spl_max = 80,
1512
+
.ppt_pl2_sppt_min = 32,
1513
+
.ppt_pl2_sppt_def = 52,
1514
+
.ppt_pl2_sppt_max = 92,
1515
+
.ppt_pl3_fppt_min = 45,
1516
+
.ppt_pl3_fppt_def = 71,
1517
+
.ppt_pl3_fppt_max = 93,
1518
+
},
1519
+
},
1520
+
},
1521
+
{
1522
+
.matches = {
1505
1523
DMI_MATCH(DMI_BOARD_NAME, "G513I"),
1506
1524
},
1507
1525
.driver_data = &(struct power_data) {
···
1633
1529
.ppt_pl2_sppt_max = 50,
1634
1530
.ppt_pl3_fppt_min = 28,
1635
1531
.ppt_pl3_fppt_max = 65,
1532
+
.nv_temp_target_min = 75,
1533
+
.nv_temp_target_max = 87,
1534
+
},
1535
+
.requires_fan_curve = true,
1536
+
},
1537
+
},
1538
+
{
1539
+
.matches = {
1540
+
DMI_MATCH(DMI_BOARD_NAME, "G614FP"),
1541
+
},
1542
+
.driver_data = &(struct power_data) {
1543
+
.ac_data = &(struct power_limits) {
1544
+
.ppt_pl1_spl_min = 30,
1545
+
.ppt_pl1_spl_max = 120,
1546
+
.ppt_pl2_sppt_min = 65,
1547
+
.ppt_pl2_sppt_def = 140,
1548
+
.ppt_pl2_sppt_max = 165,
1549
+
.ppt_pl3_fppt_min = 65,
1550
+
.ppt_pl3_fppt_def = 140,
1551
+
.ppt_pl3_fppt_max = 165,
1552
+
.nv_temp_target_min = 75,
1553
+
.nv_temp_target_max = 87,
1554
+
.nv_dynamic_boost_min = 5,
1555
+
.nv_dynamic_boost_max = 15,
1556
+
.nv_tgp_min = 50,
1557
+
.nv_tgp_max = 100,
1558
+
},
1559
+
.dc_data = &(struct power_limits) {
1560
+
.ppt_pl1_spl_min = 25,
1561
+
.ppt_pl1_spl_max = 65,
1562
+
.ppt_pl2_sppt_min = 25,
1563
+
.ppt_pl2_sppt_max = 65,
1564
+
.ppt_pl3_fppt_min = 35,
1565
+
.ppt_pl3_fppt_max = 75,
1636
1566
.nv_temp_target_min = 75,
1637
1567
.nv_temp_target_max = 87,
1638
1568
},
···
1844
1706
.nv_temp_target_max = 87,
1845
1707
},
1846
1708
.requires_fan_curve = true,
1709
+
},
1710
+
},
1711
+
{
1712
+
.matches = {
1713
+
DMI_MATCH(DMI_BOARD_NAME, "G733QS"),
1714
+
},
1715
+
.driver_data = &(struct power_data) {
1716
+
.ac_data = &(struct power_limits) {
1717
+
.ppt_pl1_spl_min = 15,
1718
+
.ppt_pl1_spl_max = 80,
1719
+
.ppt_pl2_sppt_min = 15,
1720
+
.ppt_pl2_sppt_max = 80,
1721
+
},
1722
+
.requires_fan_curve = false,
1847
1723
},
1848
1724
},
1849
1725
{
+1
-1
drivers/platform/x86/asus-nb-wmi.c
+1
-1
drivers/platform/x86/asus-nb-wmi.c
+1
-1
drivers/platform/x86/dell/alienware-wmi-wmax.c
+1
-1
drivers/platform/x86/dell/alienware-wmi-wmax.c
+6
drivers/platform/x86/dell/dell-wmi-base.c
+6
drivers/platform/x86/dell/dell-wmi-base.c
···
80
80
static const struct key_entry dell_wmi_keymap_type_0000[] = {
81
81
{ KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
82
82
83
+
/* Audio mute toggle */
84
+
{ KE_KEY, 0x0109, { KEY_MUTE } },
85
+
86
+
/* Mic mute toggle */
87
+
{ KE_KEY, 0x0150, { KEY_MICMUTE } },
88
+
83
89
/* Meta key lock */
84
90
{ KE_IGNORE, 0xe000, { KEY_RIGHTMETA } },
85
91
-1
drivers/platform/x86/dell/dell-wmi-sysman/passwordattr-interface.c
-1
drivers/platform/x86/dell/dell-wmi-sysman/passwordattr-interface.c
···
93
93
if (ret < 0)
94
94
goto out;
95
95
96
-
print_hex_dump_bytes("set new password data: ", DUMP_PREFIX_NONE, buffer, buffer_size);
97
96
ret = call_password_interface(wmi_priv.password_attr_wdev, buffer, buffer_size);
98
97
/* on success copy the new password to current password */
99
98
if (!ret)
+6
-3
drivers/platform/x86/hp/hp-bioscfg/enum-attributes.c
+6
-3
drivers/platform/x86/hp/hp-bioscfg/enum-attributes.c
···
94
94
bioscfg_drv.enumeration_instances_count =
95
95
hp_get_instance_count(HP_WMI_BIOS_ENUMERATION_GUID);
96
96
97
-
bioscfg_drv.enumeration_data = kzalloc_objs(*bioscfg_drv.enumeration_data,
98
-
bioscfg_drv.enumeration_instances_count);
97
+
if (!bioscfg_drv.enumeration_instances_count)
98
+
return -EINVAL;
99
+
bioscfg_drv.enumeration_data = kvcalloc(bioscfg_drv.enumeration_instances_count,
100
+
sizeof(*bioscfg_drv.enumeration_data), GFP_KERNEL);
101
+
99
102
if (!bioscfg_drv.enumeration_data) {
100
103
bioscfg_drv.enumeration_instances_count = 0;
101
104
return -ENOMEM;
···
447
444
}
448
445
bioscfg_drv.enumeration_instances_count = 0;
449
446
450
-
kfree(bioscfg_drv.enumeration_data);
447
+
kvfree(bioscfg_drv.enumeration_data);
451
448
bioscfg_drv.enumeration_data = NULL;
452
449
}
+30
-1
drivers/platform/x86/hp/hp-wmi.c
+30
-1
drivers/platform/x86/hp/hp-wmi.c
···
120
120
.ec_tp_offset = HP_VICTUS_S_EC_THERMAL_PROFILE_OFFSET,
121
121
};
122
122
123
+
static const struct thermal_profile_params omen_v1_legacy_thermal_params = {
124
+
.performance = HP_OMEN_V1_THERMAL_PROFILE_PERFORMANCE,
125
+
.balanced = HP_OMEN_V1_THERMAL_PROFILE_DEFAULT,
126
+
.low_power = HP_OMEN_V1_THERMAL_PROFILE_DEFAULT,
127
+
.ec_tp_offset = HP_OMEN_EC_THERMAL_PROFILE_OFFSET,
128
+
};
129
+
123
130
/*
124
131
* A generic pointer for the currently-active board's thermal profile
125
132
* parameters.
···
153
146
"8900", "8901", "8902", "8912", "8917", "8918", "8949", "894A", "89EB",
154
147
"8A15", "8A42",
155
148
"8BAD",
149
+
"8E41",
156
150
};
157
151
158
152
/* DMI Board names of Omen laptops that are specifically set to be thermal
···
174
166
"8BAD",
175
167
};
176
168
177
-
/* DMI Board names of Victus 16-d1xxx laptops */
169
+
/* DMI Board names of Victus 16-d laptops */
178
170
static const char * const victus_thermal_profile_boards[] = {
171
+
"88F8",
179
172
"8A25",
180
173
};
181
174
182
175
/* DMI Board names of Victus 16-r and Victus 16-s laptops */
183
176
static const struct dmi_system_id victus_s_thermal_profile_boards[] __initconst = {
184
177
{
178
+
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8A4D") },
179
+
.driver_data = (void *)&omen_v1_legacy_thermal_params,
180
+
},
181
+
{
182
+
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BAB") },
183
+
.driver_data = (void *)&omen_v1_thermal_params,
184
+
},
185
+
{
185
186
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BBE") },
186
187
.driver_data = (void *)&victus_s_thermal_params,
188
+
},
189
+
{
190
+
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BCA") },
191
+
.driver_data = (void *)&omen_v1_thermal_params,
192
+
},
193
+
{
194
+
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BCD") },
195
+
.driver_data = (void *)&omen_v1_thermal_params,
187
196
},
188
197
{
189
198
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BD4") },
···
209
184
{
210
185
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8BD5") },
211
186
.driver_data = (void *)&victus_s_thermal_params,
187
+
},
188
+
{
189
+
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8C76") },
190
+
.driver_data = (void *)&omen_v1_thermal_params,
212
191
},
213
192
{
214
193
.matches = { DMI_MATCH(DMI_BOARD_NAME, "8C78") },
+28
-1
drivers/platform/x86/intel/hid.c
+28
-1
drivers/platform/x86/intel/hid.c
···
136
136
},
137
137
},
138
138
{
139
+
.ident = "Lenovo ThinkPad X1 Fold 16 Gen 1",
140
+
.matches = {
141
+
DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
142
+
DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Fold 16 Gen 1"),
143
+
},
144
+
},
145
+
{
139
146
.ident = "Microsoft Surface Go 3",
140
147
.matches = {
141
148
DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
···
194
187
.matches = {
195
188
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
196
189
DMI_MATCH(DMI_PRODUCT_NAME, "Dell Pro Rugged 12 Tablet RA02260"),
190
+
},
191
+
},
192
+
{
193
+
.matches = {
194
+
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
195
+
DMI_MATCH(DMI_PRODUCT_NAME, "Dell 14 Plus 2-in-1 DB04250"),
196
+
},
197
+
},
198
+
{
199
+
.matches = {
200
+
DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
201
+
DMI_MATCH(DMI_PRODUCT_NAME, "Dell 16 Plus 2-in-1 DB06250"),
197
202
},
198
203
},
199
204
{ }
···
438
419
return 0;
439
420
}
440
421
422
+
static int intel_hid_pl_freeze_handler(struct device *device)
423
+
{
424
+
struct intel_hid_priv *priv = dev_get_drvdata(device);
425
+
426
+
priv->wakeup_mode = false;
427
+
return intel_hid_pl_suspend_handler(device);
428
+
}
429
+
441
430
static int intel_hid_pl_resume_handler(struct device *device)
442
431
{
443
432
intel_hid_pm_complete(device);
···
460
433
static const struct dev_pm_ops intel_hid_pl_pm_ops = {
461
434
.prepare = intel_hid_pm_prepare,
462
435
.complete = intel_hid_pm_complete,
463
-
.freeze = intel_hid_pl_suspend_handler,
436
+
.freeze = intel_hid_pl_freeze_handler,
464
437
.thaw = intel_hid_pl_resume_handler,
465
438
.restore = intel_hid_pl_resume_handler,
466
439
.suspend = intel_hid_pl_suspend_handler,
+7
drivers/platform/x86/intel/int3472/discrete.c
+7
drivers/platform/x86/intel/int3472/discrete.c
···
223
223
*con_id = "avdd";
224
224
*gpio_flags = GPIO_ACTIVE_HIGH;
225
225
break;
226
+
case INT3472_GPIO_TYPE_DOVDD:
227
+
*con_id = "dovdd";
228
+
*gpio_flags = GPIO_ACTIVE_HIGH;
229
+
break;
226
230
case INT3472_GPIO_TYPE_HANDSHAKE:
227
231
*con_id = "dvdd";
228
232
*gpio_flags = GPIO_ACTIVE_HIGH;
···
255
251
* 0x0b Power enable
256
252
* 0x0c Clock enable
257
253
* 0x0d Privacy LED
254
+
* 0x10 DOVDD (digital I/O voltage)
258
255
* 0x13 Hotplug detect
259
256
*
260
257
* There are some known platform specific quirks where that does not quite
···
337
332
case INT3472_GPIO_TYPE_CLK_ENABLE:
338
333
case INT3472_GPIO_TYPE_PRIVACY_LED:
339
334
case INT3472_GPIO_TYPE_POWER_ENABLE:
335
+
case INT3472_GPIO_TYPE_DOVDD:
340
336
case INT3472_GPIO_TYPE_HANDSHAKE:
341
337
gpio = skl_int3472_gpiod_get_from_temp_lookup(int3472, agpio, con_id, gpio_flags);
342
338
if (IS_ERR(gpio)) {
···
362
356
case INT3472_GPIO_TYPE_POWER_ENABLE:
363
357
second_sensor = int3472->quirks.avdd_second_sensor;
364
358
fallthrough;
359
+
case INT3472_GPIO_TYPE_DOVDD:
365
360
case INT3472_GPIO_TYPE_HANDSHAKE:
366
361
ret = skl_int3472_register_regulator(int3472, gpio, enable_time_us,
367
362
con_id, second_sensor);
+4
-1
drivers/platform/x86/intel/speed_select_if/isst_tpmi_core.c
+4
-1
drivers/platform/x86/intel/speed_select_if/isst_tpmi_core.c
···
558
558
{
559
559
u64 value;
560
560
561
+
if (!static_cpu_has(X86_FEATURE_HWP))
562
+
return true;
563
+
561
564
rdmsrq(MSR_PM_ENABLE, value);
562
565
return !(value & 0x1);
563
566
}
···
872
869
_read_pp_info("current_level", perf_level.current_level, SST_PP_STATUS_OFFSET,
873
870
SST_PP_LEVEL_START, SST_PP_LEVEL_WIDTH, SST_MUL_FACTOR_NONE)
874
871
_read_pp_info("locked", perf_level.locked, SST_PP_STATUS_OFFSET,
875
-
SST_PP_LOCK_START, SST_PP_LEVEL_WIDTH, SST_MUL_FACTOR_NONE)
872
+
SST_PP_LOCK_START, SST_PP_LOCK_WIDTH, SST_MUL_FACTOR_NONE)
876
873
_read_pp_info("feature_state", perf_level.feature_state, SST_PP_STATUS_OFFSET,
877
874
SST_PP_FEATURE_STATE_START, SST_PP_FEATURE_STATE_WIDTH, SST_MUL_FACTOR_NONE)
878
875
perf_level.enabled = !!(power_domain_info->sst_header.cap_mask & BIT(1));
+4
-2
drivers/platform/x86/lenovo/thinkpad_acpi.c
+4
-2
drivers/platform/x86/lenovo/thinkpad_acpi.c
···
9551
9551
{
9552
9552
switch (what) {
9553
9553
case THRESHOLD_START:
9554
-
if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, ret, battery))
9554
+
if (!battery_info.batteries[battery].start_support ||
9555
+
ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_START, ret, battery)))
9555
9556
return -ENODEV;
9556
9557
9557
9558
/* The value is in the low 8 bits of the response */
9558
9559
*ret = *ret & 0xFF;
9559
9560
return 0;
9560
9561
case THRESHOLD_STOP:
9561
-
if ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, ret, battery))
9562
+
if (!battery_info.batteries[battery].stop_support ||
9563
+
ACPI_FAILURE(tpacpi_battery_acpi_eval(GET_STOP, ret, battery)))
9562
9564
return -ENODEV;
9563
9565
/* Value is in lower 8 bits */
9564
9566
*ret = *ret & 0xFF;
-2
drivers/platform/x86/lenovo/wmi-gamezone.c
-2
drivers/platform/x86/lenovo/wmi-gamezone.c
+29
-1
drivers/platform/x86/oxpec.c
+29
-1
drivers/platform/x86/oxpec.c
···
11
11
*
12
12
* Copyright (C) 2022 Joaquín I. Aramendía <samsagax@gmail.com>
13
13
* Copyright (C) 2024 Derek J. Clark <derekjohn.clark@gmail.com>
14
-
* Copyright (C) 2025 Antheas Kapenekakis <lkml@antheas.dev>
14
+
* Copyright (C) 2025-2026 Antheas Kapenekakis <lkml@antheas.dev>
15
15
*/
16
16
17
17
#include <linux/acpi.h>
···
117
117
{
118
118
.matches = {
119
119
DMI_MATCH(DMI_BOARD_VENDOR, "AOKZOE"),
120
+
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AOKZOE A2 Pro"),
121
+
},
122
+
.driver_data = (void *)aok_zoe_a1,
123
+
},
124
+
{
125
+
.matches = {
126
+
DMI_MATCH(DMI_BOARD_VENDOR, "AOKZOE"),
120
127
DMI_EXACT_MATCH(DMI_BOARD_NAME, "AOKZOE A1X"),
121
128
},
122
129
.driver_data = (void *)oxp_fly,
···
148
141
DMI_MATCH(DMI_BOARD_NAME, "ONEXPLAYER 2"),
149
142
},
150
143
.driver_data = (void *)oxp_2,
144
+
},
145
+
{
146
+
.matches = {
147
+
DMI_MATCH(DMI_BOARD_VENDOR, "ONE-NETBOOK"),
148
+
DMI_EXACT_MATCH(DMI_BOARD_NAME, "ONEXPLAYER APEX"),
149
+
},
150
+
.driver_data = (void *)oxp_fly,
151
151
},
152
152
{
153
153
.matches = {
···
229
215
{
230
216
.matches = {
231
217
DMI_MATCH(DMI_BOARD_VENDOR, "ONE-NETBOOK"),
218
+
DMI_EXACT_MATCH(DMI_BOARD_NAME, "ONEXPLAYER X1z"),
219
+
},
220
+
.driver_data = (void *)oxp_x1,
221
+
},
222
+
{
223
+
.matches = {
224
+
DMI_MATCH(DMI_BOARD_VENDOR, "ONE-NETBOOK"),
232
225
DMI_EXACT_MATCH(DMI_BOARD_NAME, "ONEXPLAYER X1 A"),
233
226
},
234
227
.driver_data = (void *)oxp_x1,
···
244
223
.matches = {
245
224
DMI_MATCH(DMI_BOARD_VENDOR, "ONE-NETBOOK"),
246
225
DMI_EXACT_MATCH(DMI_BOARD_NAME, "ONEXPLAYER X1 i"),
226
+
},
227
+
.driver_data = (void *)oxp_x1,
228
+
},
229
+
{
230
+
.matches = {
231
+
DMI_MATCH(DMI_BOARD_VENDOR, "ONE-NETBOOK"),
232
+
DMI_EXACT_MATCH(DMI_BOARD_NAME, "ONEXPLAYER X1Air"),
247
233
},
248
234
.driver_data = (void *)oxp_x1,
249
235
},
+24
-1
drivers/platform/x86/redmi-wmi.c
+24
-1
drivers/platform/x86/redmi-wmi.c
···
20
20
static const struct key_entry redmi_wmi_keymap[] = {
21
21
{KE_KEY, 0x00000201, {KEY_SELECTIVE_SCREENSHOT}},
22
22
{KE_KEY, 0x00000301, {KEY_ALL_APPLICATIONS}},
23
-
{KE_KEY, 0x00001b01, {KEY_SETUP}},
23
+
{KE_KEY, 0x00001b01, {KEY_CONFIG}},
24
+
{KE_KEY, 0x00011b01, {KEY_CONFIG}},
25
+
{KE_KEY, 0x00010101, {KEY_SWITCHVIDEOMODE}},
26
+
{KE_KEY, 0x00001a01, {KEY_REFRESH_RATE_TOGGLE}},
24
27
25
28
/* AI button has code for each position */
26
29
{KE_KEY, 0x00011801, {KEY_ASSISTANT}},
···
34
31
{KE_IGNORE, 0x00800501, {}},
35
32
{KE_IGNORE, 0x00050501, {}},
36
33
{KE_IGNORE, 0x000a0501, {}},
34
+
35
+
/* Xiaomi G Command Center */
36
+
{KE_KEY, 0x00010a01, {KEY_VENDOR}},
37
+
38
+
/* OEM preset power mode */
39
+
{KE_IGNORE, 0x00011601, {}},
40
+
{KE_IGNORE, 0x00021601, {}},
41
+
{KE_IGNORE, 0x00031601, {}},
42
+
{KE_IGNORE, 0x00041601, {}},
43
+
44
+
/* Fn Lock state */
45
+
{KE_IGNORE, 0x00000701, {}},
46
+
{KE_IGNORE, 0x00010701, {}},
47
+
48
+
/* Fn+`/1/2/3/4 */
49
+
{KE_KEY, 0x00011101, {KEY_F13}},
50
+
{KE_KEY, 0x00011201, {KEY_F14}},
51
+
{KE_KEY, 0x00011301, {KEY_F15}},
52
+
{KE_KEY, 0x00011401, {KEY_F16}},
53
+
{KE_KEY, 0x00011501, {KEY_F17}},
37
54
38
55
{KE_END}
39
56
};
+18
drivers/platform/x86/touchscreen_dmi.c
+18
drivers/platform/x86/touchscreen_dmi.c
···
410
410
.properties = gdix1001_upside_down_props,
411
411
};
412
412
413
+
static const struct property_entry gdix1001_y_inverted_props[] = {
414
+
PROPERTY_ENTRY_BOOL("touchscreen-inverted-y"),
415
+
{ }
416
+
};
417
+
418
+
static const struct ts_dmi_data gdix1001_y_inverted_data = {
419
+
.acpi_name = "GDIX1001",
420
+
.properties = gdix1001_y_inverted_props,
421
+
};
422
+
413
423
static const struct property_entry gp_electronic_t701_props[] = {
414
424
PROPERTY_ENTRY_U32("touchscreen-size-x", 960),
415
425
PROPERTY_ENTRY_U32("touchscreen-size-y", 640),
···
1666
1656
DMI_MATCH(DMI_SYS_VENDOR, "Globalspace Tech Pvt Ltd"),
1667
1657
DMI_MATCH(DMI_PRODUCT_NAME, "SolTIVW"),
1668
1658
DMI_MATCH(DMI_PRODUCT_SKU, "PN20170413488"),
1659
+
},
1660
+
},
1661
+
{
1662
+
/* SUPI S10 */
1663
+
.driver_data = (void *)&gdix1001_y_inverted_data,
1664
+
.matches = {
1665
+
DMI_MATCH(DMI_SYS_VENDOR, "SUPI"),
1666
+
DMI_MATCH(DMI_PRODUCT_NAME, "S10"),
1669
1667
},
1670
1668
},
1671
1669
{
+75
-35
drivers/platform/x86/uniwill/uniwill-acpi.c
+75
-35
drivers/platform/x86/uniwill/uniwill-acpi.c
···
314
314
#define LED_CHANNELS 3
315
315
#define LED_MAX_BRIGHTNESS 200
316
316
317
-
#define UNIWILL_FEATURE_FN_LOCK_TOGGLE BIT(0)
318
-
#define UNIWILL_FEATURE_SUPER_KEY_TOGGLE BIT(1)
317
+
#define UNIWILL_FEATURE_FN_LOCK BIT(0)
318
+
#define UNIWILL_FEATURE_SUPER_KEY BIT(1)
319
319
#define UNIWILL_FEATURE_TOUCHPAD_TOGGLE BIT(2)
320
320
#define UNIWILL_FEATURE_LIGHTBAR BIT(3)
321
321
#define UNIWILL_FEATURE_BATTERY BIT(4)
···
330
330
struct acpi_battery_hook hook;
331
331
unsigned int last_charge_ctrl;
332
332
struct mutex battery_lock; /* Protects the list of currently registered batteries */
333
+
unsigned int last_status;
333
334
unsigned int last_switch_status;
334
335
struct mutex super_key_lock; /* Protects the toggling of the super key lock state */
335
336
struct list_head batteries;
···
378
377
{ KE_IGNORE, UNIWILL_OSD_CAPSLOCK, { KEY_CAPSLOCK }},
379
378
{ KE_IGNORE, UNIWILL_OSD_NUMLOCK, { KEY_NUMLOCK }},
380
379
381
-
/* Reported when the user locks/unlocks the super key */
382
-
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_LOCK_ENABLE, { KEY_UNKNOWN }},
383
-
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_LOCK_DISABLE, { KEY_UNKNOWN }},
380
+
/*
381
+
* Reported when the user enables/disables the super key.
382
+
* Those events might even be reported when the change was done
383
+
* using the sysfs attribute!
384
+
*/
385
+
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_DISABLE, { KEY_UNKNOWN }},
386
+
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_ENABLE, { KEY_UNKNOWN }},
384
387
/* Optional, might not be reported by all devices */
385
-
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_LOCK_CHANGED, { KEY_UNKNOWN }},
388
+
{ KE_IGNORE, UNIWILL_OSD_SUPER_KEY_STATE_CHANGED, { KEY_UNKNOWN }},
386
389
387
390
/* Reported in manual mode when toggling the airplane mode status */
388
391
{ KE_KEY, UNIWILL_OSD_RFKILL, { KEY_RFKILL }},
···
405
400
406
401
/* Reported when the user wants to toggle the mute status */
407
402
{ KE_IGNORE, UNIWILL_OSD_MUTE, { KEY_MUTE }},
408
-
409
-
/* Reported when the user locks/unlocks the Fn key */
410
-
{ KE_IGNORE, UNIWILL_OSD_FN_LOCK, { KEY_FN_ESC }},
411
403
412
404
/* Reported when the user wants to toggle the brightness of the keyboard */
413
405
{ KE_KEY, UNIWILL_OSD_KBDILLUMTOGGLE, { KEY_KBDILLUMTOGGLE }},
···
578
576
case EC_ADDR_SECOND_FAN_RPM_1:
579
577
case EC_ADDR_SECOND_FAN_RPM_2:
580
578
case EC_ADDR_BAT_ALERT:
579
+
case EC_ADDR_BIOS_OEM:
581
580
case EC_ADDR_PWM_1:
582
581
case EC_ADDR_PWM_2:
583
582
case EC_ADDR_TRIGGER:
···
603
600
.use_single_write = true,
604
601
};
605
602
606
-
static ssize_t fn_lock_toggle_enable_store(struct device *dev, struct device_attribute *attr,
607
-
const char *buf, size_t count)
603
+
static ssize_t fn_lock_store(struct device *dev, struct device_attribute *attr, const char *buf,
604
+
size_t count)
608
605
{
609
606
struct uniwill_data *data = dev_get_drvdata(dev);
610
607
unsigned int value;
···
627
624
return count;
628
625
}
629
626
630
-
static ssize_t fn_lock_toggle_enable_show(struct device *dev, struct device_attribute *attr,
631
-
char *buf)
627
+
static ssize_t fn_lock_show(struct device *dev, struct device_attribute *attr, char *buf)
632
628
{
633
629
struct uniwill_data *data = dev_get_drvdata(dev);
634
630
unsigned int value;
···
640
638
return sysfs_emit(buf, "%d\n", !!(value & FN_LOCK_STATUS));
641
639
}
642
640
643
-
static DEVICE_ATTR_RW(fn_lock_toggle_enable);
641
+
static DEVICE_ATTR_RW(fn_lock);
644
642
645
-
static ssize_t super_key_toggle_enable_store(struct device *dev, struct device_attribute *attr,
646
-
const char *buf, size_t count)
643
+
static ssize_t super_key_enable_store(struct device *dev, struct device_attribute *attr,
644
+
const char *buf, size_t count)
647
645
{
648
646
struct uniwill_data *data = dev_get_drvdata(dev);
649
647
unsigned int value;
···
675
673
return count;
676
674
}
677
675
678
-
static ssize_t super_key_toggle_enable_show(struct device *dev, struct device_attribute *attr,
679
-
char *buf)
676
+
static ssize_t super_key_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
680
677
{
681
678
struct uniwill_data *data = dev_get_drvdata(dev);
682
679
unsigned int value;
···
688
687
return sysfs_emit(buf, "%d\n", !(value & SUPER_KEY_LOCK_STATUS));
689
688
}
690
689
691
-
static DEVICE_ATTR_RW(super_key_toggle_enable);
690
+
static DEVICE_ATTR_RW(super_key_enable);
692
691
693
692
static ssize_t touchpad_toggle_enable_store(struct device *dev, struct device_attribute *attr,
694
693
const char *buf, size_t count)
···
882
881
883
882
static struct attribute *uniwill_attrs[] = {
884
883
/* Keyboard-related */
885
-
&dev_attr_fn_lock_toggle_enable.attr,
886
-
&dev_attr_super_key_toggle_enable.attr,
884
+
&dev_attr_fn_lock.attr,
885
+
&dev_attr_super_key_enable.attr,
887
886
&dev_attr_touchpad_toggle_enable.attr,
888
887
/* Lightbar-related */
889
888
&dev_attr_rainbow_animation.attr,
···
898
897
struct device *dev = kobj_to_dev(kobj);
899
898
struct uniwill_data *data = dev_get_drvdata(dev);
900
899
901
-
if (attr == &dev_attr_fn_lock_toggle_enable.attr) {
902
-
if (uniwill_device_supports(data, UNIWILL_FEATURE_FN_LOCK_TOGGLE))
900
+
if (attr == &dev_attr_fn_lock.attr) {
901
+
if (uniwill_device_supports(data, UNIWILL_FEATURE_FN_LOCK))
903
902
return attr->mode;
904
903
}
905
904
906
-
if (attr == &dev_attr_super_key_toggle_enable.attr) {
907
-
if (uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY_TOGGLE))
905
+
if (attr == &dev_attr_super_key_enable.attr) {
906
+
if (uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY))
908
907
return attr->mode;
909
908
}
910
909
···
1358
1357
1359
1358
switch (action) {
1360
1359
case UNIWILL_OSD_BATTERY_ALERT:
1360
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_BATTERY))
1361
+
return NOTIFY_DONE;
1362
+
1361
1363
mutex_lock(&data->battery_lock);
1362
1364
list_for_each_entry(entry, &data->batteries, head) {
1363
1365
power_supply_changed(entry->battery);
···
1372
1368
/* noop for the time being, will change once charging priority
1373
1369
* gets implemented.
1374
1370
*/
1371
+
1372
+
return NOTIFY_OK;
1373
+
case UNIWILL_OSD_FN_LOCK:
1374
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_FN_LOCK))
1375
+
return NOTIFY_DONE;
1376
+
1377
+
sysfs_notify(&data->dev->kobj, NULL, "fn_lock");
1375
1378
1376
1379
return NOTIFY_OK;
1377
1380
default:
···
1514
1503
regmap_clear_bits(data->regmap, EC_ADDR_AP_OEM, ENABLE_MANUAL_CTRL);
1515
1504
}
1516
1505
1517
-
static int uniwill_suspend_keyboard(struct uniwill_data *data)
1506
+
static int uniwill_suspend_fn_lock(struct uniwill_data *data)
1518
1507
{
1519
-
if (!uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY_TOGGLE))
1508
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_FN_LOCK))
1509
+
return 0;
1510
+
1511
+
/*
1512
+
* The EC_ADDR_BIOS_OEM is marked as volatile, so we have to restore it
1513
+
* ourselves.
1514
+
*/
1515
+
return regmap_read(data->regmap, EC_ADDR_BIOS_OEM, &data->last_status);
1516
+
}
1517
+
1518
+
static int uniwill_suspend_super_key(struct uniwill_data *data)
1519
+
{
1520
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY))
1520
1521
return 0;
1521
1522
1522
1523
/*
···
1565
1542
struct uniwill_data *data = dev_get_drvdata(dev);
1566
1543
int ret;
1567
1544
1568
-
ret = uniwill_suspend_keyboard(data);
1545
+
ret = uniwill_suspend_fn_lock(data);
1546
+
if (ret < 0)
1547
+
return ret;
1548
+
1549
+
ret = uniwill_suspend_super_key(data);
1569
1550
if (ret < 0)
1570
1551
return ret;
1571
1552
···
1587
1560
return 0;
1588
1561
}
1589
1562
1590
-
static int uniwill_resume_keyboard(struct uniwill_data *data)
1563
+
static int uniwill_resume_fn_lock(struct uniwill_data *data)
1564
+
{
1565
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_FN_LOCK))
1566
+
return 0;
1567
+
1568
+
return regmap_update_bits(data->regmap, EC_ADDR_BIOS_OEM, FN_LOCK_STATUS,
1569
+
data->last_status);
1570
+
}
1571
+
1572
+
static int uniwill_resume_super_key(struct uniwill_data *data)
1591
1573
{
1592
1574
unsigned int value;
1593
1575
int ret;
1594
1576
1595
-
if (!uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY_TOGGLE))
1577
+
if (!uniwill_device_supports(data, UNIWILL_FEATURE_SUPER_KEY))
1596
1578
return 0;
1597
1579
1598
1580
ret = regmap_read(data->regmap, EC_ADDR_SWITCH_STATUS, &value);
···
1644
1608
if (ret < 0)
1645
1609
return ret;
1646
1610
1647
-
ret = uniwill_resume_keyboard(data);
1611
+
ret = uniwill_resume_fn_lock(data);
1612
+
if (ret < 0)
1613
+
return ret;
1614
+
1615
+
ret = uniwill_resume_super_key(data);
1648
1616
if (ret < 0)
1649
1617
return ret;
1650
1618
···
1683
1643
};
1684
1644
1685
1645
static struct uniwill_device_descriptor lapac71h_descriptor __initdata = {
1686
-
.features = UNIWILL_FEATURE_FN_LOCK_TOGGLE |
1687
-
UNIWILL_FEATURE_SUPER_KEY_TOGGLE |
1646
+
.features = UNIWILL_FEATURE_FN_LOCK |
1647
+
UNIWILL_FEATURE_SUPER_KEY |
1688
1648
UNIWILL_FEATURE_TOUCHPAD_TOGGLE |
1689
1649
UNIWILL_FEATURE_BATTERY |
1690
1650
UNIWILL_FEATURE_HWMON,
1691
1651
};
1692
1652
1693
1653
static struct uniwill_device_descriptor lapkc71f_descriptor __initdata = {
1694
-
.features = UNIWILL_FEATURE_FN_LOCK_TOGGLE |
1695
-
UNIWILL_FEATURE_SUPER_KEY_TOGGLE |
1654
+
.features = UNIWILL_FEATURE_FN_LOCK |
1655
+
UNIWILL_FEATURE_SUPER_KEY |
1696
1656
UNIWILL_FEATURE_TOUCHPAD_TOGGLE |
1697
1657
UNIWILL_FEATURE_LIGHTBAR |
1698
1658
UNIWILL_FEATURE_BATTERY |
+3
-3
drivers/platform/x86/uniwill/uniwill-wmi.h
+3
-3
drivers/platform/x86/uniwill/uniwill-wmi.h
···
64
64
#define UNIWILL_OSD_KB_LED_LEVEL3 0x3E
65
65
#define UNIWILL_OSD_KB_LED_LEVEL4 0x3F
66
66
67
-
#define UNIWILL_OSD_SUPER_KEY_LOCK_ENABLE 0x40
68
-
#define UNIWILL_OSD_SUPER_KEY_LOCK_DISABLE 0x41
67
+
#define UNIWILL_OSD_SUPER_KEY_DISABLE 0x40
68
+
#define UNIWILL_OSD_SUPER_KEY_ENABLE 0x41
69
69
70
70
#define UNIWILL_OSD_MENU_JP 0x42
71
71
···
74
74
75
75
#define UNIWILL_OSD_RFKILL 0xA4
76
76
77
-
#define UNIWILL_OSD_SUPER_KEY_LOCK_CHANGED 0xA5
77
+
#define UNIWILL_OSD_SUPER_KEY_STATE_CHANGED 0xA5
78
78
79
79
#define UNIWILL_OSD_LIGHTBAR_STATE_CHANGED 0xA6
80
80
+7
-7
include/linux/platform_data/mlxreg.h
+7
-7
include/linux/platform_data/mlxreg.h
···
13
13
/**
14
14
* enum mlxreg_wdt_type - type of HW watchdog
15
15
*
16
-
* TYPE1 HW watchdog implementation exist in old systems.
17
-
* All new systems have TYPE2 HW watchdog.
18
-
* TYPE3 HW watchdog can exist on all systems with new CPLD.
19
-
* TYPE3 is selected by WD capability bit.
16
+
* @MLX_WDT_TYPE1: HW watchdog implementation in old systems.
17
+
* @MLX_WDT_TYPE2: All new systems have TYPE2 HW watchdog.
18
+
* @MLX_WDT_TYPE3: HW watchdog that can exist on all systems with new CPLD.
19
+
* TYPE3 is selected by WD capability bit.
20
20
*/
21
21
enum mlxreg_wdt_type {
22
22
MLX_WDT_TYPE1,
···
35
35
* @MLXREG_HOTPLUG_LC_SYNCED: entry for line card synchronization events, coming
36
36
* after hardware-firmware synchronization handshake;
37
37
* @MLXREG_HOTPLUG_LC_READY: entry for line card ready events, indicating line card
38
-
PHYs ready / unready state;
38
+
* PHYs ready / unready state;
39
39
* @MLXREG_HOTPLUG_LC_ACTIVE: entry for line card active events, indicating firmware
40
40
* availability / unavailability for the ports on line card;
41
41
* @MLXREG_HOTPLUG_LC_THERMAL: entry for line card thermal shutdown events, positive
···
123
123
* @reg_pwr: attribute power register;
124
124
* @reg_ena: attribute enable register;
125
125
* @mode: access mode;
126
-
* @np - pointer to node platform associated with attribute;
127
-
* @hpdev - hotplug device data;
126
+
* @np: pointer to node platform associated with attribute;
127
+
* @hpdev: hotplug device data;
128
128
* @notifier: pointer to event notifier block;
129
129
* @health_cntr: dynamic device health indication counter;
130
130
* @attached: true if device has been attached after good health indication;
+3
-2
include/linux/platform_data/x86/int3472.h
+3
-2
include/linux/platform_data/x86/int3472.h
···
26
26
#define INT3472_GPIO_TYPE_POWER_ENABLE 0x0b
27
27
#define INT3472_GPIO_TYPE_CLK_ENABLE 0x0c
28
28
#define INT3472_GPIO_TYPE_PRIVACY_LED 0x0d
29
+
#define INT3472_GPIO_TYPE_DOVDD 0x10
29
30
#define INT3472_GPIO_TYPE_HANDSHAKE 0x12
30
31
#define INT3472_GPIO_TYPE_HOTPLUG_DETECT 0x13
31
32
···
34
33
#define INT3472_MAX_SENSOR_GPIOS 3
35
34
#define INT3472_MAX_REGULATORS 3
36
35
37
-
/* E.g. "avdd\0" */
38
-
#define GPIO_SUPPLY_NAME_LENGTH 5
36
+
/* E.g. "dovdd\0" */
37
+
#define GPIO_SUPPLY_NAME_LENGTH 6
39
38
/* 12 chars for acpi_dev_name() + "-", e.g. "ABCD1234:00-" */
40
39
#define GPIO_REGULATOR_NAME_LENGTH (12 + GPIO_SUPPLY_NAME_LENGTH)
41
40
/* lower- and upper-case mapping */