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/intel_vsec.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/pci.h>
16 #include <linux/slab.h>
17 #include <linux/uaccess.h>
18 #include <linux/overflow.h>
19
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 */
pmt_crashlog_complete(struct intel_pmt_entry * entry)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
pmt_crashlog_disabled(struct intel_pmt_entry * entry)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
pmt_crashlog_supported(struct intel_pmt_entry * entry)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
pmt_crashlog_set_disable(struct intel_pmt_entry * entry,bool disable)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
pmt_crashlog_set_clear(struct intel_pmt_entry * entry)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
pmt_crashlog_set_execute(struct intel_pmt_entry * entry)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
enable_show(struct device * dev,struct device_attribute * attr,char * buf)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
enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
trigger_show(struct device * dev,struct device_attribute * attr,char * buf)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
trigger_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
pmt_crashlog_header_decode(struct intel_pmt_entry * entry,struct device * dev)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 */
pmt_crashlog_remove(struct auxiliary_device * auxdev)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
pmt_crashlog_probe(struct auxiliary_device * auxdev,const struct auxiliary_device_id * id)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
pmt_crashlog_init(void)314 static int __init pmt_crashlog_init(void)
315 {
316 return auxiliary_driver_register(&pmt_crashlog_aux_driver);
317 }
318
pmt_crashlog_exit(void)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