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 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 Book 1", 104 .matches = { 105 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 106 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book"), 107 }, 108 .driver_data = (void *)lid_device_props_l17, 109 }, 110 { 111 .ident = "Surface Book 2", 112 .matches = { 113 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 114 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book 2"), 115 }, 116 .driver_data = (void *)lid_device_props_l17, 117 }, 118 { 119 .ident = "Surface Book 3", 120 .matches = { 121 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 122 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Book 3"), 123 }, 124 .driver_data = (void *)lid_device_props_l4D, 125 }, 126 { 127 .ident = "Surface Laptop 1", 128 .matches = { 129 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 130 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop"), 131 }, 132 .driver_data = (void *)lid_device_props_l57, 133 }, 134 { 135 .ident = "Surface Laptop 2", 136 .matches = { 137 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 138 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop 2"), 139 }, 140 .driver_data = (void *)lid_device_props_l57, 141 }, 142 { 143 .ident = "Surface Laptop 3 (Intel 13\")", 144 .matches = { 145 /* 146 * We match for SKU here due to different variants: The 147 * AMD (15") version does not rely on GPEs. 148 */ 149 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 150 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Laptop_3_1867:1868"), 151 }, 152 .driver_data = (void *)lid_device_props_l4D, 153 }, 154 { 155 .ident = "Surface Laptop 3 (Intel 15\")", 156 .matches = { 157 /* 158 * We match for SKU here due to different variants: The 159 * AMD (15") version does not rely on GPEs. 160 */ 161 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 162 DMI_EXACT_MATCH(DMI_PRODUCT_SKU, "Surface_Laptop_3_1872"), 163 }, 164 .driver_data = (void *)lid_device_props_l4D, 165 }, 166 { 167 .ident = "Surface Laptop Studio", 168 .matches = { 169 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), 170 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "Surface Laptop Studio"), 171 }, 172 .driver_data = (void *)lid_device_props_l4B, 173 }, 174 { } 175 }; 176 177 struct surface_lid_device { 178 u32 gpe_number; 179 }; 180 181 static int surface_lid_enable_wakeup(struct device *dev, bool enable) 182 { 183 const struct surface_lid_device *lid = dev_get_drvdata(dev); 184 int action = enable ? ACPI_GPE_ENABLE : ACPI_GPE_DISABLE; 185 acpi_status status; 186 187 status = acpi_set_gpe_wake_mask(NULL, lid->gpe_number, action); 188 if (ACPI_FAILURE(status)) { 189 dev_err(dev, "failed to set GPE wake mask: %s\n", 190 acpi_format_exception(status)); 191 return -EINVAL; 192 } 193 194 return 0; 195 } 196 197 static int __maybe_unused surface_gpe_suspend(struct device *dev) 198 { 199 return surface_lid_enable_wakeup(dev, true); 200 } 201 202 static int __maybe_unused surface_gpe_resume(struct device *dev) 203 { 204 return surface_lid_enable_wakeup(dev, false); 205 } 206 207 static SIMPLE_DEV_PM_OPS(surface_gpe_pm, surface_gpe_suspend, surface_gpe_resume); 208 209 static int surface_gpe_probe(struct platform_device *pdev) 210 { 211 struct surface_lid_device *lid; 212 u32 gpe_number; 213 acpi_status status; 214 int ret; 215 216 ret = device_property_read_u32(&pdev->dev, "gpe", &gpe_number); 217 if (ret) { 218 dev_err(&pdev->dev, "failed to read 'gpe' property: %d\n", ret); 219 return ret; 220 } 221 222 lid = devm_kzalloc(&pdev->dev, sizeof(*lid), GFP_KERNEL); 223 if (!lid) 224 return -ENOMEM; 225 226 lid->gpe_number = gpe_number; 227 platform_set_drvdata(pdev, lid); 228 229 status = acpi_mark_gpe_for_wake(NULL, gpe_number); 230 if (ACPI_FAILURE(status)) { 231 dev_err(&pdev->dev, "failed to mark GPE for wake: %s\n", 232 acpi_format_exception(status)); 233 return -EINVAL; 234 } 235 236 status = acpi_enable_gpe(NULL, gpe_number); 237 if (ACPI_FAILURE(status)) { 238 dev_err(&pdev->dev, "failed to enable GPE: %s\n", 239 acpi_format_exception(status)); 240 return -EINVAL; 241 } 242 243 ret = surface_lid_enable_wakeup(&pdev->dev, false); 244 if (ret) 245 acpi_disable_gpe(NULL, gpe_number); 246 247 return ret; 248 } 249 250 static int surface_gpe_remove(struct platform_device *pdev) 251 { 252 struct surface_lid_device *lid = dev_get_drvdata(&pdev->dev); 253 254 /* restore default behavior without this module */ 255 surface_lid_enable_wakeup(&pdev->dev, false); 256 acpi_disable_gpe(NULL, lid->gpe_number); 257 258 return 0; 259 } 260 261 static struct platform_driver surface_gpe_driver = { 262 .probe = surface_gpe_probe, 263 .remove = surface_gpe_remove, 264 .driver = { 265 .name = "surface_gpe", 266 .pm = &surface_gpe_pm, 267 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 268 }, 269 }; 270 271 static struct platform_device *surface_gpe_device; 272 273 static int __init surface_gpe_init(void) 274 { 275 const struct dmi_system_id *match; 276 struct platform_device *pdev; 277 struct fwnode_handle *fwnode; 278 int status; 279 280 match = dmi_first_match(dmi_lid_device_table); 281 if (!match) { 282 pr_info("no compatible Microsoft Surface device found, exiting\n"); 283 return -ENODEV; 284 } 285 286 status = platform_driver_register(&surface_gpe_driver); 287 if (status) 288 return status; 289 290 fwnode = fwnode_create_software_node(match->driver_data, NULL); 291 if (IS_ERR(fwnode)) { 292 status = PTR_ERR(fwnode); 293 goto err_node; 294 } 295 296 pdev = platform_device_alloc("surface_gpe", PLATFORM_DEVID_NONE); 297 if (!pdev) { 298 status = -ENOMEM; 299 goto err_alloc; 300 } 301 302 pdev->dev.fwnode = fwnode; 303 304 status = platform_device_add(pdev); 305 if (status) 306 goto err_add; 307 308 surface_gpe_device = pdev; 309 return 0; 310 311 err_add: 312 platform_device_put(pdev); 313 err_alloc: 314 fwnode_remove_software_node(fwnode); 315 err_node: 316 platform_driver_unregister(&surface_gpe_driver); 317 return status; 318 } 319 module_init(surface_gpe_init); 320 321 static void __exit surface_gpe_exit(void) 322 { 323 struct fwnode_handle *fwnode = surface_gpe_device->dev.fwnode; 324 325 platform_device_unregister(surface_gpe_device); 326 platform_driver_unregister(&surface_gpe_driver); 327 fwnode_remove_software_node(fwnode); 328 } 329 module_exit(surface_gpe_exit); 330 331 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>"); 332 MODULE_DESCRIPTION("Surface GPE/Lid Driver"); 333 MODULE_LICENSE("GPL"); 334 MODULE_ALIAS("dmi:*:svnMicrosoftCorporation:pnSurface*:*"); 335