1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/proc_fs.h> 3 #include <linux/seq_file.h> 4 #include <linux/export.h> 5 #include <linux/suspend.h> 6 #include <linux/bcd.h> 7 #include <linux/acpi.h> 8 #include <linux/uaccess.h> 9 10 #include "sleep.h" 11 #include "internal.h" 12 13 #define _COMPONENT ACPI_SYSTEM_COMPONENT 14 15 /* 16 * this file provides support for: 17 * /proc/acpi/wakeup 18 */ 19 20 ACPI_MODULE_NAME("sleep") 21 22 static int 23 acpi_system_wakeup_device_seq_show(struct seq_file *seq, void *offset) 24 { 25 struct list_head *node, *next; 26 27 seq_printf(seq, "Device\tS-state\t Status Sysfs node\n"); 28 29 mutex_lock(&acpi_device_lock); 30 list_for_each_safe(node, next, &acpi_wakeup_device_list) { 31 struct acpi_device *dev = 32 container_of(node, struct acpi_device, wakeup_list); 33 struct acpi_device_physical_node *entry; 34 35 if (!dev->wakeup.flags.valid) 36 continue; 37 38 seq_printf(seq, "%s\t S%d\t", 39 dev->pnp.bus_id, 40 (u32) dev->wakeup.sleep_state); 41 42 mutex_lock(&dev->physical_node_lock); 43 44 if (!dev->physical_node_count) { 45 seq_printf(seq, "%c%-8s\n", 46 dev->wakeup.flags.valid ? '*' : ' ', 47 device_may_wakeup(&dev->dev) ? 48 "enabled" : "disabled"); 49 } else { 50 struct device *ldev; 51 list_for_each_entry(entry, &dev->physical_node_list, 52 node) { 53 ldev = get_device(entry->dev); 54 if (!ldev) 55 continue; 56 57 if (&entry->node != 58 dev->physical_node_list.next) 59 seq_printf(seq, "\t\t"); 60 61 seq_printf(seq, "%c%-8s %s:%s\n", 62 dev->wakeup.flags.valid ? '*' : ' ', 63 (device_may_wakeup(&dev->dev) || 64 device_may_wakeup(ldev)) ? 65 "enabled" : "disabled", 66 ldev->bus ? ldev->bus->name : 67 "no-bus", dev_name(ldev)); 68 put_device(ldev); 69 } 70 } 71 72 mutex_unlock(&dev->physical_node_lock); 73 } 74 mutex_unlock(&acpi_device_lock); 75 return 0; 76 } 77 78 static void physical_device_enable_wakeup(struct acpi_device *adev) 79 { 80 struct acpi_device_physical_node *entry; 81 82 mutex_lock(&adev->physical_node_lock); 83 84 list_for_each_entry(entry, 85 &adev->physical_node_list, node) 86 if (entry->dev && device_can_wakeup(entry->dev)) { 87 bool enable = !device_may_wakeup(entry->dev); 88 device_set_wakeup_enable(entry->dev, enable); 89 } 90 91 mutex_unlock(&adev->physical_node_lock); 92 } 93 94 static ssize_t 95 acpi_system_write_wakeup_device(struct file *file, 96 const char __user * buffer, 97 size_t count, loff_t * ppos) 98 { 99 struct list_head *node, *next; 100 char strbuf[5]; 101 char str[5] = ""; 102 103 if (count > 4) 104 count = 4; 105 106 if (copy_from_user(strbuf, buffer, count)) 107 return -EFAULT; 108 strbuf[count] = '\0'; 109 sscanf(strbuf, "%s", str); 110 111 mutex_lock(&acpi_device_lock); 112 list_for_each_safe(node, next, &acpi_wakeup_device_list) { 113 struct acpi_device *dev = 114 container_of(node, struct acpi_device, wakeup_list); 115 if (!dev->wakeup.flags.valid) 116 continue; 117 118 if (!strncmp(dev->pnp.bus_id, str, 4)) { 119 if (device_can_wakeup(&dev->dev)) { 120 bool enable = !device_may_wakeup(&dev->dev); 121 device_set_wakeup_enable(&dev->dev, enable); 122 } else { 123 physical_device_enable_wakeup(dev); 124 } 125 break; 126 } 127 } 128 mutex_unlock(&acpi_device_lock); 129 return count; 130 } 131 132 static int 133 acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file) 134 { 135 return single_open(file, acpi_system_wakeup_device_seq_show, 136 PDE_DATA(inode)); 137 } 138 139 static const struct proc_ops acpi_system_wakeup_device_proc_ops = { 140 .proc_open = acpi_system_wakeup_device_open_fs, 141 .proc_read = seq_read, 142 .proc_write = acpi_system_write_wakeup_device, 143 .proc_lseek = seq_lseek, 144 .proc_release = single_release, 145 }; 146 147 void __init acpi_sleep_proc_init(void) 148 { 149 /* 'wakeup device' [R/W] */ 150 proc_create("wakeup", S_IFREG | S_IRUGO | S_IWUSR, 151 acpi_root_dir, &acpi_system_wakeup_device_proc_ops); 152 } 153