1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/smp.h>
18#include <linux/init.h>
19#include <linux/sysctl.h>
20#include <linux/highmem.h>
21#include <linux/timer.h>
22#include <linux/slab.h>
23#include <linux/jiffies.h>
24#include <linux/spinlock.h>
25#include <linux/list.h>
26#include <linux/sysdev.h>
27#include <linux/ctype.h>
28#include <linux/workqueue.h>
29#include <asm/uaccess.h>
30#include <asm/page.h>
31
32#include "edac_core.h"
33#include "edac_module.h"
34
35
36
37
38static DEFINE_MUTEX(device_ctls_mutex);
39static LIST_HEAD(edac_device_list);
40
41#ifdef CONFIG_EDAC_DEBUG
42static void edac_device_dump_device(struct edac_device_ctl_info *edac_dev)
43{
44 debugf3("\tedac_dev = %p dev_idx=%d \n", edac_dev, edac_dev->dev_idx);
45 debugf4("\tedac_dev->edac_check = %p\n", edac_dev->edac_check);
46 debugf3("\tdev = %p\n", edac_dev->dev);
47 debugf3("\tmod_name:ctl_name = %s:%s\n",
48 edac_dev->mod_name, edac_dev->ctl_name);
49 debugf3("\tpvt_info = %p\n\n", edac_dev->pvt_info);
50}
51#endif
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68struct edac_device_ctl_info *edac_device_alloc_ctl_info(
69 unsigned sz_private,
70 char *edac_device_name, unsigned nr_instances,
71 char *edac_block_name, unsigned nr_blocks,
72 unsigned offset_value,
73 struct edac_dev_sysfs_block_attribute *attrib_spec, unsigned nr_attrib,
74 int device_index)
75{
76 struct edac_device_ctl_info *dev_ctl;
77 struct edac_device_instance *dev_inst, *inst;
78 struct edac_device_block *dev_blk, *blk_p, *blk;
79 struct edac_dev_sysfs_block_attribute *dev_attrib, *attrib_p, *attrib;
80 unsigned total_size;
81 unsigned count;
82 unsigned instance, block, attr;
83 void *pvt;
84 int err;
85
86 debugf4("%s() instances=%d blocks=%d\n",
87 __func__, nr_instances, nr_blocks);
88
89
90
91
92
93
94
95
96 dev_ctl = (struct edac_device_ctl_info *)NULL;
97
98
99
100
101 dev_inst = edac_align_ptr(&dev_ctl[1], sizeof(*dev_inst));
102
103
104
105
106 dev_blk = edac_align_ptr(&dev_inst[nr_instances], sizeof(*dev_blk));
107
108
109
110
111 count = nr_instances * nr_blocks;
112 dev_attrib = edac_align_ptr(&dev_blk[count], sizeof(*dev_attrib));
113
114
115 if (nr_attrib > 0) {
116
117 count *= nr_attrib;
118
119
120 pvt = edac_align_ptr(&dev_attrib[count], sz_private);
121 } else {
122
123 pvt = edac_align_ptr(dev_attrib, sz_private);
124 }
125
126
127
128
129
130 total_size = ((unsigned long)pvt) + sz_private;
131
132
133 dev_ctl = kzalloc(total_size, GFP_KERNEL);
134 if (dev_ctl == NULL)
135 return NULL;
136
137
138
139
140
141
142
143
144 dev_inst = (struct edac_device_instance *)
145 (((char *)dev_ctl) + ((unsigned long)dev_inst));
146 dev_blk = (struct edac_device_block *)
147 (((char *)dev_ctl) + ((unsigned long)dev_blk));
148 dev_attrib = (struct edac_dev_sysfs_block_attribute *)
149 (((char *)dev_ctl) + ((unsigned long)dev_attrib));
150 pvt = sz_private ? (((char *)dev_ctl) + ((unsigned long)pvt)) : NULL;
151
152
153 dev_ctl->dev_idx = device_index;
154 dev_ctl->nr_instances = nr_instances;
155 dev_ctl->instances = dev_inst;
156 dev_ctl->pvt_info = pvt;
157
158
159 dev_ctl->log_ce = 1;
160 dev_ctl->log_ue = 1;
161
162
163 snprintf(dev_ctl->name,sizeof(dev_ctl->name),"%s",edac_device_name);
164
165 debugf4("%s() edac_dev=%p next after end=%p\n",
166 __func__, dev_ctl, pvt + sz_private );
167
168
169 for (instance = 0; instance < nr_instances; instance++) {
170 inst = &dev_inst[instance];
171 inst->ctl = dev_ctl;
172 inst->nr_blocks = nr_blocks;
173 blk_p = &dev_blk[instance * nr_blocks];
174 inst->blocks = blk_p;
175
176
177 snprintf(inst->name, sizeof(inst->name),
178 "%s%u", edac_device_name, instance);
179
180
181 for (block = 0; block < nr_blocks; block++) {
182 blk = &blk_p[block];
183 blk->instance = inst;
184 snprintf(blk->name, sizeof(blk->name),
185 "%s%d", edac_block_name, block+offset_value);
186
187 debugf4("%s() instance=%d inst_p=%p block=#%d "
188 "block_p=%p name='%s'\n",
189 __func__, instance, inst, block,
190 blk, blk->name);
191
192
193
194
195 if ((nr_attrib == 0) || (attrib_spec == NULL))
196 continue;
197
198
199 blk->nr_attribs = nr_attrib;
200 attrib_p = &dev_attrib[block*nr_instances*nr_attrib];
201 blk->block_attributes = attrib_p;
202
203 debugf4("%s() THIS BLOCK_ATTRIB=%p\n",
204 __func__, blk->block_attributes);
205
206
207
208
209
210
211 for (attr = 0; attr < nr_attrib; attr++) {
212 attrib = &attrib_p[attr];
213
214
215
216
217 attrib->attr = attrib_spec[attr].attr;
218 attrib->show = attrib_spec[attr].show;
219 attrib->store = attrib_spec[attr].store;
220
221 attrib->block = blk;
222
223 debugf4("%s() alloc-attrib=%p attrib_name='%s' "
224 "attrib-spec=%p spec-name=%s\n",
225 __func__, attrib, attrib->attr.name,
226 &attrib_spec[attr],
227 attrib_spec[attr].attr.name
228 );
229 }
230 }
231 }
232
233
234 dev_ctl->op_state = OP_ALLOC;
235
236
237
238
239 err = edac_device_register_sysfs_main_kobj(dev_ctl);
240 if (err) {
241 kfree(dev_ctl);
242 return NULL;
243 }
244
245
246
247
248
249
250
251
252 return dev_ctl;
253}
254EXPORT_SYMBOL_GPL(edac_device_alloc_ctl_info);
255
256
257
258
259
260
261void edac_device_free_ctl_info(struct edac_device_ctl_info *ctl_info)
262{
263 edac_device_unregister_sysfs_main_kobj(ctl_info);
264}
265EXPORT_SYMBOL_GPL(edac_device_free_ctl_info);
266
267
268
269
270
271
272
273
274
275
276
277static struct edac_device_ctl_info *find_edac_device_by_dev(struct device *dev)
278{
279 struct edac_device_ctl_info *edac_dev;
280 struct list_head *item;
281
282 debugf0("%s()\n", __func__);
283
284 list_for_each(item, &edac_device_list) {
285 edac_dev = list_entry(item, struct edac_device_ctl_info, link);
286
287 if (edac_dev->dev == dev)
288 return edac_dev;
289 }
290
291 return NULL;
292}
293
294
295
296
297
298
299
300
301
302
303
304
305static int add_edac_dev_to_global_list(struct edac_device_ctl_info *edac_dev)
306{
307 struct list_head *item, *insert_before;
308 struct edac_device_ctl_info *rover;
309
310 insert_before = &edac_device_list;
311
312
313 rover = find_edac_device_by_dev(edac_dev->dev);
314 if (unlikely(rover != NULL))
315 goto fail0;
316
317
318 list_for_each(item, &edac_device_list) {
319 rover = list_entry(item, struct edac_device_ctl_info, link);
320
321 if (rover->dev_idx >= edac_dev->dev_idx) {
322 if (unlikely(rover->dev_idx == edac_dev->dev_idx))
323 goto fail1;
324
325 insert_before = item;
326 break;
327 }
328 }
329
330 list_add_tail_rcu(&edac_dev->link, insert_before);
331 return 0;
332
333fail0:
334 edac_printk(KERN_WARNING, EDAC_MC,
335 "%s (%s) %s %s already assigned %d\n",
336 dev_name(rover->dev), edac_dev_name(rover),
337 rover->mod_name, rover->ctl_name, rover->dev_idx);
338 return 1;
339
340fail1:
341 edac_printk(KERN_WARNING, EDAC_MC,
342 "bug in low-level driver: attempt to assign\n"
343 " duplicate dev_idx %d in %s()\n", rover->dev_idx,
344 __func__);
345 return 1;
346}
347
348
349
350
351
352
353static void complete_edac_device_list_del(struct rcu_head *head)
354{
355 struct edac_device_ctl_info *edac_dev;
356
357 edac_dev = container_of(head, struct edac_device_ctl_info, rcu);
358 INIT_LIST_HEAD(&edac_dev->link);
359}
360
361
362
363
364
365
366
367static void del_edac_device_from_global_list(struct edac_device_ctl_info
368 *edac_device)
369{
370 list_del_rcu(&edac_device->link);
371 call_rcu(&edac_device->rcu, complete_edac_device_list_del);
372 rcu_barrier();
373}
374
375
376
377
378
379
380
381
382
383
384
385
386
387static void edac_device_workq_function(struct work_struct *work_req)
388{
389 struct delayed_work *d_work = to_delayed_work(work_req);
390 struct edac_device_ctl_info *edac_dev = to_edac_device_ctl_work(d_work);
391
392 mutex_lock(&device_ctls_mutex);
393
394
395 if (edac_dev->op_state == OP_OFFLINE) {
396 mutex_unlock(&device_ctls_mutex);
397 return;
398 }
399
400
401 if ((edac_dev->op_state == OP_RUNNING_POLL) &&
402 (edac_dev->edac_check != NULL)) {
403 edac_dev->edac_check(edac_dev);
404 }
405
406 mutex_unlock(&device_ctls_mutex);
407
408
409
410
411
412
413 if (edac_dev->poll_msec == 1000)
414 queue_delayed_work(edac_workqueue, &edac_dev->work,
415 round_jiffies_relative(edac_dev->delay));
416 else
417 queue_delayed_work(edac_workqueue, &edac_dev->work,
418 edac_dev->delay);
419}
420
421
422
423
424
425
426void edac_device_workq_setup(struct edac_device_ctl_info *edac_dev,
427 unsigned msec)
428{
429 debugf0("%s()\n", __func__);
430
431
432
433
434
435 edac_dev->poll_msec = msec;
436 edac_dev->delay = msecs_to_jiffies(msec);
437
438 INIT_DELAYED_WORK(&edac_dev->work, edac_device_workq_function);
439
440
441
442
443
444
445 if (edac_dev->poll_msec == 1000)
446 queue_delayed_work(edac_workqueue, &edac_dev->work,
447 round_jiffies_relative(edac_dev->delay));
448 else
449 queue_delayed_work(edac_workqueue, &edac_dev->work,
450 edac_dev->delay);
451}
452
453
454
455
456
457void edac_device_workq_teardown(struct edac_device_ctl_info *edac_dev)
458{
459 int status;
460
461 status = cancel_delayed_work(&edac_dev->work);
462 if (status == 0) {
463
464 flush_workqueue(edac_workqueue);
465 }
466}
467
468
469
470
471
472
473
474
475void edac_device_reset_delay_period(struct edac_device_ctl_info *edac_dev,
476 unsigned long value)
477{
478
479 edac_device_workq_teardown(edac_dev);
480
481
482 mutex_lock(&device_ctls_mutex);
483
484
485 edac_device_workq_setup(edac_dev, value);
486
487 mutex_unlock(&device_ctls_mutex);
488}
489
490
491
492
493
494
495
496int edac_device_alloc_index(void)
497{
498 static atomic_t device_indexes = ATOMIC_INIT(0);
499
500 return atomic_inc_return(&device_indexes) - 1;
501}
502EXPORT_SYMBOL_GPL(edac_device_alloc_index);
503
504
505
506
507
508
509
510
511
512
513
514
515int edac_device_add_device(struct edac_device_ctl_info *edac_dev)
516{
517 debugf0("%s()\n", __func__);
518
519#ifdef CONFIG_EDAC_DEBUG
520 if (edac_debug_level >= 3)
521 edac_device_dump_device(edac_dev);
522#endif
523 mutex_lock(&device_ctls_mutex);
524
525 if (add_edac_dev_to_global_list(edac_dev))
526 goto fail0;
527
528
529 edac_dev->start_time = jiffies;
530
531
532 if (edac_device_create_sysfs(edac_dev)) {
533 edac_device_printk(edac_dev, KERN_WARNING,
534 "failed to create sysfs device\n");
535 goto fail1;
536 }
537
538
539 if (edac_dev->edac_check != NULL) {
540
541 edac_dev->op_state = OP_RUNNING_POLL;
542
543
544
545
546
547 edac_device_workq_setup(edac_dev, 1000);
548 } else {
549 edac_dev->op_state = OP_RUNNING_INTERRUPT;
550 }
551
552
553 edac_device_printk(edac_dev, KERN_INFO,
554 "Giving out device to module '%s' controller "
555 "'%s': DEV '%s' (%s)\n",
556 edac_dev->mod_name,
557 edac_dev->ctl_name,
558 edac_dev_name(edac_dev),
559 edac_op_state_to_string(edac_dev->op_state));
560
561 mutex_unlock(&device_ctls_mutex);
562 return 0;
563
564fail1:
565
566 del_edac_device_from_global_list(edac_dev);
567
568fail0:
569 mutex_unlock(&device_ctls_mutex);
570 return 1;
571}
572EXPORT_SYMBOL_GPL(edac_device_add_device);
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587struct edac_device_ctl_info *edac_device_del_device(struct device *dev)
588{
589 struct edac_device_ctl_info *edac_dev;
590
591 debugf0("%s()\n", __func__);
592
593 mutex_lock(&device_ctls_mutex);
594
595
596 edac_dev = find_edac_device_by_dev(dev);
597 if (edac_dev == NULL) {
598 mutex_unlock(&device_ctls_mutex);
599 return NULL;
600 }
601
602
603 edac_dev->op_state = OP_OFFLINE;
604
605
606 del_edac_device_from_global_list(edac_dev);
607
608 mutex_unlock(&device_ctls_mutex);
609
610
611 edac_device_workq_teardown(edac_dev);
612
613
614 edac_device_remove_sysfs(edac_dev);
615
616 edac_printk(KERN_INFO, EDAC_MC,
617 "Removed device %d for %s %s: DEV %s\n",
618 edac_dev->dev_idx,
619 edac_dev->mod_name, edac_dev->ctl_name, edac_dev_name(edac_dev));
620
621 return edac_dev;
622}
623EXPORT_SYMBOL_GPL(edac_device_del_device);
624
625static inline int edac_device_get_log_ce(struct edac_device_ctl_info *edac_dev)
626{
627 return edac_dev->log_ce;
628}
629
630static inline int edac_device_get_log_ue(struct edac_device_ctl_info *edac_dev)
631{
632 return edac_dev->log_ue;
633}
634
635static inline int edac_device_get_panic_on_ue(struct edac_device_ctl_info
636 *edac_dev)
637{
638 return edac_dev->panic_on_ue;
639}
640
641
642
643
644
645void edac_device_handle_ce(struct edac_device_ctl_info *edac_dev,
646 int inst_nr, int block_nr, const char *msg)
647{
648 struct edac_device_instance *instance;
649 struct edac_device_block *block = NULL;
650
651 if ((inst_nr >= edac_dev->nr_instances) || (inst_nr < 0)) {
652 edac_device_printk(edac_dev, KERN_ERR,
653 "INTERNAL ERROR: 'instance' out of range "
654 "(%d >= %d)\n", inst_nr,
655 edac_dev->nr_instances);
656 return;
657 }
658
659 instance = edac_dev->instances + inst_nr;
660
661 if ((block_nr >= instance->nr_blocks) || (block_nr < 0)) {
662 edac_device_printk(edac_dev, KERN_ERR,
663 "INTERNAL ERROR: instance %d 'block' "
664 "out of range (%d >= %d)\n",
665 inst_nr, block_nr,
666 instance->nr_blocks);
667 return;
668 }
669
670 if (instance->nr_blocks > 0) {
671 block = instance->blocks + block_nr;
672 block->counters.ce_count++;
673 }
674
675
676 instance->counters.ce_count++;
677 edac_dev->counters.ce_count++;
678
679 if (edac_device_get_log_ce(edac_dev))
680 edac_device_printk(edac_dev, KERN_WARNING,
681 "CE: %s instance: %s block: %s '%s'\n",
682 edac_dev->ctl_name, instance->name,
683 block ? block->name : "N/A", msg);
684}
685EXPORT_SYMBOL_GPL(edac_device_handle_ce);
686
687
688
689
690
691void edac_device_handle_ue(struct edac_device_ctl_info *edac_dev,
692 int inst_nr, int block_nr, const char *msg)
693{
694 struct edac_device_instance *instance;
695 struct edac_device_block *block = NULL;
696
697 if ((inst_nr >= edac_dev->nr_instances) || (inst_nr < 0)) {
698 edac_device_printk(edac_dev, KERN_ERR,
699 "INTERNAL ERROR: 'instance' out of range "
700 "(%d >= %d)\n", inst_nr,
701 edac_dev->nr_instances);
702 return;
703 }
704
705 instance = edac_dev->instances + inst_nr;
706
707 if ((block_nr >= instance->nr_blocks) || (block_nr < 0)) {
708 edac_device_printk(edac_dev, KERN_ERR,
709 "INTERNAL ERROR: instance %d 'block' "
710 "out of range (%d >= %d)\n",
711 inst_nr, block_nr,
712 instance->nr_blocks);
713 return;
714 }
715
716 if (instance->nr_blocks > 0) {
717 block = instance->blocks + block_nr;
718 block->counters.ue_count++;
719 }
720
721
722 instance->counters.ue_count++;
723 edac_dev->counters.ue_count++;
724
725 if (edac_device_get_log_ue(edac_dev))
726 edac_device_printk(edac_dev, KERN_EMERG,
727 "UE: %s instance: %s block: %s '%s'\n",
728 edac_dev->ctl_name, instance->name,
729 block ? block->name : "N/A", msg);
730
731 if (edac_device_get_panic_on_ue(edac_dev))
732 panic("EDAC %s: UE instance: %s block %s '%s'\n",
733 edac_dev->ctl_name, instance->name,
734 block ? block->name : "N/A", msg);
735}
736EXPORT_SYMBOL_GPL(edac_device_handle_ue);
737