GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / edac / debugfs.c
1 #include "edac_module.h"
2
3 static struct dentry *edac_debugfs;
4
5 static ssize_t edac_fake_inject_write(struct file *file,
6                                       const char __user *data,
7                                       size_t count, loff_t *ppos)
8 {
9         struct device *dev = file->private_data;
10         struct mem_ctl_info *mci = to_mci(dev);
11         static enum hw_event_mc_err_type type;
12         u16 errcount = mci->fake_inject_count;
13
14         if (!errcount)
15                 errcount = 1;
16
17         type = mci->fake_inject_ue ? HW_EVENT_ERR_UNCORRECTED
18                                    : HW_EVENT_ERR_CORRECTED;
19
20         printk(KERN_DEBUG
21                "Generating %d %s fake error%s to %d.%d.%d to test core handling. NOTE: this won't test the driver-specific decoding logic.\n",
22                 errcount,
23                 (type == HW_EVENT_ERR_UNCORRECTED) ? "UE" : "CE",
24                 errcount > 1 ? "s" : "",
25                 mci->fake_inject_layer[0],
26                 mci->fake_inject_layer[1],
27                 mci->fake_inject_layer[2]
28                );
29         edac_mc_handle_error(type, mci, errcount, 0, 0, 0,
30                              mci->fake_inject_layer[0],
31                              mci->fake_inject_layer[1],
32                              mci->fake_inject_layer[2],
33                              "FAKE ERROR", "for EDAC testing only");
34
35         return count;
36 }
37
38 static const struct file_operations debug_fake_inject_fops = {
39         .open = simple_open,
40         .write = edac_fake_inject_write,
41         .llseek = generic_file_llseek,
42 };
43
44 int __init edac_debugfs_init(void)
45 {
46         edac_debugfs = debugfs_create_dir("edac", NULL);
47         if (IS_ERR(edac_debugfs)) {
48                 edac_debugfs = NULL;
49                 return -ENOMEM;
50         }
51         return 0;
52 }
53
54 void edac_debugfs_exit(void)
55 {
56         debugfs_remove(edac_debugfs);
57 }
58
59 int edac_create_debugfs_nodes(struct mem_ctl_info *mci)
60 {
61         struct dentry *d, *parent;
62         char name[80];
63         int i;
64
65         if (!edac_debugfs)
66                 return -ENODEV;
67
68         d = debugfs_create_dir(mci->dev.kobj.name, edac_debugfs);
69         if (!d)
70                 return -ENOMEM;
71         parent = d;
72
73         for (i = 0; i < mci->n_layers; i++) {
74                 sprintf(name, "fake_inject_%s",
75                              edac_layer_name[mci->layers[i].type]);
76                 d = debugfs_create_u8(name, S_IRUGO | S_IWUSR, parent,
77                                       &mci->fake_inject_layer[i]);
78                 if (!d)
79                         goto nomem;
80         }
81
82         d = debugfs_create_bool("fake_inject_ue", S_IRUGO | S_IWUSR, parent,
83                                 &mci->fake_inject_ue);
84         if (!d)
85                 goto nomem;
86
87         d = debugfs_create_u16("fake_inject_count", S_IRUGO | S_IWUSR, parent,
88                                 &mci->fake_inject_count);
89         if (!d)
90                 goto nomem;
91
92         d = debugfs_create_file("fake_inject", S_IWUSR, parent,
93                                 &mci->dev,
94                                 &debug_fake_inject_fops);
95         if (!d)
96                 goto nomem;
97
98         mci->debugfs = parent;
99         return 0;
100 nomem:
101         edac_debugfs_remove_recursive(mci->debugfs);
102         return -ENOMEM;
103 }
104
105 /* Create a toplevel dir under EDAC's debugfs hierarchy */
106 struct dentry *edac_debugfs_create_dir(const char *dirname)
107 {
108         if (!edac_debugfs)
109                 return NULL;
110
111         return debugfs_create_dir(dirname, edac_debugfs);
112 }
113 EXPORT_SYMBOL_GPL(edac_debugfs_create_dir);
114
115 /* Create a toplevel dir under EDAC's debugfs hierarchy with parent @parent */
116 struct dentry *
117 edac_debugfs_create_dir_at(const char *dirname, struct dentry *parent)
118 {
119         return debugfs_create_dir(dirname, parent);
120 }
121 EXPORT_SYMBOL_GPL(edac_debugfs_create_dir_at);
122
123 /*
124  * Create a file under EDAC's hierarchy or a sub-hierarchy:
125  *
126  * @name: file name
127  * @mode: file permissions
128  * @parent: parent dentry. If NULL, it becomes the toplevel EDAC dir
129  * @data: private data of caller
130  * @fops: file operations of this file
131  */
132 struct dentry *
133 edac_debugfs_create_file(const char *name, umode_t mode, struct dentry *parent,
134                          void *data, const struct file_operations *fops)
135 {
136         if (!parent)
137                 parent = edac_debugfs;
138
139         return debugfs_create_file(name, mode, parent, data, fops);
140 }
141 EXPORT_SYMBOL_GPL(edac_debugfs_create_file);
142
143 /* Wrapper for debugfs_create_x8() */
144 struct dentry *edac_debugfs_create_x8(const char *name, umode_t mode,
145                                        struct dentry *parent, u8 *value)
146 {
147         if (!parent)
148                 parent = edac_debugfs;
149
150         return debugfs_create_x8(name, mode, parent, value);
151 }
152 EXPORT_SYMBOL_GPL(edac_debugfs_create_x8);
153
154 /* Wrapper for debugfs_create_x16() */
155 struct dentry *edac_debugfs_create_x16(const char *name, umode_t mode,
156                                        struct dentry *parent, u16 *value)
157 {
158         if (!parent)
159                 parent = edac_debugfs;
160
161         return debugfs_create_x16(name, mode, parent, value);
162 }
163 EXPORT_SYMBOL_GPL(edac_debugfs_create_x16);