1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Surface GPE/Lid driver to enable wakeup from suspend via the lid by 4 * properly configuring the respective GPEs. Required for wakeup via lid on 5 * newer Intel-based Microsoft Surface devices. 6 * 7 * Copyright (C) 2020-2022 Maximilian Luz <luzmaximilian@gmail.com> 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <linux/acpi.h> 13 #include <linux/dmi.h> 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/platform_device.h> 17 18 /* 19 * Note: The GPE numbers for the lid devices found below have been obtained 20 * from ACPI/the DSDT table, specifically from the GPE handler for the 21 * lid. 22 */ 23 24 static const struct property_entry lid_device_props_l17[] = { 25 PROPERTY_ENTRY_U32("gpe", 0x17), 26 {}, 27 }; 28 29 static const struct property_entry lid_device_props_l4B[] = { 30 PROPERTY_ENTRY_U32("gpe", 0x4B), 31 {}, 32 }; 33 34 static const struct property_entry lid_device_props_l4D[] = { 35 PROPERTY_ENTRY_U32("gpe", 0x4D), 36 {}, 37 }; 38 39 static const struct property_entry lid_device_props_l4F[] = { 40 PROPERTY_ENTRY_U32("gpe", 0x4F), 41 {}, 42 }; 43 44 static const struct property_entry lid_device_props_l57[] = { 45 PROPERTY_ENTRY_U32("gpe", 0x57), 46 {}, 47 }; 48 49 /* 50 * Note: When changing this, don't forget to check that the MODULE_ALIAS below 51 * still fits. 52 */ 53 static const struct dmi_system_id dmi_lid_device_table[] = { 54 { 55 .ident = "Surface Pro 4", 56 .matches = { 57 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 58 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Pro 4"), 59 }, 60 .driver_data = (void *)lid_device_props_l17, 61 }, 62 { 63 .ident = "Surface Pro 5", 64 .matches = { 65 /* 66 * We match for SKU here due to generic product name 67 * "Surface Pro". 68 */ 69 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 70 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Pro_1796"), 71 }, 72 .driver_data = (void *)lid_device_props_l4F, 73 }, 74 { 75 .ident = "Surface Pro 5 (LTE)", 76 .matches = { 77 /* 78 * We match for SKU here due to generic product name 79 * "Surface Pro" 80 */ 81 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 82 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Pro_1807"), 83 }, 84 .driver_data = (void *)lid_device_props_l4F, 85 }, 86 { 87 .ident = "Surface Pro 6", 88 .matches = { 89 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 90 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Pro 6"), 91 }, 92 .driver_data = (void *)lid_device_props_l4F, 93 }, 94 { 95 .ident = "Surface Pro 7", 96 .matches = { 97 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 98 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Pro 7"), 99 }, 100 .driver_data = (void *)lid_device_props_l4D, 101 }, 102 { 103 .ident = "Surface Pro 8", 104 .matches = { 105 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 106 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Pro 8"), 107 }, 108 .driver_data = (void *)lid_device_props_l4B, 109 }, 110 { 111 .ident = "Surface Book 1", 112 .matches = { 113 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 114 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book"), 115 }, 116 .driver_data = (void *)lid_device_props_l17, 117 }, 118 { 119 .ident = "Surface Book 2", 120 .matches = { 121 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 122 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book 2"), 123 }, 124 .driver_data = (void *)lid_device_props_l17, 125 }, 126 { 127 .ident = "Surface Book 3", 128 .matches = { 129 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 130 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book 3"), 131 }, 132 .driver_data = (void *)lid_device_props_l4D, 133 }, 134 { 135 .ident = "Surface Laptop 1", 136 .matches = { 137 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 138 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop"), 139 }, 140 .driver_data = (void *)lid_device_props_l57, 141 }, 142 { 143 .ident = "Surface Laptop 2", 144 .matches = { 145 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 146 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop 2"), 147 }, 148 .driver_data = (void *)lid_device_props_l57, 149 }, 150 { 151 .ident = "Surface Laptop 3 (Intel 13\")", 152 .matches = { 153 /* 154 * We match for SKU here due to different variants: The 155 * AMD (15") version does not rely on GPEs. 156 */ 157 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 158 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Laptop_3_1867:1868"), 159 }, 160 .driver_data = (void *)lid_device_props_l4D, 161 }, 162 { 163 .ident = "Surface Laptop 3 (Intel 15\")", 164 .matches = { 165 /* 166 * We match for SKU here due to different variants: The 167 * AMD (15") version does not rely on GPEs. 168 */ 169 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 170 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Laptop_3_1872"), 171 }, 172 .driver_data = (void *)lid_device_props_l4D, 173 }, 174 { 175 .ident = "Surface Laptop 4 (Intel 13\")", 176 .matches = { 177 /* 178 * We match for SKU here due to different variants: The 179 * AMD (15") version does not rely on GPEs. 180 */ 181 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 182 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Laptop_4_1950:1951"), 183 }, 184 .driver_data = (void *)lid_device_props_l4B, 185 }, 186 { 187 .ident = "Surface Laptop Studio", 188 .matches = { 189 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 190 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop Studio"), 191 }, 192 .driver_data = (void *)lid_device_props_l4B, 193 }, 194 { } 195 }; 196 197 struct surface_lid_device { 198 u32 gpe_number; 199 }; 200 201 static int surface_lid_enable_wakeup(struct device *dev, bool enable) 202 { 203 const struct surface_lid_device *lid = dev_get_drvdata(dev); 204 int action = enable ? ACPI_GPE_ENABLE : ACPI_GPE_DISABLE; 205 acpi_status status; 206 207 status = acpi_set_gpe_wake_mask(NULL, lid->gpe_number, action); 208 if (ACPI_FAILURE(status)) { 209 dev_err(dev, "failed to set GPE wake mask: %s\n", 210 acpi_format_exception(status)); 211 return -EINVAL; 212 } 213 214 return 0; 215 } 216 217 static int __maybe_unused surface_gpe_suspend(struct device *dev) 218 { 219 return surface_lid_enable_wakeup(dev, true); 220 } 221 222 static int __maybe_unused surface_gpe_resume(struct device *dev) 223 { 224 return surface_lid_enable_wakeup(dev, false); 225 } 226 227 static SIMPLE_DEV_PM_OPS(surface_gpe_pm, surface_gpe_suspend, surface_gpe_resume); 228 229 static int surface_gpe_probe(struct platform_device *pdev) 230 { 231 struct surface_lid_device *lid; 232 u32 gpe_number; 233 acpi_status status; 234 int ret; 235 236 ret = device_property_read_u32(&pdev->dev, "gpe", &gpe_number); 237 if (ret) { 238 dev_err(&pdev->dev, "failed to read 'gpe' property: %d\n", ret); 239 return ret; 240 } 241 242 lid = devm_kzalloc(&pdev->dev, sizeof(*lid), GFP_KERNEL); 243 if (!lid) 244 return -ENOMEM; 245 246 lid->gpe_number = gpe_number; 247 platform_set_drvdata(pdev, lid); 248 249 status = acpi_mark_gpe_for_wake(NULL, gpe_number); 250 if (ACPI_FAILURE(status)) { 251 dev_err(&pdev->dev, "failed to mark GPE for wake: %s\n", 252 acpi_format_exception(status)); 253 return -EINVAL; 254 } 255 256 status = acpi_enable_gpe(NULL, gpe_number); 257 if (ACPI_FAILURE(status)) { 258 dev_err(&pdev->dev, "failed to enable GPE: %s\n", 259 acpi_format_exception(status)); 260 return -EINVAL; 261 } 262 263 ret = surface_lid_enable_wakeup(&pdev->dev, false); 264 if (ret) 265 acpi_disable_gpe(NULL, gpe_number); 266 267 return ret; 268 } 269 270 static void surface_gpe_remove(struct platform_device *pdev) 271 { 272 struct surface_lid_device *lid = dev_get_drvdata(&pdev->dev); 273 274 /* restore default behavior without this module */ 275 surface_lid_enable_wakeup(&pdev->dev, false); 276 acpi_disable_gpe(NULL, lid->gpe_number); 277 } 278 279 static struct platform_driver surface_gpe_driver = { 280 .probe = surface_gpe_probe, 281 .remove_new = surface_gpe_remove, 282 .driver = { 283 .name = "surface_gpe", 284 .pm = &surface_gpe_pm, 285 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 286 }, 287 }; 288 289 static struct platform_device *surface_gpe_device; 290 291 static int __init surface_gpe_init(void) 292 { 293 const struct dmi_system_id *match; 294 struct platform_device *pdev; 295 struct fwnode_handle *fwnode; 296 int status; 297 298 match = dmi_first_match(dmi_lid_device_table); 299 if (!match) { 300 pr_info("no compatible Microsoft Surface device found, exiting\n"); 301 return -ENODEV; 302 } 303 304 status = platform_driver_register(&surface_gpe_driver); 305 if (status) 306 return status; 307 308 fwnode = fwnode_create_software_node(match->driver_data, NULL); 309 if (IS_ERR(fwnode)) { 310 status = PTR_ERR(fwnode); 311 goto err_node; 312 } 313 314 pdev = platform_device_alloc("surface_gpe", PLATFORM_DEVID_NONE); 315 if (!pdev) { 316 status = -ENOMEM; 317 goto err_alloc; 318 } 319 320 pdev->dev.fwnode = fwnode; 321 322 status = platform_device_add(pdev); 323 if (status) 324 goto err_add; 325 326 surface_gpe_device = pdev; 327 return 0; 328 329 err_add: 330 platform_device_put(pdev); 331 err_alloc: 332 fwnode_remove_software_node(fwnode); 333 err_node: 334 platform_driver_unregister(&surface_gpe_driver); 335 return status; 336 } 337 module_init(surface_gpe_init); 338 339 static void __exit surface_gpe_exit(void) 340 { 341 struct fwnode_handle *fwnode = surface_gpe_device->dev.fwnode; 342 343 platform_device_unregister(surface_gpe_device); 344 platform_driver_unregister(&surface_gpe_driver); 345 fwnode_remove_software_node(fwnode); 346 } 347 module_exit(surface_gpe_exit); 348 349 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>"); 350 MODULE_DESCRIPTION("Surface GPE/Lid Driver"); 351 MODULE_LICENSE("GPL"); 352 MODULE_ALIAS("dmi:*:svnMicrosoftCorporation:pnSurface*:*"); 353