1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Toshiba HDD Active Protection Sensor (HAPS) driver 4 * 5 * Copyright (C) 2014 Azael Avalos <coproscefalo@gmail.com> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/types.h> 14 #include <linux/acpi.h> 15 16 MODULE_AUTHOR("Azael Avalos <coproscefalo@gmail.com>"); 17 MODULE_DESCRIPTION("Toshiba HDD Active Protection Sensor"); 18 MODULE_LICENSE("GPL"); 19 20 struct toshiba_haps_dev { 21 struct acpi_device *acpi_dev; 22 23 int protection_level; 24 }; 25 26 static struct toshiba_haps_dev *toshiba_haps; 27 28 /* HAPS functions */ 29 static int toshiba_haps_reset_protection(acpi_handle handle) 30 { 31 acpi_status status; 32 33 status = acpi_evaluate_object(handle, "RSSS", NULL, NULL); 34 if (ACPI_FAILURE(status)) { 35 pr_err("Unable to reset the HDD protection\n"); 36 return -EIO; 37 } 38 39 return 0; 40 } 41 42 static int toshiba_haps_protection_level(acpi_handle handle, int level) 43 { 44 acpi_status status; 45 46 status = acpi_execute_simple_method(handle, "PTLV", level); 47 if (ACPI_FAILURE(status)) { 48 pr_err("Error while setting the protection level\n"); 49 return -EIO; 50 } 51 52 pr_debug("HDD protection level set to: %d\n", level); 53 54 return 0; 55 } 56 57 /* sysfs files */ 58 static ssize_t protection_level_show(struct device *dev, 59 struct device_attribute *attr, char *buf) 60 { 61 struct toshiba_haps_dev *haps = dev_get_drvdata(dev); 62 63 return sprintf(buf, "%i\n", haps->protection_level); 64 } 65 66 static ssize_t protection_level_store(struct device *dev, 67 struct device_attribute *attr, 68 const char *buf, size_t count) 69 { 70 struct toshiba_haps_dev *haps = dev_get_drvdata(dev); 71 int level; 72 int ret; 73 74 ret = kstrtoint(buf, 0, &level); 75 if (ret) 76 return ret; 77 /* 78 * Check for supported levels, which can be: 79 * 0 - Disabled | 1 - Low | 2 - Medium | 3 - High 80 */ 81 if (level < 0 || level > 3) 82 return -EINVAL; 83 84 /* Set the sensor level */ 85 ret = toshiba_haps_protection_level(haps->acpi_dev->handle, level); 86 if (ret != 0) 87 return ret; 88 89 haps->protection_level = level; 90 91 return count; 92 } 93 static DEVICE_ATTR_RW(protection_level); 94 95 static ssize_t reset_protection_store(struct device *dev, 96 struct device_attribute *attr, 97 const char *buf, size_t count) 98 { 99 struct toshiba_haps_dev *haps = dev_get_drvdata(dev); 100 int reset; 101 int ret; 102 103 ret = kstrtoint(buf, 0, &reset); 104 if (ret) 105 return ret; 106 /* The only accepted value is 1 */ 107 if (reset != 1) 108 return -EINVAL; 109 110 /* Reset the protection interface */ 111 ret = toshiba_haps_reset_protection(haps->acpi_dev->handle); 112 if (ret != 0) 113 return ret; 114 115 return count; 116 } 117 static DEVICE_ATTR_WO(reset_protection); 118 119 static struct attribute *haps_attributes[] = { 120 &dev_attr_protection_level.attr, 121 &dev_attr_reset_protection.attr, 122 NULL, 123 }; 124 125 static const struct attribute_group haps_attr_group = { 126 .attrs = haps_attributes, 127 }; 128 129 /* 130 * ACPI stuff 131 */ 132 static void toshiba_haps_notify(struct acpi_device *device, u32 event) 133 { 134 pr_debug("Received event: 0x%x\n", event); 135 136 acpi_bus_generate_netlink_event(device->pnp.device_class, 137 dev_name(&device->dev), 138 event, 0); 139 } 140 141 static void toshiba_haps_remove(struct acpi_device *device) 142 { 143 sysfs_remove_group(&device->dev.kobj, &haps_attr_group); 144 145 if (toshiba_haps) 146 toshiba_haps = NULL; 147 } 148 149 /* Helper function */ 150 static int toshiba_haps_available(acpi_handle handle) 151 { 152 acpi_status status; 153 u64 hdd_present; 154 155 /* 156 * A non existent device as well as having (only) 157 * Solid State Drives can cause the call to fail. 158 */ 159 status = acpi_evaluate_integer(handle, "_STA", NULL, &hdd_present); 160 if (ACPI_FAILURE(status)) { 161 pr_err("ACPI call to query HDD protection failed\n"); 162 return 0; 163 } 164 165 if (!hdd_present) { 166 pr_info("HDD protection not available or using SSD\n"); 167 return 0; 168 } 169 170 return 1; 171 } 172 173 static int toshiba_haps_add(struct acpi_device *acpi_dev) 174 { 175 struct toshiba_haps_dev *haps; 176 int ret; 177 178 if (toshiba_haps) 179 return -EBUSY; 180 181 if (!toshiba_haps_available(acpi_dev->handle)) 182 return -ENODEV; 183 184 pr_info("Toshiba HDD Active Protection Sensor device\n"); 185 186 haps = kzalloc(sizeof(struct toshiba_haps_dev), GFP_KERNEL); 187 if (!haps) 188 return -ENOMEM; 189 190 haps->acpi_dev = acpi_dev; 191 haps->protection_level = 2; 192 acpi_dev->driver_data = haps; 193 dev_set_drvdata(&acpi_dev->dev, haps); 194 195 /* Set the protection level, currently at level 2 (Medium) */ 196 ret = toshiba_haps_protection_level(acpi_dev->handle, 2); 197 if (ret != 0) 198 return ret; 199 200 ret = sysfs_create_group(&acpi_dev->dev.kobj, &haps_attr_group); 201 if (ret) 202 return ret; 203 204 toshiba_haps = haps; 205 206 return 0; 207 } 208 209 #ifdef CONFIG_PM_SLEEP 210 static int toshiba_haps_suspend(struct device *device) 211 { 212 struct toshiba_haps_dev *haps; 213 int ret; 214 215 haps = acpi_driver_data(to_acpi_device(device)); 216 217 /* Deactivate the protection on suspend */ 218 ret = toshiba_haps_protection_level(haps->acpi_dev->handle, 0); 219 220 return ret; 221 } 222 223 static int toshiba_haps_resume(struct device *device) 224 { 225 struct toshiba_haps_dev *haps; 226 int ret; 227 228 haps = acpi_driver_data(to_acpi_device(device)); 229 230 /* Set the stored protection level */ 231 ret = toshiba_haps_protection_level(haps->acpi_dev->handle, 232 haps->protection_level); 233 234 /* Reset the protection on resume */ 235 ret = toshiba_haps_reset_protection(haps->acpi_dev->handle); 236 if (ret != 0) 237 return ret; 238 239 return ret; 240 } 241 #endif 242 243 static SIMPLE_DEV_PM_OPS(toshiba_haps_pm, 244 toshiba_haps_suspend, toshiba_haps_resume); 245 246 static const struct acpi_device_id haps_device_ids[] = { 247 {"TOS620A", 0}, 248 {"", 0}, 249 }; 250 MODULE_DEVICE_TABLE(acpi, haps_device_ids); 251 252 static struct acpi_driver toshiba_haps_driver = { 253 .name = "Toshiba HAPS", 254 .owner = THIS_MODULE, 255 .ids = haps_device_ids, 256 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 257 .ops = { 258 .add = toshiba_haps_add, 259 .remove = toshiba_haps_remove, 260 .notify = toshiba_haps_notify, 261 }, 262 .drv.pm = &toshiba_haps_pm, 263 }; 264 265 module_acpi_driver(toshiba_haps_driver); 266