1 /*
2  * EDAC PCI component
3  *
4  * Author: Dave Jiang <djiang@mvista.com>
5  *
6  * 2007 (c) MontaVista Software, Inc. This file is licensed under
7  * the terms of the GNU General Public License version 2. This program
8  * is licensed "as is" without any warranty of any kind, whether express
9  * or implied.
10  *
11  */
12 #include <asm/page.h>
13 #include <linux/uaccess.h>
14 #include <linux/ctype.h>
15 #include <linux/highmem.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/smp.h>
20 #include <linux/spinlock.h>
21 #include <linux/sysctl.h>
22 #include <linux/timer.h>
23 
24 #include "edac_pci.h"
25 #include "edac_module.h"
26 
27 static DEFINE_MUTEX(edac_pci_ctls_mutex);
28 static LIST_HEAD(edac_pci_list);
29 static atomic_t pci_indexes = ATOMIC_INIT(0);
30 
edac_pci_alloc_ctl_info(unsigned int sz_pvt,const char * edac_pci_name)31 struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt,
32 						const char *edac_pci_name)
33 {
34 	struct edac_pci_ctl_info *pci;
35 	void *p = NULL, *pvt;
36 	unsigned int size;
37 
38 	edac_dbg(1, "\n");
39 
40 	pci = edac_align_ptr(&p, sizeof(*pci), 1);
41 	pvt = edac_align_ptr(&p, 1, sz_pvt);
42 	size = ((unsigned long)pvt) + sz_pvt;
43 
44 	/* Alloc the needed control struct memory */
45 	pci = kzalloc(size, GFP_KERNEL);
46 	if (pci  == NULL)
47 		return NULL;
48 
49 	/* Now much private space */
50 	pvt = sz_pvt ? ((char *)pci) + ((unsigned long)pvt) : NULL;
51 
52 	pci->pvt_info = pvt;
53 	pci->op_state = OP_ALLOC;
54 
55 	snprintf(pci->name, strlen(edac_pci_name) + 1, "%s", edac_pci_name);
56 
57 	return pci;
58 }
59 EXPORT_SYMBOL_GPL(edac_pci_alloc_ctl_info);
60 
edac_pci_free_ctl_info(struct edac_pci_ctl_info * pci)61 void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci)
62 {
63 	edac_dbg(1, "\n");
64 
65 	edac_pci_remove_sysfs(pci);
66 }
67 EXPORT_SYMBOL_GPL(edac_pci_free_ctl_info);
68 
69 /*
70  * find_edac_pci_by_dev()
71  * 	scans the edac_pci list for a specific 'struct device *'
72  *
73  *	return NULL if not found, or return control struct pointer
74  */
find_edac_pci_by_dev(struct device * dev)75 static struct edac_pci_ctl_info *find_edac_pci_by_dev(struct device *dev)
76 {
77 	struct edac_pci_ctl_info *pci;
78 	struct list_head *item;
79 
80 	edac_dbg(1, "\n");
81 
82 	list_for_each(item, &edac_pci_list) {
83 		pci = list_entry(item, struct edac_pci_ctl_info, link);
84 
85 		if (pci->dev == dev)
86 			return pci;
87 	}
88 
89 	return NULL;
90 }
91 
92 /*
93  * add_edac_pci_to_global_list
94  * 	Before calling this function, caller must assign a unique value to
95  * 	edac_dev->pci_idx.
96  * 	Return:
97  * 		0 on success
98  * 		1 on failure
99  */
add_edac_pci_to_global_list(struct edac_pci_ctl_info * pci)100 static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci)
101 {
102 	struct list_head *item, *insert_before;
103 	struct edac_pci_ctl_info *rover;
104 
105 	edac_dbg(1, "\n");
106 
107 	insert_before = &edac_pci_list;
108 
109 	/* Determine if already on the list */
110 	rover = find_edac_pci_by_dev(pci->dev);
111 	if (unlikely(rover != NULL))
112 		goto fail0;
113 
114 	/* Insert in ascending order by 'pci_idx', so find position */
115 	list_for_each(item, &edac_pci_list) {
116 		rover = list_entry(item, struct edac_pci_ctl_info, link);
117 
118 		if (rover->pci_idx >= pci->pci_idx) {
119 			if (unlikely(rover->pci_idx == pci->pci_idx))
120 				goto fail1;
121 
122 			insert_before = item;
123 			break;
124 		}
125 	}
126 
127 	list_add_tail_rcu(&pci->link, insert_before);
128 	return 0;
129 
130 fail0:
131 	edac_printk(KERN_WARNING, EDAC_PCI,
132 		"%s (%s) %s %s already assigned %d\n",
133 		dev_name(rover->dev), edac_dev_name(rover),
134 		rover->mod_name, rover->ctl_name, rover->pci_idx);
135 	return 1;
136 
137 fail1:
138 	edac_printk(KERN_WARNING, EDAC_PCI,
139 		"but in low-level driver: attempt to assign\n"
140 		"\tduplicate pci_idx %d in %s()\n", rover->pci_idx,
141 		__func__);
142 	return 1;
143 }
144 
145 /*
146  * del_edac_pci_from_global_list
147  *
148  *	remove the PCI control struct from the global list
149  */
del_edac_pci_from_global_list(struct edac_pci_ctl_info * pci)150 static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci)
151 {
152 	list_del_rcu(&pci->link);
153 
154 	/* these are for safe removal of devices from global list while
155 	 * NMI handlers may be traversing list
156 	 */
157 	synchronize_rcu();
158 	INIT_LIST_HEAD(&pci->link);
159 }
160 
161 /*
162  * edac_pci_workq_function()
163  *
164  * 	periodic function that performs the operation
165  *	scheduled by a workq request, for a given PCI control struct
166  */
edac_pci_workq_function(struct work_struct * work_req)167 static void edac_pci_workq_function(struct work_struct *work_req)
168 {
169 	struct delayed_work *d_work = to_delayed_work(work_req);
170 	struct edac_pci_ctl_info *pci = to_edac_pci_ctl_work(d_work);
171 	int msec;
172 	unsigned long delay;
173 
174 	edac_dbg(3, "checking\n");
175 
176 	mutex_lock(&edac_pci_ctls_mutex);
177 
178 	if (pci->op_state != OP_RUNNING_POLL) {
179 		mutex_unlock(&edac_pci_ctls_mutex);
180 		return;
181 	}
182 
183 	if (edac_pci_get_check_errors())
184 		pci->edac_check(pci);
185 
186 	/* if we are on a one second period, then use round */
187 	msec = edac_pci_get_poll_msec();
188 	if (msec == 1000)
189 		delay = round_jiffies_relative(msecs_to_jiffies(msec));
190 	else
191 		delay = msecs_to_jiffies(msec);
192 
193 	edac_queue_work(&pci->work, delay);
194 
195 	mutex_unlock(&edac_pci_ctls_mutex);
196 }
197 
edac_pci_alloc_index(void)198 int edac_pci_alloc_index(void)
199 {
200 	return atomic_inc_return(&pci_indexes) - 1;
201 }
202 EXPORT_SYMBOL_GPL(edac_pci_alloc_index);
203 
edac_pci_add_device(struct edac_pci_ctl_info * pci,int edac_idx)204 int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx)
205 {
206 	edac_dbg(0, "\n");
207 
208 	pci->pci_idx = edac_idx;
209 	pci->start_time = jiffies;
210 
211 	mutex_lock(&edac_pci_ctls_mutex);
212 
213 	if (add_edac_pci_to_global_list(pci))
214 		goto fail0;
215 
216 	if (edac_pci_create_sysfs(pci)) {
217 		edac_pci_printk(pci, KERN_WARNING,
218 				"failed to create sysfs pci\n");
219 		goto fail1;
220 	}
221 
222 	if (pci->edac_check) {
223 		pci->op_state = OP_RUNNING_POLL;
224 
225 		INIT_DELAYED_WORK(&pci->work, edac_pci_workq_function);
226 		edac_queue_work(&pci->work, msecs_to_jiffies(edac_pci_get_poll_msec()));
227 
228 	} else {
229 		pci->op_state = OP_RUNNING_INTERRUPT;
230 	}
231 
232 	edac_pci_printk(pci, KERN_INFO,
233 		"Giving out device to module %s controller %s: DEV %s (%s)\n",
234 		pci->mod_name, pci->ctl_name, pci->dev_name,
235 		edac_op_state_to_string(pci->op_state));
236 
237 	mutex_unlock(&edac_pci_ctls_mutex);
238 	return 0;
239 
240 	/* error unwind stack */
241 fail1:
242 	del_edac_pci_from_global_list(pci);
243 fail0:
244 	mutex_unlock(&edac_pci_ctls_mutex);
245 	return 1;
246 }
247 EXPORT_SYMBOL_GPL(edac_pci_add_device);
248 
edac_pci_del_device(struct device * dev)249 struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev)
250 {
251 	struct edac_pci_ctl_info *pci;
252 
253 	edac_dbg(0, "\n");
254 
255 	mutex_lock(&edac_pci_ctls_mutex);
256 
257 	/* ensure the control struct is on the global list
258 	 * if not, then leave
259 	 */
260 	pci = find_edac_pci_by_dev(dev);
261 	if (pci  == NULL) {
262 		mutex_unlock(&edac_pci_ctls_mutex);
263 		return NULL;
264 	}
265 
266 	pci->op_state = OP_OFFLINE;
267 
268 	del_edac_pci_from_global_list(pci);
269 
270 	mutex_unlock(&edac_pci_ctls_mutex);
271 
272 	if (pci->edac_check)
273 		edac_stop_work(&pci->work);
274 
275 	edac_printk(KERN_INFO, EDAC_PCI,
276 		"Removed device %d for %s %s: DEV %s\n",
277 		pci->pci_idx, pci->mod_name, pci->ctl_name, edac_dev_name(pci));
278 
279 	return pci;
280 }
281 EXPORT_SYMBOL_GPL(edac_pci_del_device);
282 
283 /*
284  * edac_pci_generic_check
285  *
286  *	a Generic parity check API
287  */
edac_pci_generic_check(struct edac_pci_ctl_info * pci)288 static void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
289 {
290 	edac_dbg(4, "\n");
291 	edac_pci_do_parity_check();
292 }
293 
294 /* free running instance index counter */
295 static int edac_pci_idx;
296 #define EDAC_PCI_GENCTL_NAME	"EDAC PCI controller"
297 
298 struct edac_pci_gen_data {
299 	int edac_idx;
300 };
301 
edac_pci_create_generic_ctl(struct device * dev,const char * mod_name)302 struct edac_pci_ctl_info *edac_pci_create_generic_ctl(struct device *dev,
303 						const char *mod_name)
304 {
305 	struct edac_pci_ctl_info *pci;
306 	struct edac_pci_gen_data *pdata;
307 
308 	pci = edac_pci_alloc_ctl_info(sizeof(*pdata), EDAC_PCI_GENCTL_NAME);
309 	if (!pci)
310 		return NULL;
311 
312 	pdata = pci->pvt_info;
313 	pci->dev = dev;
314 	dev_set_drvdata(pci->dev, pci);
315 	pci->dev_name = pci_name(to_pci_dev(dev));
316 
317 	pci->mod_name = mod_name;
318 	pci->ctl_name = EDAC_PCI_GENCTL_NAME;
319 	if (edac_op_state == EDAC_OPSTATE_POLL)
320 		pci->edac_check = edac_pci_generic_check;
321 
322 	pdata->edac_idx = edac_pci_idx++;
323 
324 	if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
325 		edac_dbg(3, "failed edac_pci_add_device()\n");
326 		edac_pci_free_ctl_info(pci);
327 		return NULL;
328 	}
329 
330 	return pci;
331 }
332 EXPORT_SYMBOL_GPL(edac_pci_create_generic_ctl);
333 
edac_pci_release_generic_ctl(struct edac_pci_ctl_info * pci)334 void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci)
335 {
336 	edac_dbg(0, "pci mod=%s\n", pci->mod_name);
337 
338 	edac_pci_del_device(pci->dev);
339 	edac_pci_free_ctl_info(pci);
340 }
341 EXPORT_SYMBOL_GPL(edac_pci_release_generic_ctl);
342