1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Intel Platform Monitoring Technology Crashlog driver 4 * 5 * Copyright (c) 2020, Intel Corporation. 6 * All Rights Reserved. 7 * 8 * Author: "Alexander Duyck" <alexander.h.duyck@linux.intel.com> 9 */ 10 11 #include <linux/auxiliary_bus.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/pci.h> 15 #include <linux/slab.h> 16 #include <linux/uaccess.h> 17 #include <linux/overflow.h> 18 19 #include "../vsec.h" 20 #include "class.h" 21 22 /* Crashlog discovery header types */ 23 #define CRASH_TYPE_OOBMSM 1 24 25 /* Control Flags */ 26 #define CRASHLOG_FLAG_DISABLE BIT(28) 27 28 /* 29 * Bits 29 and 30 control the state of bit 31. 30 * 31 * Bit 29 will clear bit 31, if set, allowing a new crashlog to be captured. 32 * Bit 30 will immediately trigger a crashlog to be generated, setting bit 31. 33 * Bit 31 is the read-only status with a 1 indicating log is complete. 34 */ 35 #define CRASHLOG_FLAG_TRIGGER_CLEAR BIT(29) 36 #define CRASHLOG_FLAG_TRIGGER_EXECUTE BIT(30) 37 #define CRASHLOG_FLAG_TRIGGER_COMPLETE BIT(31) 38 #define CRASHLOG_FLAG_TRIGGER_MASK GENMASK(31, 28) 39 40 /* Crashlog Discovery Header */ 41 #define CONTROL_OFFSET 0x0 42 #define GUID_OFFSET 0x4 43 #define BASE_OFFSET 0x8 44 #define SIZE_OFFSET 0xC 45 #define GET_ACCESS(v) ((v) & GENMASK(3, 0)) 46 #define GET_TYPE(v) (((v) & GENMASK(7, 4)) >> 4) 47 #define GET_VERSION(v) (((v) & GENMASK(19, 16)) >> 16) 48 /* size is in bytes */ 49 #define GET_SIZE(v) ((v) * sizeof(u32)) 50 51 struct crashlog_entry { 52 /* entry must be first member of struct */ 53 struct intel_pmt_entry entry; 54 struct mutex control_mutex; 55 }; 56 57 struct pmt_crashlog_priv { 58 int num_entries; 59 struct crashlog_entry entry[]; 60 }; 61 62 /* 63 * I/O 64 */ 65 static bool pmt_crashlog_complete(struct intel_pmt_entry *entry) 66 { 67 u32 control = readl(entry->disc_table + CONTROL_OFFSET); 68 69 /* return current value of the crashlog complete flag */ 70 return !!(control & CRASHLOG_FLAG_TRIGGER_COMPLETE); 71 } 72 73 static bool pmt_crashlog_disabled(struct intel_pmt_entry *entry) 74 { 75 u32 control = readl(entry->disc_table + CONTROL_OFFSET); 76 77 /* return current value of the crashlog disabled flag */ 78 return !!(control & CRASHLOG_FLAG_DISABLE); 79 } 80 81 static bool pmt_crashlog_supported(struct intel_pmt_entry *entry) 82 { 83 u32 discovery_header = readl(entry->disc_table + CONTROL_OFFSET); 84 u32 crash_type, version; 85 86 crash_type = GET_TYPE(discovery_header); 87 version = GET_VERSION(discovery_header); 88 89 /* 90 * Currently we only recognize OOBMSM version 0 devices. 91 * We can ignore all other crashlog devices in the system. 92 */ 93 return crash_type == CRASH_TYPE_OOBMSM && version == 0; 94 } 95 96 static void pmt_crashlog_set_disable(struct intel_pmt_entry *entry, 97 bool disable) 98 { 99 u32 control = readl(entry->disc_table + CONTROL_OFFSET); 100 101 /* clear trigger bits so we are only modifying disable flag */ 102 control &= ~CRASHLOG_FLAG_TRIGGER_MASK; 103 104 if (disable) 105 control |= CRASHLOG_FLAG_DISABLE; 106 else 107 control &= ~CRASHLOG_FLAG_DISABLE; 108 109 writel(control, entry->disc_table + CONTROL_OFFSET); 110 } 111 112 static void pmt_crashlog_set_clear(struct intel_pmt_entry *entry) 113 { 114 u32 control = readl(entry->disc_table + CONTROL_OFFSET); 115 116 control &= ~CRASHLOG_FLAG_TRIGGER_MASK; 117 control |= CRASHLOG_FLAG_TRIGGER_CLEAR; 118 119 writel(control, entry->disc_table + CONTROL_OFFSET); 120 } 121 122 static void pmt_crashlog_set_execute(struct intel_pmt_entry *entry) 123 { 124 u32 control = readl(entry->disc_table + CONTROL_OFFSET); 125 126 control &= ~CRASHLOG_FLAG_TRIGGER_MASK; 127 control |= CRASHLOG_FLAG_TRIGGER_EXECUTE; 128 129 writel(control, entry->disc_table + CONTROL_OFFSET); 130 } 131 132 /* 133 * sysfs 134 */ 135 static ssize_t 136 enable_show(struct device *dev, struct device_attribute *attr, char *buf) 137 { 138 struct intel_pmt_entry *entry = dev_get_drvdata(dev); 139 int enabled = !pmt_crashlog_disabled(entry); 140 141 return sprintf(buf, "%d\n", enabled); 142 } 143 144 static ssize_t 145 enable_store(struct device *dev, struct device_attribute *attr, 146 const char *buf, size_t count) 147 { 148 struct crashlog_entry *entry; 149 bool enabled; 150 int result; 151 152 entry = dev_get_drvdata(dev); 153 154 result = kstrtobool(buf, &enabled); 155 if (result) 156 return result; 157 158 mutex_lock(&entry->control_mutex); 159 pmt_crashlog_set_disable(&entry->entry, !enabled); 160 mutex_unlock(&entry->control_mutex); 161 162 return count; 163 } 164 static DEVICE_ATTR_RW(enable); 165 166 static ssize_t 167 trigger_show(struct device *dev, struct device_attribute *attr, char *buf) 168 { 169 struct intel_pmt_entry *entry; 170 int trigger; 171 172 entry = dev_get_drvdata(dev); 173 trigger = pmt_crashlog_complete(entry); 174 175 return sprintf(buf, "%d\n", trigger); 176 } 177 178 static ssize_t 179 trigger_store(struct device *dev, struct device_attribute *attr, 180 const char *buf, size_t count) 181 { 182 struct crashlog_entry *entry; 183 bool trigger; 184 int result; 185 186 entry = dev_get_drvdata(dev); 187 188 result = kstrtobool(buf, &trigger); 189 if (result) 190 return result; 191 192 mutex_lock(&entry->control_mutex); 193 194 if (!trigger) { 195 pmt_crashlog_set_clear(&entry->entry); 196 } else if (pmt_crashlog_complete(&entry->entry)) { 197 /* we cannot trigger a new crash if one is still pending */ 198 result = -EEXIST; 199 goto err; 200 } else if (pmt_crashlog_disabled(&entry->entry)) { 201 /* if device is currently disabled, return busy */ 202 result = -EBUSY; 203 goto err; 204 } else { 205 pmt_crashlog_set_execute(&entry->entry); 206 } 207 208 result = count; 209 err: 210 mutex_unlock(&entry->control_mutex); 211 return result; 212 } 213 static DEVICE_ATTR_RW(trigger); 214 215 static struct attribute *pmt_crashlog_attrs[] = { 216 &dev_attr_enable.attr, 217 &dev_attr_trigger.attr, 218 NULL 219 }; 220 221 static const struct attribute_group pmt_crashlog_group = { 222 .attrs = pmt_crashlog_attrs, 223 }; 224 225 static int pmt_crashlog_header_decode(struct intel_pmt_entry *entry, 226 struct device *dev) 227 { 228 void __iomem *disc_table = entry->disc_table; 229 struct intel_pmt_header *header = &entry->header; 230 struct crashlog_entry *crashlog; 231 232 if (!pmt_crashlog_supported(entry)) 233 return 1; 234 235 /* initialize control mutex */ 236 crashlog = container_of(entry, struct crashlog_entry, entry); 237 mutex_init(&crashlog->control_mutex); 238 239 header->access_type = GET_ACCESS(readl(disc_table)); 240 header->guid = readl(disc_table + GUID_OFFSET); 241 header->base_offset = readl(disc_table + BASE_OFFSET); 242 243 /* Size is measured in DWORDS, but accessor returns bytes */ 244 header->size = GET_SIZE(readl(disc_table + SIZE_OFFSET)); 245 246 return 0; 247 } 248 249 static DEFINE_XARRAY_ALLOC(crashlog_array); 250 static struct intel_pmt_namespace pmt_crashlog_ns = { 251 .name = "crashlog", 252 .xa = &crashlog_array, 253 .attr_grp = &pmt_crashlog_group, 254 .pmt_header_decode = pmt_crashlog_header_decode, 255 }; 256 257 /* 258 * initialization 259 */ 260 static void pmt_crashlog_remove(struct auxiliary_device *auxdev) 261 { 262 struct pmt_crashlog_priv *priv = auxiliary_get_drvdata(auxdev); 263 int i; 264 265 for (i = 0; i < priv->num_entries; i++) 266 intel_pmt_dev_destroy(&priv->entry[i].entry, &pmt_crashlog_ns); 267 } 268 269 static int pmt_crashlog_probe(struct auxiliary_device *auxdev, 270 const struct auxiliary_device_id *id) 271 { 272 struct intel_vsec_device *intel_vsec_dev = auxdev_to_ivdev(auxdev); 273 struct pmt_crashlog_priv *priv; 274 size_t size; 275 int i, ret; 276 277 size = struct_size(priv, entry, intel_vsec_dev->num_resources); 278 priv = devm_kzalloc(&auxdev->dev, size, GFP_KERNEL); 279 if (!priv) 280 return -ENOMEM; 281 282 auxiliary_set_drvdata(auxdev, priv); 283 284 for (i = 0; i < intel_vsec_dev->num_resources; i++) { 285 struct intel_pmt_entry *entry = &priv->entry[priv->num_entries].entry; 286 287 ret = intel_pmt_dev_create(entry, &pmt_crashlog_ns, intel_vsec_dev, i); 288 if (ret < 0) 289 goto abort_probe; 290 if (ret) 291 continue; 292 293 priv->num_entries++; 294 } 295 296 return 0; 297 abort_probe: 298 pmt_crashlog_remove(auxdev); 299 return ret; 300 } 301 302 static const struct auxiliary_device_id pmt_crashlog_id_table[] = { 303 { .name = "intel_vsec.crashlog" }, 304 {} 305 }; 306 MODULE_DEVICE_TABLE(auxiliary, pmt_crashlog_id_table); 307 308 static struct auxiliary_driver pmt_crashlog_aux_driver = { 309 .id_table = pmt_crashlog_id_table, 310 .remove = pmt_crashlog_remove, 311 .probe = pmt_crashlog_probe, 312 }; 313 314 static int __init pmt_crashlog_init(void) 315 { 316 return auxiliary_driver_register(&pmt_crashlog_aux_driver); 317 } 318 319 static void __exit pmt_crashlog_exit(void) 320 { 321 auxiliary_driver_unregister(&pmt_crashlog_aux_driver); 322 xa_destroy(&crashlog_array); 323 } 324 325 module_init(pmt_crashlog_init); 326 module_exit(pmt_crashlog_exit); 327 328 MODULE_AUTHOR("Alexander Duyck <alexander.h.duyck@linux.intel.com>"); 329 MODULE_DESCRIPTION("Intel PMT Crashlog driver"); 330 MODULE_LICENSE("GPL v2"); 331 MODULE_IMPORT_NS(INTEL_PMT); 332