Commit | Line | Data |
---|---|---|
da9bb1d2 AC |
1 | /* |
2 | * edac_mc kernel module | |
49c0dab7 | 3 | * (C) 2005, 2006 Linux Networx (http://lnxi.com) |
da9bb1d2 AC |
4 | * This file may be distributed under the terms of the |
5 | * GNU General Public License. | |
6 | * | |
7 | * Written by Thayne Harbaugh | |
8 | * Based on work by Dan Hollis <goemon at anime dot net> and others. | |
9 | * http://www.anime.net/~goemon/linux-ecc/ | |
10 | * | |
11 | * Modified by Dave Peterson and Doug Thompson | |
12 | * | |
13 | */ | |
14 | ||
da9bb1d2 AC |
15 | #include <linux/module.h> |
16 | #include <linux/proc_fs.h> | |
17 | #include <linux/kernel.h> | |
18 | #include <linux/types.h> | |
19 | #include <linux/smp.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/sysctl.h> | |
22 | #include <linux/highmem.h> | |
23 | #include <linux/timer.h> | |
24 | #include <linux/slab.h> | |
25 | #include <linux/jiffies.h> | |
26 | #include <linux/spinlock.h> | |
27 | #include <linux/list.h> | |
28 | #include <linux/sysdev.h> | |
29 | #include <linux/ctype.h> | |
c0d12172 | 30 | #include <linux/edac.h> |
da9bb1d2 AC |
31 | #include <asm/uaccess.h> |
32 | #include <asm/page.h> | |
33 | #include <asm/edac.h> | |
20bcb7a8 | 34 | #include "edac_core.h" |
7c9281d7 | 35 | #include "edac_module.h" |
da9bb1d2 | 36 | |
da9bb1d2 | 37 | /* lock to memory controller's control array */ |
63b7df91 | 38 | static DEFINE_MUTEX(mem_ctls_mutex); |
da9bb1d2 AC |
39 | static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices); |
40 | ||
da9bb1d2 AC |
41 | #ifdef CONFIG_EDAC_DEBUG |
42 | ||
2da1c119 | 43 | static void edac_mc_dump_channel(struct channel_info *chan) |
da9bb1d2 AC |
44 | { |
45 | debugf4("\tchannel = %p\n", chan); | |
46 | debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx); | |
47 | debugf4("\tchannel->ce_count = %d\n", chan->ce_count); | |
48 | debugf4("\tchannel->label = '%s'\n", chan->label); | |
49 | debugf4("\tchannel->csrow = %p\n\n", chan->csrow); | |
50 | } | |
51 | ||
2da1c119 | 52 | static void edac_mc_dump_csrow(struct csrow_info *csrow) |
da9bb1d2 AC |
53 | { |
54 | debugf4("\tcsrow = %p\n", csrow); | |
55 | debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx); | |
079708b9 | 56 | debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page); |
da9bb1d2 AC |
57 | debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page); |
58 | debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask); | |
59 | debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages); | |
079708b9 | 60 | debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels); |
da9bb1d2 AC |
61 | debugf4("\tcsrow->channels = %p\n", csrow->channels); |
62 | debugf4("\tcsrow->mci = %p\n\n", csrow->mci); | |
63 | } | |
64 | ||
2da1c119 | 65 | static void edac_mc_dump_mci(struct mem_ctl_info *mci) |
da9bb1d2 AC |
66 | { |
67 | debugf3("\tmci = %p\n", mci); | |
68 | debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap); | |
69 | debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap); | |
70 | debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap); | |
71 | debugf4("\tmci->edac_check = %p\n", mci->edac_check); | |
72 | debugf3("\tmci->nr_csrows = %d, csrows = %p\n", | |
73 | mci->nr_csrows, mci->csrows); | |
37f04581 | 74 | debugf3("\tdev = %p\n", mci->dev); |
079708b9 | 75 | debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name); |
da9bb1d2 AC |
76 | debugf3("\tpvt_info = %p\n\n", mci->pvt_info); |
77 | } | |
78 | ||
079708b9 | 79 | #endif /* CONFIG_EDAC_DEBUG */ |
da9bb1d2 AC |
80 | |
81 | /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'. | |
82 | * Adjust 'ptr' so that its alignment is at least as stringent as what the | |
83 | * compiler would provide for X and return the aligned result. | |
84 | * | |
85 | * If 'size' is a constant, the compiler will optimize this whole function | |
86 | * down to either a no-op or the addition of a constant to the value of 'ptr'. | |
87 | */ | |
7391c6dc | 88 | void *edac_align_ptr(void *ptr, unsigned size) |
da9bb1d2 AC |
89 | { |
90 | unsigned align, r; | |
91 | ||
92 | /* Here we assume that the alignment of a "long long" is the most | |
93 | * stringent alignment that the compiler will ever provide by default. | |
94 | * As far as I know, this is a reasonable assumption. | |
95 | */ | |
96 | if (size > sizeof(long)) | |
97 | align = sizeof(long long); | |
98 | else if (size > sizeof(int)) | |
99 | align = sizeof(long); | |
100 | else if (size > sizeof(short)) | |
101 | align = sizeof(int); | |
102 | else if (size > sizeof(char)) | |
103 | align = sizeof(short); | |
104 | else | |
079708b9 | 105 | return (char *)ptr; |
da9bb1d2 AC |
106 | |
107 | r = size % align; | |
108 | ||
109 | if (r == 0) | |
079708b9 | 110 | return (char *)ptr; |
da9bb1d2 | 111 | |
7391c6dc | 112 | return (void *)(((unsigned long)ptr) + align - r); |
da9bb1d2 AC |
113 | } |
114 | ||
da9bb1d2 AC |
115 | /** |
116 | * edac_mc_alloc: Allocate a struct mem_ctl_info structure | |
117 | * @size_pvt: size of private storage needed | |
118 | * @nr_csrows: Number of CWROWS needed for this MC | |
119 | * @nr_chans: Number of channels for the MC | |
120 | * | |
121 | * Everything is kmalloc'ed as one big chunk - more efficient. | |
122 | * Only can be used if all structures have the same lifetime - otherwise | |
123 | * you have to allocate and initialize your own structures. | |
124 | * | |
125 | * Use edac_mc_free() to free mc structures allocated by this function. | |
126 | * | |
127 | * Returns: | |
128 | * NULL allocation failed | |
129 | * struct mem_ctl_info pointer | |
130 | */ | |
131 | struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows, | |
b8f6f975 | 132 | unsigned nr_chans, int edac_index) |
da9bb1d2 AC |
133 | { |
134 | struct mem_ctl_info *mci; | |
135 | struct csrow_info *csi, *csrow; | |
136 | struct channel_info *chi, *chp, *chan; | |
137 | void *pvt; | |
138 | unsigned size; | |
139 | int row, chn; | |
8096cfaf | 140 | int err; |
da9bb1d2 AC |
141 | |
142 | /* Figure out the offsets of the various items from the start of an mc | |
143 | * structure. We want the alignment of each item to be at least as | |
144 | * stringent as what the compiler would provide if we could simply | |
145 | * hardcode everything into a single struct. | |
146 | */ | |
079708b9 | 147 | mci = (struct mem_ctl_info *)0; |
7391c6dc DT |
148 | csi = edac_align_ptr(&mci[1], sizeof(*csi)); |
149 | chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi)); | |
e27e3dac | 150 | pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt); |
079708b9 | 151 | size = ((unsigned long)pvt) + sz_pvt; |
da9bb1d2 | 152 | |
8096cfaf DT |
153 | mci = kzalloc(size, GFP_KERNEL); |
154 | if (mci == NULL) | |
da9bb1d2 AC |
155 | return NULL; |
156 | ||
157 | /* Adjust pointers so they point within the memory we just allocated | |
158 | * rather than an imaginary chunk of memory located at address 0. | |
159 | */ | |
079708b9 DT |
160 | csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi)); |
161 | chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi)); | |
162 | pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL; | |
da9bb1d2 | 163 | |
b8f6f975 DT |
164 | /* setup index and various internal pointers */ |
165 | mci->mc_idx = edac_index; | |
da9bb1d2 AC |
166 | mci->csrows = csi; |
167 | mci->pvt_info = pvt; | |
168 | mci->nr_csrows = nr_csrows; | |
169 | ||
170 | for (row = 0; row < nr_csrows; row++) { | |
171 | csrow = &csi[row]; | |
172 | csrow->csrow_idx = row; | |
173 | csrow->mci = mci; | |
174 | csrow->nr_channels = nr_chans; | |
175 | chp = &chi[row * nr_chans]; | |
176 | csrow->channels = chp; | |
177 | ||
178 | for (chn = 0; chn < nr_chans; chn++) { | |
179 | chan = &chp[chn]; | |
180 | chan->chan_idx = chn; | |
181 | chan->csrow = csrow; | |
182 | } | |
183 | } | |
184 | ||
81d87cb1 DJ |
185 | mci->op_state = OP_ALLOC; |
186 | ||
8096cfaf DT |
187 | /* |
188 | * Initialize the 'root' kobj for the edac_mc controller | |
189 | */ | |
190 | err = edac_mc_register_sysfs_main_kobj(mci); | |
191 | if (err) { | |
192 | kfree(mci); | |
193 | return NULL; | |
194 | } | |
195 | ||
196 | /* at this point, the root kobj is valid, and in order to | |
197 | * 'free' the object, then the function: | |
198 | * edac_mc_unregister_sysfs_main_kobj() must be called | |
199 | * which will perform kobj unregistration and the actual free | |
200 | * will occur during the kobject callback operation | |
201 | */ | |
da9bb1d2 AC |
202 | return mci; |
203 | } | |
9110540f | 204 | EXPORT_SYMBOL_GPL(edac_mc_alloc); |
da9bb1d2 | 205 | |
da9bb1d2 | 206 | /** |
8096cfaf DT |
207 | * edac_mc_free |
208 | * 'Free' a previously allocated 'mci' structure | |
da9bb1d2 | 209 | * @mci: pointer to a struct mem_ctl_info structure |
da9bb1d2 AC |
210 | */ |
211 | void edac_mc_free(struct mem_ctl_info *mci) | |
212 | { | |
8096cfaf | 213 | edac_mc_unregister_sysfs_main_kobj(mci); |
da9bb1d2 | 214 | } |
9110540f | 215 | EXPORT_SYMBOL_GPL(edac_mc_free); |
da9bb1d2 | 216 | |
37f04581 | 217 | static struct mem_ctl_info *find_mci_by_dev(struct device *dev) |
da9bb1d2 AC |
218 | { |
219 | struct mem_ctl_info *mci; | |
220 | struct list_head *item; | |
221 | ||
537fba28 | 222 | debugf3("%s()\n", __func__); |
da9bb1d2 AC |
223 | |
224 | list_for_each(item, &mc_devices) { | |
225 | mci = list_entry(item, struct mem_ctl_info, link); | |
226 | ||
37f04581 | 227 | if (mci->dev == dev) |
da9bb1d2 AC |
228 | return mci; |
229 | } | |
230 | ||
231 | return NULL; | |
232 | } | |
233 | ||
81d87cb1 DJ |
234 | /* |
235 | * handler for EDAC to check if NMI type handler has asserted interrupt | |
236 | */ | |
237 | static int edac_mc_assert_error_check_and_clear(void) | |
238 | { | |
66ee2f94 | 239 | int old_state; |
81d87cb1 | 240 | |
079708b9 | 241 | if (edac_op_state == EDAC_OPSTATE_POLL) |
81d87cb1 DJ |
242 | return 1; |
243 | ||
66ee2f94 DJ |
244 | old_state = edac_err_assert; |
245 | edac_err_assert = 0; | |
81d87cb1 | 246 | |
66ee2f94 | 247 | return old_state; |
81d87cb1 DJ |
248 | } |
249 | ||
250 | /* | |
251 | * edac_mc_workq_function | |
252 | * performs the operation scheduled by a workq request | |
253 | */ | |
81d87cb1 DJ |
254 | static void edac_mc_workq_function(struct work_struct *work_req) |
255 | { | |
079708b9 | 256 | struct delayed_work *d_work = (struct delayed_work *)work_req; |
81d87cb1 | 257 | struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work); |
81d87cb1 DJ |
258 | |
259 | mutex_lock(&mem_ctls_mutex); | |
260 | ||
bf52fa4a DT |
261 | /* if this control struct has movd to offline state, we are done */ |
262 | if (mci->op_state == OP_OFFLINE) { | |
263 | mutex_unlock(&mem_ctls_mutex); | |
264 | return; | |
265 | } | |
266 | ||
81d87cb1 DJ |
267 | /* Only poll controllers that are running polled and have a check */ |
268 | if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL)) | |
269 | mci->edac_check(mci); | |
270 | ||
271 | /* | |
272 | * FIXME: temp place holder for PCI checks, | |
273 | * goes away when we break out PCI | |
274 | */ | |
275 | edac_pci_do_parity_check(); | |
276 | ||
277 | mutex_unlock(&mem_ctls_mutex); | |
278 | ||
279 | /* Reschedule */ | |
4de78c68 | 280 | queue_delayed_work(edac_workqueue, &mci->work, |
052dfb45 | 281 | msecs_to_jiffies(edac_mc_get_poll_msec())); |
81d87cb1 DJ |
282 | } |
283 | ||
284 | /* | |
285 | * edac_mc_workq_setup | |
286 | * initialize a workq item for this mci | |
287 | * passing in the new delay period in msec | |
bf52fa4a DT |
288 | * |
289 | * locking model: | |
290 | * | |
291 | * called with the mem_ctls_mutex held | |
81d87cb1 | 292 | */ |
bf52fa4a | 293 | static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec) |
81d87cb1 DJ |
294 | { |
295 | debugf0("%s()\n", __func__); | |
296 | ||
bf52fa4a DT |
297 | /* if this instance is not in the POLL state, then simply return */ |
298 | if (mci->op_state != OP_RUNNING_POLL) | |
299 | return; | |
300 | ||
81d87cb1 | 301 | INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function); |
81d87cb1 DJ |
302 | queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec)); |
303 | } | |
304 | ||
305 | /* | |
306 | * edac_mc_workq_teardown | |
307 | * stop the workq processing on this mci | |
bf52fa4a DT |
308 | * |
309 | * locking model: | |
310 | * | |
311 | * called WITHOUT lock held | |
81d87cb1 | 312 | */ |
bf52fa4a | 313 | static void edac_mc_workq_teardown(struct mem_ctl_info *mci) |
81d87cb1 DJ |
314 | { |
315 | int status; | |
316 | ||
bf52fa4a DT |
317 | /* if not running POLL, leave now */ |
318 | if (mci->op_state == OP_RUNNING_POLL) { | |
319 | status = cancel_delayed_work(&mci->work); | |
320 | if (status == 0) { | |
321 | debugf0("%s() not canceled, flush the queue\n", | |
322 | __func__); | |
323 | ||
324 | /* workq instance might be running, wait for it */ | |
325 | flush_workqueue(edac_workqueue); | |
326 | } | |
81d87cb1 DJ |
327 | } |
328 | } | |
329 | ||
330 | /* | |
331 | * edac_reset_delay_period | |
332 | */ | |
bf52fa4a | 333 | static void edac_reset_delay_period(struct mem_ctl_info *mci, unsigned long value) |
81d87cb1 | 334 | { |
81d87cb1 DJ |
335 | /* cancel the current workq request */ |
336 | edac_mc_workq_teardown(mci); | |
337 | ||
bf52fa4a DT |
338 | /* lock the list of devices for the new setup */ |
339 | mutex_lock(&mem_ctls_mutex); | |
340 | ||
81d87cb1 DJ |
341 | /* restart the workq request, with new delay value */ |
342 | edac_mc_workq_setup(mci, value); | |
343 | ||
344 | mutex_unlock(&mem_ctls_mutex); | |
345 | } | |
346 | ||
2d7bbb91 DT |
347 | /* Return 0 on success, 1 on failure. |
348 | * Before calling this function, caller must | |
349 | * assign a unique value to mci->mc_idx. | |
bf52fa4a DT |
350 | * |
351 | * locking model: | |
352 | * | |
353 | * called with the mem_ctls_mutex lock held | |
2d7bbb91 | 354 | */ |
079708b9 | 355 | static int add_mc_to_global_list(struct mem_ctl_info *mci) |
da9bb1d2 AC |
356 | { |
357 | struct list_head *item, *insert_before; | |
358 | struct mem_ctl_info *p; | |
da9bb1d2 | 359 | |
2d7bbb91 | 360 | insert_before = &mc_devices; |
da9bb1d2 | 361 | |
bf52fa4a DT |
362 | p = find_mci_by_dev(mci->dev); |
363 | if (unlikely(p != NULL)) | |
2d7bbb91 | 364 | goto fail0; |
da9bb1d2 | 365 | |
2d7bbb91 DT |
366 | list_for_each(item, &mc_devices) { |
367 | p = list_entry(item, struct mem_ctl_info, link); | |
da9bb1d2 | 368 | |
2d7bbb91 DT |
369 | if (p->mc_idx >= mci->mc_idx) { |
370 | if (unlikely(p->mc_idx == mci->mc_idx)) | |
371 | goto fail1; | |
da9bb1d2 | 372 | |
2d7bbb91 DT |
373 | insert_before = item; |
374 | break; | |
da9bb1d2 | 375 | } |
da9bb1d2 AC |
376 | } |
377 | ||
378 | list_add_tail_rcu(&mci->link, insert_before); | |
c0d12172 | 379 | atomic_inc(&edac_handlers); |
da9bb1d2 | 380 | return 0; |
2d7bbb91 | 381 | |
052dfb45 | 382 | fail0: |
2d7bbb91 | 383 | edac_printk(KERN_WARNING, EDAC_MC, |
052dfb45 DT |
384 | "%s (%s) %s %s already assigned %d\n", p->dev->bus_id, |
385 | dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx); | |
2d7bbb91 DT |
386 | return 1; |
387 | ||
052dfb45 | 388 | fail1: |
2d7bbb91 | 389 | edac_printk(KERN_WARNING, EDAC_MC, |
052dfb45 DT |
390 | "bug in low-level driver: attempt to assign\n" |
391 | " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__); | |
2d7bbb91 | 392 | return 1; |
da9bb1d2 AC |
393 | } |
394 | ||
e7ecd891 | 395 | static void complete_mc_list_del(struct rcu_head *head) |
a1d03fcc DP |
396 | { |
397 | struct mem_ctl_info *mci; | |
398 | ||
399 | mci = container_of(head, struct mem_ctl_info, rcu); | |
400 | INIT_LIST_HEAD(&mci->link); | |
401 | complete(&mci->complete); | |
402 | } | |
403 | ||
e7ecd891 | 404 | static void del_mc_from_global_list(struct mem_ctl_info *mci) |
a1d03fcc | 405 | { |
c0d12172 | 406 | atomic_dec(&edac_handlers); |
a1d03fcc DP |
407 | list_del_rcu(&mci->link); |
408 | init_completion(&mci->complete); | |
409 | call_rcu(&mci->rcu, complete_mc_list_del); | |
410 | wait_for_completion(&mci->complete); | |
411 | } | |
412 | ||
5da0831c DT |
413 | /** |
414 | * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'. | |
415 | * | |
416 | * If found, return a pointer to the structure. | |
417 | * Else return NULL. | |
418 | * | |
419 | * Caller must hold mem_ctls_mutex. | |
420 | */ | |
079708b9 | 421 | struct mem_ctl_info *edac_mc_find(int idx) |
5da0831c DT |
422 | { |
423 | struct list_head *item; | |
424 | struct mem_ctl_info *mci; | |
425 | ||
426 | list_for_each(item, &mc_devices) { | |
427 | mci = list_entry(item, struct mem_ctl_info, link); | |
428 | ||
429 | if (mci->mc_idx >= idx) { | |
430 | if (mci->mc_idx == idx) | |
431 | return mci; | |
432 | ||
433 | break; | |
434 | } | |
435 | } | |
436 | ||
437 | return NULL; | |
438 | } | |
439 | EXPORT_SYMBOL(edac_mc_find); | |
440 | ||
da9bb1d2 | 441 | /** |
472678eb DP |
442 | * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and |
443 | * create sysfs entries associated with mci structure | |
da9bb1d2 | 444 | * @mci: pointer to the mci structure to be added to the list |
2d7bbb91 | 445 | * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure. |
da9bb1d2 AC |
446 | * |
447 | * Return: | |
448 | * 0 Success | |
449 | * !0 Failure | |
450 | */ | |
451 | ||
452 | /* FIXME - should a warning be printed if no error detection? correction? */ | |
b8f6f975 | 453 | int edac_mc_add_mc(struct mem_ctl_info *mci) |
da9bb1d2 | 454 | { |
537fba28 | 455 | debugf0("%s()\n", __func__); |
b8f6f975 | 456 | |
da9bb1d2 AC |
457 | #ifdef CONFIG_EDAC_DEBUG |
458 | if (edac_debug_level >= 3) | |
459 | edac_mc_dump_mci(mci); | |
e7ecd891 | 460 | |
da9bb1d2 AC |
461 | if (edac_debug_level >= 4) { |
462 | int i; | |
463 | ||
464 | for (i = 0; i < mci->nr_csrows; i++) { | |
465 | int j; | |
e7ecd891 | 466 | |
da9bb1d2 AC |
467 | edac_mc_dump_csrow(&mci->csrows[i]); |
468 | for (j = 0; j < mci->csrows[i].nr_channels; j++) | |
079708b9 | 469 | edac_mc_dump_channel(&mci->csrows[i]. |
052dfb45 | 470 | channels[j]); |
da9bb1d2 AC |
471 | } |
472 | } | |
473 | #endif | |
63b7df91 | 474 | mutex_lock(&mem_ctls_mutex); |
da9bb1d2 AC |
475 | |
476 | if (add_mc_to_global_list(mci)) | |
028a7b6d | 477 | goto fail0; |
da9bb1d2 AC |
478 | |
479 | /* set load time so that error rate can be tracked */ | |
480 | mci->start_time = jiffies; | |
481 | ||
9794f33d | 482 | if (edac_create_sysfs_mci_device(mci)) { |
483 | edac_mc_printk(mci, KERN_WARNING, | |
052dfb45 | 484 | "failed to create sysfs device\n"); |
9794f33d | 485 | goto fail1; |
486 | } | |
da9bb1d2 | 487 | |
81d87cb1 DJ |
488 | /* If there IS a check routine, then we are running POLLED */ |
489 | if (mci->edac_check != NULL) { | |
490 | /* This instance is NOW RUNNING */ | |
491 | mci->op_state = OP_RUNNING_POLL; | |
492 | ||
493 | edac_mc_workq_setup(mci, edac_mc_get_poll_msec()); | |
494 | } else { | |
495 | mci->op_state = OP_RUNNING_INTERRUPT; | |
496 | } | |
497 | ||
da9bb1d2 | 498 | /* Report action taken */ |
bf52fa4a DT |
499 | edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':" |
500 | " DEV %s\n", mci->mod_name, mci->ctl_name, dev_name(mci)); | |
da9bb1d2 | 501 | |
63b7df91 | 502 | mutex_unlock(&mem_ctls_mutex); |
028a7b6d | 503 | return 0; |
da9bb1d2 | 504 | |
052dfb45 | 505 | fail1: |
028a7b6d DP |
506 | del_mc_from_global_list(mci); |
507 | ||
052dfb45 | 508 | fail0: |
63b7df91 | 509 | mutex_unlock(&mem_ctls_mutex); |
028a7b6d | 510 | return 1; |
da9bb1d2 | 511 | } |
9110540f | 512 | EXPORT_SYMBOL_GPL(edac_mc_add_mc); |
da9bb1d2 | 513 | |
da9bb1d2 | 514 | /** |
472678eb DP |
515 | * edac_mc_del_mc: Remove sysfs entries for specified mci structure and |
516 | * remove mci structure from global list | |
37f04581 | 517 | * @pdev: Pointer to 'struct device' representing mci structure to remove. |
da9bb1d2 | 518 | * |
18dbc337 | 519 | * Return pointer to removed mci structure, or NULL if device not found. |
da9bb1d2 | 520 | */ |
079708b9 | 521 | struct mem_ctl_info *edac_mc_del_mc(struct device *dev) |
da9bb1d2 | 522 | { |
18dbc337 | 523 | struct mem_ctl_info *mci; |
da9bb1d2 | 524 | |
bf52fa4a DT |
525 | debugf0("%s()\n", __func__); |
526 | ||
63b7df91 | 527 | mutex_lock(&mem_ctls_mutex); |
18dbc337 | 528 | |
bf52fa4a DT |
529 | /* find the requested mci struct in the global list */ |
530 | mci = find_mci_by_dev(dev); | |
531 | if (mci == NULL) { | |
63b7df91 | 532 | mutex_unlock(&mem_ctls_mutex); |
18dbc337 DP |
533 | return NULL; |
534 | } | |
535 | ||
81d87cb1 DJ |
536 | /* marking MCI offline */ |
537 | mci->op_state = OP_OFFLINE; | |
538 | ||
da9bb1d2 | 539 | del_mc_from_global_list(mci); |
63b7df91 | 540 | mutex_unlock(&mem_ctls_mutex); |
bf52fa4a DT |
541 | |
542 | /* flush workq processes and remove sysfs */ | |
543 | edac_mc_workq_teardown(mci); | |
544 | edac_remove_sysfs_mci_device(mci); | |
545 | ||
537fba28 | 546 | edac_printk(KERN_INFO, EDAC_MC, |
052dfb45 DT |
547 | "Removed device %d for %s %s: DEV %s\n", mci->mc_idx, |
548 | mci->mod_name, mci->ctl_name, dev_name(mci)); | |
bf52fa4a | 549 | |
18dbc337 | 550 | return mci; |
da9bb1d2 | 551 | } |
9110540f | 552 | EXPORT_SYMBOL_GPL(edac_mc_del_mc); |
da9bb1d2 | 553 | |
2da1c119 AB |
554 | static void edac_mc_scrub_block(unsigned long page, unsigned long offset, |
555 | u32 size) | |
da9bb1d2 AC |
556 | { |
557 | struct page *pg; | |
558 | void *virt_addr; | |
559 | unsigned long flags = 0; | |
560 | ||
537fba28 | 561 | debugf3("%s()\n", __func__); |
da9bb1d2 AC |
562 | |
563 | /* ECC error page was not in our memory. Ignore it. */ | |
079708b9 | 564 | if (!pfn_valid(page)) |
da9bb1d2 AC |
565 | return; |
566 | ||
567 | /* Find the actual page structure then map it and fix */ | |
568 | pg = pfn_to_page(page); | |
569 | ||
570 | if (PageHighMem(pg)) | |
571 | local_irq_save(flags); | |
572 | ||
573 | virt_addr = kmap_atomic(pg, KM_BOUNCE_READ); | |
574 | ||
575 | /* Perform architecture specific atomic scrub operation */ | |
576 | atomic_scrub(virt_addr + offset, size); | |
577 | ||
578 | /* Unmap and complete */ | |
579 | kunmap_atomic(virt_addr, KM_BOUNCE_READ); | |
580 | ||
581 | if (PageHighMem(pg)) | |
582 | local_irq_restore(flags); | |
583 | } | |
584 | ||
da9bb1d2 | 585 | /* FIXME - should return -1 */ |
e7ecd891 | 586 | int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page) |
da9bb1d2 AC |
587 | { |
588 | struct csrow_info *csrows = mci->csrows; | |
589 | int row, i; | |
590 | ||
537fba28 | 591 | debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page); |
da9bb1d2 AC |
592 | row = -1; |
593 | ||
594 | for (i = 0; i < mci->nr_csrows; i++) { | |
595 | struct csrow_info *csrow = &csrows[i]; | |
596 | ||
597 | if (csrow->nr_pages == 0) | |
598 | continue; | |
599 | ||
537fba28 DP |
600 | debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) " |
601 | "mask(0x%lx)\n", mci->mc_idx, __func__, | |
602 | csrow->first_page, page, csrow->last_page, | |
603 | csrow->page_mask); | |
da9bb1d2 AC |
604 | |
605 | if ((page >= csrow->first_page) && | |
606 | (page <= csrow->last_page) && | |
607 | ((page & csrow->page_mask) == | |
608 | (csrow->first_page & csrow->page_mask))) { | |
609 | row = i; | |
610 | break; | |
611 | } | |
612 | } | |
613 | ||
614 | if (row == -1) | |
537fba28 | 615 | edac_mc_printk(mci, KERN_ERR, |
052dfb45 DT |
616 | "could not look up page error address %lx\n", |
617 | (unsigned long)page); | |
da9bb1d2 AC |
618 | |
619 | return row; | |
620 | } | |
9110540f | 621 | EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page); |
da9bb1d2 | 622 | |
da9bb1d2 AC |
623 | /* FIXME - setable log (warning/emerg) levels */ |
624 | /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */ | |
625 | void edac_mc_handle_ce(struct mem_ctl_info *mci, | |
052dfb45 DT |
626 | unsigned long page_frame_number, |
627 | unsigned long offset_in_page, unsigned long syndrome, | |
628 | int row, int channel, const char *msg) | |
da9bb1d2 AC |
629 | { |
630 | unsigned long remapped_page; | |
631 | ||
537fba28 | 632 | debugf3("MC%d: %s()\n", mci->mc_idx, __func__); |
da9bb1d2 AC |
633 | |
634 | /* FIXME - maybe make panic on INTERNAL ERROR an option */ | |
635 | if (row >= mci->nr_csrows || row < 0) { | |
636 | /* something is wrong */ | |
537fba28 | 637 | edac_mc_printk(mci, KERN_ERR, |
052dfb45 DT |
638 | "INTERNAL ERROR: row out of range " |
639 | "(%d >= %d)\n", row, mci->nr_csrows); | |
da9bb1d2 AC |
640 | edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); |
641 | return; | |
642 | } | |
e7ecd891 | 643 | |
da9bb1d2 AC |
644 | if (channel >= mci->csrows[row].nr_channels || channel < 0) { |
645 | /* something is wrong */ | |
537fba28 | 646 | edac_mc_printk(mci, KERN_ERR, |
052dfb45 DT |
647 | "INTERNAL ERROR: channel out of range " |
648 | "(%d >= %d)\n", channel, | |
649 | mci->csrows[row].nr_channels); | |
da9bb1d2 AC |
650 | edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); |
651 | return; | |
652 | } | |
653 | ||
4de78c68 | 654 | if (edac_mc_get_log_ce()) |
da9bb1d2 | 655 | /* FIXME - put in DIMM location */ |
537fba28 | 656 | edac_mc_printk(mci, KERN_WARNING, |
052dfb45 DT |
657 | "CE page 0x%lx, offset 0x%lx, grain %d, syndrome " |
658 | "0x%lx, row %d, channel %d, label \"%s\": %s\n", | |
659 | page_frame_number, offset_in_page, | |
660 | mci->csrows[row].grain, syndrome, row, channel, | |
661 | mci->csrows[row].channels[channel].label, msg); | |
da9bb1d2 AC |
662 | |
663 | mci->ce_count++; | |
664 | mci->csrows[row].ce_count++; | |
665 | mci->csrows[row].channels[channel].ce_count++; | |
666 | ||
667 | if (mci->scrub_mode & SCRUB_SW_SRC) { | |
668 | /* | |
669 | * Some MC's can remap memory so that it is still available | |
670 | * at a different address when PCI devices map into memory. | |
671 | * MC's that can't do this lose the memory where PCI devices | |
672 | * are mapped. This mapping is MC dependant and so we call | |
673 | * back into the MC driver for it to map the MC page to | |
674 | * a physical (CPU) page which can then be mapped to a virtual | |
675 | * page - which can then be scrubbed. | |
676 | */ | |
677 | remapped_page = mci->ctl_page_to_phys ? | |
052dfb45 DT |
678 | mci->ctl_page_to_phys(mci, page_frame_number) : |
679 | page_frame_number; | |
da9bb1d2 AC |
680 | |
681 | edac_mc_scrub_block(remapped_page, offset_in_page, | |
052dfb45 | 682 | mci->csrows[row].grain); |
da9bb1d2 AC |
683 | } |
684 | } | |
9110540f | 685 | EXPORT_SYMBOL_GPL(edac_mc_handle_ce); |
da9bb1d2 | 686 | |
e7ecd891 | 687 | void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg) |
da9bb1d2 | 688 | { |
4de78c68 | 689 | if (edac_mc_get_log_ce()) |
537fba28 | 690 | edac_mc_printk(mci, KERN_WARNING, |
052dfb45 | 691 | "CE - no information available: %s\n", msg); |
e7ecd891 | 692 | |
da9bb1d2 AC |
693 | mci->ce_noinfo_count++; |
694 | mci->ce_count++; | |
695 | } | |
9110540f | 696 | EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info); |
da9bb1d2 | 697 | |
da9bb1d2 | 698 | void edac_mc_handle_ue(struct mem_ctl_info *mci, |
052dfb45 DT |
699 | unsigned long page_frame_number, |
700 | unsigned long offset_in_page, int row, const char *msg) | |
da9bb1d2 AC |
701 | { |
702 | int len = EDAC_MC_LABEL_LEN * 4; | |
703 | char labels[len + 1]; | |
704 | char *pos = labels; | |
705 | int chan; | |
706 | int chars; | |
707 | ||
537fba28 | 708 | debugf3("MC%d: %s()\n", mci->mc_idx, __func__); |
da9bb1d2 AC |
709 | |
710 | /* FIXME - maybe make panic on INTERNAL ERROR an option */ | |
711 | if (row >= mci->nr_csrows || row < 0) { | |
712 | /* something is wrong */ | |
537fba28 | 713 | edac_mc_printk(mci, KERN_ERR, |
052dfb45 DT |
714 | "INTERNAL ERROR: row out of range " |
715 | "(%d >= %d)\n", row, mci->nr_csrows); | |
da9bb1d2 AC |
716 | edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); |
717 | return; | |
718 | } | |
719 | ||
720 | chars = snprintf(pos, len + 1, "%s", | |
079708b9 | 721 | mci->csrows[row].channels[0].label); |
da9bb1d2 AC |
722 | len -= chars; |
723 | pos += chars; | |
e7ecd891 | 724 | |
da9bb1d2 | 725 | for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0); |
052dfb45 | 726 | chan++) { |
da9bb1d2 | 727 | chars = snprintf(pos, len + 1, ":%s", |
079708b9 | 728 | mci->csrows[row].channels[chan].label); |
da9bb1d2 AC |
729 | len -= chars; |
730 | pos += chars; | |
731 | } | |
732 | ||
4de78c68 | 733 | if (edac_mc_get_log_ue()) |
537fba28 | 734 | edac_mc_printk(mci, KERN_EMERG, |
052dfb45 DT |
735 | "UE page 0x%lx, offset 0x%lx, grain %d, row %d, " |
736 | "labels \"%s\": %s\n", page_frame_number, | |
737 | offset_in_page, mci->csrows[row].grain, row, | |
738 | labels, msg); | |
da9bb1d2 | 739 | |
4de78c68 | 740 | if (edac_mc_get_panic_on_ue()) |
e7ecd891 | 741 | panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, " |
052dfb45 DT |
742 | "row %d, labels \"%s\": %s\n", mci->mc_idx, |
743 | page_frame_number, offset_in_page, | |
744 | mci->csrows[row].grain, row, labels, msg); | |
da9bb1d2 AC |
745 | |
746 | mci->ue_count++; | |
747 | mci->csrows[row].ue_count++; | |
748 | } | |
9110540f | 749 | EXPORT_SYMBOL_GPL(edac_mc_handle_ue); |
da9bb1d2 | 750 | |
e7ecd891 | 751 | void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg) |
da9bb1d2 | 752 | { |
4de78c68 | 753 | if (edac_mc_get_panic_on_ue()) |
da9bb1d2 AC |
754 | panic("EDAC MC%d: Uncorrected Error", mci->mc_idx); |
755 | ||
4de78c68 | 756 | if (edac_mc_get_log_ue()) |
537fba28 | 757 | edac_mc_printk(mci, KERN_WARNING, |
052dfb45 | 758 | "UE - no information available: %s\n", msg); |
da9bb1d2 AC |
759 | mci->ue_noinfo_count++; |
760 | mci->ue_count++; | |
761 | } | |
079708b9 | 762 | EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info); |
da9bb1d2 | 763 | |
9794f33d | 764 | /************************************************************* |
765 | * On Fully Buffered DIMM modules, this help function is | |
766 | * called to process UE events | |
767 | */ | |
768 | void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci, | |
052dfb45 DT |
769 | unsigned int csrow, |
770 | unsigned int channela, | |
771 | unsigned int channelb, char *msg) | |
9794f33d | 772 | { |
773 | int len = EDAC_MC_LABEL_LEN * 4; | |
774 | char labels[len + 1]; | |
775 | char *pos = labels; | |
776 | int chars; | |
777 | ||
778 | if (csrow >= mci->nr_csrows) { | |
779 | /* something is wrong */ | |
780 | edac_mc_printk(mci, KERN_ERR, | |
052dfb45 DT |
781 | "INTERNAL ERROR: row out of range (%d >= %d)\n", |
782 | csrow, mci->nr_csrows); | |
9794f33d | 783 | edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); |
784 | return; | |
785 | } | |
786 | ||
787 | if (channela >= mci->csrows[csrow].nr_channels) { | |
788 | /* something is wrong */ | |
789 | edac_mc_printk(mci, KERN_ERR, | |
052dfb45 DT |
790 | "INTERNAL ERROR: channel-a out of range " |
791 | "(%d >= %d)\n", | |
792 | channela, mci->csrows[csrow].nr_channels); | |
9794f33d | 793 | edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); |
794 | return; | |
795 | } | |
796 | ||
797 | if (channelb >= mci->csrows[csrow].nr_channels) { | |
798 | /* something is wrong */ | |
799 | edac_mc_printk(mci, KERN_ERR, | |
052dfb45 DT |
800 | "INTERNAL ERROR: channel-b out of range " |
801 | "(%d >= %d)\n", | |
802 | channelb, mci->csrows[csrow].nr_channels); | |
9794f33d | 803 | edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); |
804 | return; | |
805 | } | |
806 | ||
807 | mci->ue_count++; | |
808 | mci->csrows[csrow].ue_count++; | |
809 | ||
810 | /* Generate the DIMM labels from the specified channels */ | |
811 | chars = snprintf(pos, len + 1, "%s", | |
812 | mci->csrows[csrow].channels[channela].label); | |
079708b9 DT |
813 | len -= chars; |
814 | pos += chars; | |
9794f33d | 815 | chars = snprintf(pos, len + 1, "-%s", |
816 | mci->csrows[csrow].channels[channelb].label); | |
817 | ||
4de78c68 | 818 | if (edac_mc_get_log_ue()) |
9794f33d | 819 | edac_mc_printk(mci, KERN_EMERG, |
052dfb45 DT |
820 | "UE row %d, channel-a= %d channel-b= %d " |
821 | "labels \"%s\": %s\n", csrow, channela, channelb, | |
822 | labels, msg); | |
9794f33d | 823 | |
4de78c68 | 824 | if (edac_mc_get_panic_on_ue()) |
9794f33d | 825 | panic("UE row %d, channel-a= %d channel-b= %d " |
052dfb45 DT |
826 | "labels \"%s\": %s\n", csrow, channela, |
827 | channelb, labels, msg); | |
9794f33d | 828 | } |
829 | EXPORT_SYMBOL(edac_mc_handle_fbd_ue); | |
830 | ||
831 | /************************************************************* | |
832 | * On Fully Buffered DIMM modules, this help function is | |
833 | * called to process CE events | |
834 | */ | |
835 | void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci, | |
052dfb45 | 836 | unsigned int csrow, unsigned int channel, char *msg) |
9794f33d | 837 | { |
838 | ||
839 | /* Ensure boundary values */ | |
840 | if (csrow >= mci->nr_csrows) { | |
841 | /* something is wrong */ | |
842 | edac_mc_printk(mci, KERN_ERR, | |
052dfb45 DT |
843 | "INTERNAL ERROR: row out of range (%d >= %d)\n", |
844 | csrow, mci->nr_csrows); | |
9794f33d | 845 | edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); |
846 | return; | |
847 | } | |
848 | if (channel >= mci->csrows[csrow].nr_channels) { | |
849 | /* something is wrong */ | |
850 | edac_mc_printk(mci, KERN_ERR, | |
052dfb45 DT |
851 | "INTERNAL ERROR: channel out of range (%d >= %d)\n", |
852 | channel, mci->csrows[csrow].nr_channels); | |
9794f33d | 853 | edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); |
854 | return; | |
855 | } | |
856 | ||
4de78c68 | 857 | if (edac_mc_get_log_ce()) |
9794f33d | 858 | /* FIXME - put in DIMM location */ |
859 | edac_mc_printk(mci, KERN_WARNING, | |
052dfb45 DT |
860 | "CE row %d, channel %d, label \"%s\": %s\n", |
861 | csrow, channel, | |
862 | mci->csrows[csrow].channels[channel].label, msg); | |
9794f33d | 863 | |
864 | mci->ce_count++; | |
865 | mci->csrows[csrow].ce_count++; | |
866 | mci->csrows[csrow].channels[channel].ce_count++; | |
867 | } | |
079708b9 | 868 | EXPORT_SYMBOL(edac_mc_handle_fbd_ce); |
9794f33d | 869 | |
da9bb1d2 AC |
870 | /* |
871 | * Iterate over all MC instances and check for ECC, et al, errors | |
872 | */ | |
7c9281d7 | 873 | void edac_check_mc_devices(void) |
da9bb1d2 | 874 | { |
da9bb1d2 AC |
875 | struct list_head *item; |
876 | struct mem_ctl_info *mci; | |
877 | ||
537fba28 | 878 | debugf3("%s()\n", __func__); |
63b7df91 | 879 | mutex_lock(&mem_ctls_mutex); |
da9bb1d2 AC |
880 | |
881 | list_for_each(item, &mc_devices) { | |
882 | mci = list_entry(item, struct mem_ctl_info, link); | |
883 | ||
884 | if (mci->edac_check != NULL) | |
885 | mci->edac_check(mci); | |
886 | } | |
887 | ||
63b7df91 | 888 | mutex_unlock(&mem_ctls_mutex); |
da9bb1d2 | 889 | } |