| Linux kernel & device driver programming |
| [ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] |
1 /* 1
2 * file for managing the edac_device class of
3 *
4 * (C) 2007 SoftwareBitMaker (http://www.softw
5 *
6 * This file may be distributed under the term
7 * GNU General Public License.
8 *
9 * Written Doug Thompson <norsk5@xmission.com>
10 *
11 */
12
13 #include <linux/ctype.h>
14 #include <linux/module.h>
15
16 #include "edac_core.h"
17 #include "edac_module.h"
18
19 #define EDAC_DEVICE_SYMLINK "device"
20
21 #define to_edacdev(k) container_of(k, struct e
22 #define to_edacdev_attr(a) container_of(a, str
23
24
25 /*
26 * Set of edac_device_ctl_info attribute store
27 */
28
29 /* 'log_ue' */
30 static ssize_t edac_device_ctl_log_ue_show(str
31 *ctl_i
32 {
33 return sprintf(data, "%u\n", ctl_info-
34 }
35
36 static ssize_t edac_device_ctl_log_ue_store(st
37 *ctl_i
38 size_t
39 {
40 /* if parameter is zero, turn off flag
41 ctl_info->log_ue = (simple_strtoul(dat
42
43 return count;
44 }
45
46 /* 'log_ce' */
47 static ssize_t edac_device_ctl_log_ce_show(str
48 *ctl_i
49 {
50 return sprintf(data, "%u\n", ctl_info-
51 }
52
53 static ssize_t edac_device_ctl_log_ce_store(st
54 *ctl_i
55 size_t
56 {
57 /* if parameter is zero, turn off flag
58 ctl_info->log_ce = (simple_strtoul(dat
59
60 return count;
61 }
62
63 /* 'panic_on_ue' */
64 static ssize_t edac_device_ctl_panic_on_ue_sho
65
66 {
67 return sprintf(data, "%u\n", ctl_info-
68 }
69
70 static ssize_t edac_device_ctl_panic_on_ue_sto
71
72
73 {
74 /* if parameter is zero, turn off flag
75 ctl_info->panic_on_ue = (simple_strtou
76
77 return count;
78 }
79
80 /* 'poll_msec' show and store functions*/
81 static ssize_t edac_device_ctl_poll_msec_show(
82 *ctl_i
83 {
84 return sprintf(data, "%u\n", ctl_info-
85 }
86
87 static ssize_t edac_device_ctl_poll_msec_store
88 *ctl_i
89 size_t
90 {
91 unsigned long value;
92
93 /* get the value and enforce that it i
94 * one millisecond for the delay perio
95 * Then cancel last outstanding delay
96 * and set a new one.
97 */
98 value = simple_strtoul(data, NULL, 0);
99 edac_device_reset_delay_period(ctl_inf
100
101 return count;
102 }
103
104 /* edac_device_ctl_info specific attribute str
105 struct ctl_info_attribute {
106 struct attribute attr;
107 ssize_t(*show) (struct edac_device_ctl
108 ssize_t(*store) (struct edac_device_ct
109 };
110
111 #define to_ctl_info(k) container_of(k, struct
112 #define to_ctl_info_attr(a) container_of(a,str
113
114 /* Function to 'show' fields from the edac_dev
115 static ssize_t edac_dev_ctl_info_show(struct k
116 struct attribu
117 {
118 struct edac_device_ctl_info *edac_dev
119 struct ctl_info_attribute *ctl_info_at
120
121 if (ctl_info_attr->show)
122 return ctl_info_attr->show(eda
123 return -EIO;
124 }
125
126 /* Function to 'store' fields into the edac_de
127 static ssize_t edac_dev_ctl_info_store(struct
128 struct attribu
129 const char *bu
130 {
131 struct edac_device_ctl_info *edac_dev
132 struct ctl_info_attribute *ctl_info_at
133
134 if (ctl_info_attr->store)
135 return ctl_info_attr->store(ed
136 return -EIO;
137 }
138
139 /* edac_dev file operations for an 'ctl_info'
140 static struct sysfs_ops device_ctl_info_ops =
141 .show = edac_dev_ctl_info_show,
142 .store = edac_dev_ctl_info_store
143 };
144
145 #define CTL_INFO_ATTR(_name,_mode,_show,_store
146 static struct ctl_info_attribute attr_ctl_info
147 .attr = {.name = __stringify(_name), .
148 .show = _show,
149 .store = _store,
150 };
151
152 /* Declare the various ctl_info attributes her
153 CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR,
154 edac_device_ctl_log_ue_show, edac_devi
155 CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR,
156 edac_device_ctl_log_ce_show, edac_devi
157 CTL_INFO_ATTR(panic_on_ue, S_IRUGO | S_IWUSR,
158 edac_device_ctl_panic_on_ue_show,
159 edac_device_ctl_panic_on_ue_store);
160 CTL_INFO_ATTR(poll_msec, S_IRUGO | S_IWUSR,
161 edac_device_ctl_poll_msec_show, edac_d
162
163 /* Base Attributes of the EDAC_DEVICE ECC obje
164 static struct ctl_info_attribute *device_ctrl_
165 &attr_ctl_info_panic_on_ue,
166 &attr_ctl_info_log_ue,
167 &attr_ctl_info_log_ce,
168 &attr_ctl_info_poll_msec,
169 NULL,
170 };
171
172 /*
173 * edac_device_ctrl_master_release
174 *
175 * called when the reference count for th
176 * for a edac_device control struct reach
177 *
178 * Reference count model:
179 * One 'main' kobject for each co
180 * That main kobj is initially se
181 * the reference count for the ED
182 * bumped by one, thus added 'kee
183 *
184 * Each new internal kobj (in ins
185 * bumps the 'main' kobject.
186 *
187 * When they are released their r
188 * the 'main' kobj.
189 *
190 * When the main kobj reaches zer
191 * is called which then decrement
192 * When the module reference coun
193 * module no longer has dependenc
194 * function code in memory and mo
195 *
196 * This will support several cont
197 * with its own 'main' kobj.
198 */
199 static void edac_device_ctrl_master_release(st
200 {
201 struct edac_device_ctl_info *edac_dev
202
203 debugf4("%s() control index=%d\n", __f
204
205 /* decrement the EDAC CORE module ref
206 module_put(edac_dev->owner);
207
208 /* free the control struct containing
209 * passed in to this routine
210 */
211 kfree(edac_dev);
212 }
213
214 /* ktype for the main (master) kobject */
215 static struct kobj_type ktype_device_ctrl = {
216 .release = edac_device_ctrl_master_rel
217 .sysfs_ops = &device_ctl_info_ops,
218 .default_attrs = (struct attribute **)
219 };
220
221 /*
222 * edac_device_register_sysfs_main_kobj
223 *
224 * perform the high level setup for the n
225 *
226 * Return: 0 SUCCESS
227 * !0 FAILURE
228 */
229 int edac_device_register_sysfs_main_kobj(struc
230 {
231 struct sysdev_class *edac_class;
232 int err;
233
234 debugf1("%s()\n", __func__);
235
236 /* get the /sys/devices/system/edac re
237 edac_class = edac_get_edac_class();
238 if (edac_class == NULL) {
239 debugf1("%s() no edac_class er
240 err = -ENODEV;
241 goto err_out;
242 }
243
244 /* Point to the 'edac_class' this inst
245 edac_dev->edac_class = edac_class;
246
247 /* Init the devices's kobject */
248 memset(&edac_dev->kobj, 0, sizeof(stru
249
250 /* Record which module 'owns' this con
251 * and bump the ref count of the modul
252 */
253 edac_dev->owner = THIS_MODULE;
254
255 if (!try_module_get(edac_dev->owner))
256 err = -ENODEV;
257 goto err_out;
258 }
259
260 /* register */
261 err = kobject_init_and_add(&edac_dev->
262 &edac_class
263 "%s", edac_
264 if (err) {
265 debugf1("%s()Failed to registe
266 __func__, edac_dev->na
267 goto err_kobj_reg;
268 }
269 kobject_uevent(&edac_dev->kobj, KOBJ_A
270
271 /* At this point, to 'free' the contro
272 * edac_device_unregister_sysfs_main_k
273 */
274
275 debugf4("%s() Registered '.../edac/%s'
276 __func__, edac_dev->name);
277
278 return 0;
279
280 /* Error exit stack */
281 err_kobj_reg:
282 module_put(edac_dev->owner);
283
284 err_out:
285 return err;
286 }
287
288 /*
289 * edac_device_unregister_sysfs_main_kobj:
290 * the '..../edac/<name>' kobject
291 */
292 void edac_device_unregister_sysfs_main_kobj(
293 struct
294 {
295 debugf0("%s()\n", __func__);
296 debugf4("%s() name of kobject is: %s\n
297 __func__, kobject_name(&edac_d
298
299 /*
300 * Unregister the edac device's kobjec
301 * allow for reference count to reach
302 * the callback will be called to:
303 * a) module_put() this module
304 * b) 'kfree' the memory
305 */
306 kobject_put(&edac_dev->kobj);
307 }
308
309 /* edac_dev -> instance information */
310
311 /*
312 * Set of low-level instance attribute show fu
313 */
314 static ssize_t instance_ue_count_show(struct e
315 char *data)
316 {
317 return sprintf(data, "%u\n", instance-
318 }
319
320 static ssize_t instance_ce_count_show(struct e
321 char *data)
322 {
323 return sprintf(data, "%u\n", instance-
324 }
325
326 #define to_instance(k) container_of(k, struct
327 #define to_instance_attr(a) container_of(a,str
328
329 /* DEVICE instance kobject release() function
330 static void edac_device_ctrl_instance_release(
331 {
332 struct edac_device_instance *instance;
333
334 debugf1("%s()\n", __func__);
335
336 /* map from this kobj to the main cont
337 * and then dec the main kobj count
338 */
339 instance = to_instance(kobj);
340 kobject_put(&instance->ctl->kobj);
341 }
342
343 /* instance specific attribute structure */
344 struct instance_attribute {
345 struct attribute attr;
346 ssize_t(*show) (struct edac_device_ins
347 ssize_t(*store) (struct edac_device_in
348 };
349
350 /* Function to 'show' fields from the edac_dev
351 static ssize_t edac_dev_instance_show(struct k
352 struct attribu
353 {
354 struct edac_device_instance *instance
355 struct instance_attribute *instance_at
356
357 if (instance_attr->show)
358 return instance_attr->show(ins
359 return -EIO;
360 }
361
362 /* Function to 'store' fields into the edac_de
363 static ssize_t edac_dev_instance_store(struct
364 struct attribu
365 const char *bu
366 {
367 struct edac_device_instance *instance
368 struct instance_attribute *instance_at
369
370 if (instance_attr->store)
371 return instance_attr->store(in
372 return -EIO;
373 }
374
375 /* edac_dev file operations for an 'instance'
376 static struct sysfs_ops device_instance_ops =
377 .show = edac_dev_instance_show,
378 .store = edac_dev_instance_store
379 };
380
381 #define INSTANCE_ATTR(_name,_mode,_show,_store
382 static struct instance_attribute attr_instance
383 .attr = {.name = __stringify(_name), .
384 .show = _show,
385 .store = _store,
386 };
387
388 /*
389 * Define attributes visible for the edac_devi
390 * Each contains a pointer to a show and
391 * function pointer that does the low lev
392 */
393 INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_c
394 INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_c
395
396 /* list of edac_dev 'instance' attributes */
397 static struct instance_attribute *device_insta
398 &attr_instance_ce_count,
399 &attr_instance_ue_count,
400 NULL,
401 };
402
403 /* The 'ktype' for each edac_dev 'instance' */
404 static struct kobj_type ktype_instance_ctrl =
405 .release = edac_device_ctrl_instance_r
406 .sysfs_ops = &device_instance_ops,
407 .default_attrs = (struct attribute **)
408 };
409
410 /* edac_dev -> instance -> block information *
411
412 #define to_block(k) container_of(k, struct eda
413 #define to_block_attr(a) \
414 container_of(a, struct edac_dev_sysfs_
415
416 /*
417 * Set of low-level block attribute show funct
418 */
419 static ssize_t block_ue_count_show(struct kobj
420 struct
421 {
422 struct edac_device_block *block = to_b
423
424 return sprintf(data, "%u\n", block->co
425 }
426
427 static ssize_t block_ce_count_show(struct kobj
428 struct
429 {
430 struct edac_device_block *block = to_b
431
432 return sprintf(data, "%u\n", block->co
433 }
434
435 /* DEVICE block kobject release() function */
436 static void edac_device_ctrl_block_release(str
437 {
438 struct edac_device_block *block;
439
440 debugf1("%s()\n", __func__);
441
442 /* get the container of the kobj */
443 block = to_block(kobj);
444
445 /* map from 'block kobj' to 'block->in
446 * now 'release' the block kobject
447 */
448 kobject_put(&block->instance->ctl->kob
449 }
450
451
452 /* Function to 'show' fields from the edac_dev
453 static ssize_t edac_dev_block_show(struct kobj
454 struct attribu
455 {
456 struct edac_dev_sysfs_block_attribute
457
458
459 if (block_attr->show)
460 return block_attr->show(kobj,
461 return -EIO;
462 }
463
464 /* Function to 'store' fields into the edac_de
465 static ssize_t edac_dev_block_store(struct kob
466 struct attribu
467 const char *bu
468 {
469 struct edac_dev_sysfs_block_attribute
470
471 block_attr = to_block_attr(attr);
472
473 if (block_attr->store)
474 return block_attr->store(kobj,
475 return -EIO;
476 }
477
478 /* edac_dev file operations for a 'block' */
479 static struct sysfs_ops device_block_ops = {
480 .show = edac_dev_block_show,
481 .store = edac_dev_block_store
482 };
483
484 #define BLOCK_ATTR(_name,_mode,_show,_store)
485 static struct edac_dev_sysfs_block_attribute a
486 .attr = {.name = __stringify(_name), .
487 .show = _show,
488 .store = _store,
489 };
490
491 BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_s
492 BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_s
493
494 /* list of edac_dev 'block' attributes */
495 static struct edac_dev_sysfs_block_attribute *
496 &attr_block_ce_count,
497 &attr_block_ue_count,
498 NULL,
499 };
500
501 /* The 'ktype' for each edac_dev 'block' */
502 static struct kobj_type ktype_block_ctrl = {
503 .release = edac_device_ctrl_block_rele
504 .sysfs_ops = &device_block_ops,
505 .default_attrs = (struct attribute **)
506 };
507
508 /* block ctor/dtor code */
509
510 /*
511 * edac_device_create_block
512 */
513 static int edac_device_create_block(struct eda
514 struct edac_de
515 struct edac_de
516 {
517 int i;
518 int err;
519 struct edac_dev_sysfs_block_attribute
520 struct kobject *main_kobj;
521
522 debugf4("%s() Instance '%s' inst_p=%p
523 __func__, instance->name, inst
524 debugf4("%s() block kobj=%p block kob
525 __func__, &block->kobj, &block
526
527 /* init this block's kobject */
528 memset(&block->kobj, 0, sizeof(struct
529
530 /* bump the main kobject's reference c
531 * and this instance is dependant on t
532 */
533 main_kobj = kobject_get(&edac_dev->kob
534 if (!main_kobj) {
535 err = -ENODEV;
536 goto err_out;
537 }
538
539 /* Add this block's kobject */
540 err = kobject_init_and_add(&block->kob
541 &instance->
542 "%s", block
543 if (err) {
544 debugf1("%s() Failed to regist
545 __func__, block->name)
546 kobject_put(main_kobj);
547 err = -ENODEV;
548 goto err_out;
549 }
550
551 /* If there are driver level block att
552 * to the block kobject
553 */
554 sysfs_attrib = block->block_attributes
555 if (sysfs_attrib && block->nr_attribs)
556 for (i = 0; i < block->nr_attr
557
558 debugf4("%s() creating
559 "attrib->%p to
560 __func__,
561 sysfs_attrib->
562 sysfs_attrib,
563
564 /* Create each block_a
565 err = sysfs_create_fil
566 &sysfs_attrib-
567 if (err)
568 goto err_on_at
569 }
570 }
571 kobject_uevent(&block->kobj, KOBJ_ADD)
572
573 return 0;
574
575 /* Error unwind stack */
576 err_on_attrib:
577 kobject_put(&block->kobj);
578
579 err_out:
580 return err;
581 }
582
583 /*
584 * edac_device_delete_block(edac_dev,block);
585 */
586 static void edac_device_delete_block(struct ed
587 struct edac_de
588 {
589 struct edac_dev_sysfs_block_attribute
590 int i;
591
592 /* if this block has 'attributes' then
593 * and 'remove' the attributes on this
594 */
595 sysfs_attrib = block->block_attributes
596 if (sysfs_attrib && block->nr_attribs)
597 for (i = 0; i < block->nr_attr
598
599 /* remove each block_a
600 sysfs_remove_file(&blo
601 (struct attrib
602 }
603 }
604
605 /* unregister this block's kobject, SE
606 * edac_device_ctrl_block_release
607 */
608 kobject_put(&block->kobj);
609 }
610
611 /* instance ctor/dtor code */
612
613 /*
614 * edac_device_create_instance
615 * create just one instance of an edac_de
616 */
617 static int edac_device_create_instance(struct
618 int idx)
619 {
620 int i, j;
621 int err;
622 struct edac_device_instance *instance;
623 struct kobject *main_kobj;
624
625 instance = &edac_dev->instances[idx];
626
627 /* Init the instance's kobject */
628 memset(&instance->kobj, 0, sizeof(stru
629
630 instance->ctl = edac_dev;
631
632 /* bump the main kobject's reference c
633 * and this instance is dependant on t
634 */
635 main_kobj = kobject_get(&edac_dev->kob
636 if (!main_kobj) {
637 err = -ENODEV;
638 goto err_out;
639 }
640
641 /* Formally register this instance's k
642 err = kobject_init_and_add(&instance->
643 &edac_dev->
644 if (err != 0) {
645 debugf2("%s() Failed to regist
646 __func__, instance->na
647 kobject_put(main_kobj);
648 goto err_out;
649 }
650
651 debugf4("%s() now register '%d' blocks
652 __func__, instance->nr_blocks,
653
654 /* register all blocks of this instanc
655 for (i = 0; i < instance->nr_blocks; i
656 err = edac_device_create_block
657
658 if (err) {
659 /* If any fail, remove
660 for (j = 0; j < i; j++
661 edac_device_de
662
663 goto err_release_insta
664 }
665 }
666 kobject_uevent(&instance->kobj, KOBJ_A
667
668 debugf4("%s() Registered instance %d '
669 __func__, idx, instance->name)
670
671 return 0;
672
673 /* error unwind stack */
674 err_release_instance_kobj:
675 kobject_put(&instance->kobj);
676
677 err_out:
678 return err;
679 }
680
681 /*
682 * edac_device_remove_instance
683 * remove an edac_device instance
684 */
685 static void edac_device_delete_instance(struct
686 int id
687 {
688 struct edac_device_instance *instance;
689 int i;
690
691 instance = &edac_dev->instances[idx];
692
693 /* unregister all blocks in this insta
694 for (i = 0; i < instance->nr_blocks; i
695 edac_device_delete_block(edac_
696
697 /* unregister this instance's kobject,
698 * edac_device_ctrl_instance_rele
699 */
700 kobject_put(&instance->kobj);
701 }
702
703 /*
704 * edac_device_create_instances
705 * create the first level of 'instances'
706 * (ie 'cache' might have 'cache0', 'cac
707 */
708 static int edac_device_create_instances(struct
709 {
710 int i, j;
711 int err;
712
713 debugf0("%s()\n", __func__);
714
715 /* iterate over creation of the instan
716 for (i = 0; i < edac_dev->nr_instances
717 err = edac_device_create_insta
718 if (err) {
719 /* unwind previous ins
720 for (j = 0; j < i; j++
721 edac_device_de
722 return err;
723 }
724 }
725
726 return 0;
727 }
728
729 /*
730 * edac_device_delete_instances(edac_dev);
731 * unregister all the kobjects of the ins
732 */
733 static void edac_device_delete_instances(struc
734 {
735 int i;
736
737 /* iterate over creation of the instan
738 for (i = 0; i < edac_dev->nr_instances
739 edac_device_delete_instance(ed
740 }
741
742 /* edac_dev sysfs ctor/dtor code */
743
744 /*
745 * edac_device_add_main_sysfs_attributes
746 * add some attributes to this instance's
747 */
748 static int edac_device_add_main_sysfs_attribut
749 struct edac_device_ctl
750 {
751 struct edac_dev_sysfs_attribute *sysfs
752 int err = 0;
753
754 sysfs_attrib = edac_dev->sysfs_attribu
755 if (sysfs_attrib) {
756 /* iterate over the array and
757 * entry in the list
758 */
759 while (sysfs_attrib->attr.name
760 err = sysfs_create_fil
761 (struct attrib
762 if (err)
763 goto err_out;
764
765 sysfs_attrib++;
766 }
767 }
768
769 err_out:
770 return err;
771 }
772
773 /*
774 * edac_device_remove_main_sysfs_attributes
775 * remove any attributes to this instance
776 */
777 static void edac_device_remove_main_sysfs_attr
778 struct edac_device_ctl
779 {
780 struct edac_dev_sysfs_attribute *sysfs
781
782 /* if there are main attributes, defin
783 * point to the start of the array and
784 * removing each attribute listed from
785 */
786 sysfs_attrib = edac_dev->sysfs_attribu
787 if (sysfs_attrib) {
788 while (sysfs_attrib->attr.name
789 sysfs_remove_file(&eda
790 (struc
791 sysfs_attrib++;
792 }
793 }
794 }
795
796 /*
797 * edac_device_create_sysfs() Constructor
798 *
799 * accept a created edac_device control struct
800 * and 'export' it to sysfs. The 'main' kobj s
801 * created. 'instance' and 'block' kobjects sh
802 * along with any 'block' attributes from the
803 * the main attributes (if any) are connected
804 * the control structure.
805 *
806 * Return:
807 * 0 Success
808 * !0 Failure
809 */
810 int edac_device_create_sysfs(struct edac_devic
811 {
812 int err;
813 struct kobject *edac_kobj = &edac_dev-
814
815 debugf0("%s() idx=%d\n", __func__, eda
816
817 /* go create any main attributes call
818 err = edac_device_add_main_sysfs_attri
819 if (err) {
820 debugf0("%s() failed to add sy
821 goto err_out;
822 }
823
824 /* create a symlink from the edac devi
825 * to the platform 'device' being used
826 */
827 err = sysfs_create_link(edac_kobj,
828 &edac_dev->dev
829 if (err) {
830 debugf0("%s() sysfs_create_lin
831 __func__, err);
832 goto err_remove_main_attribs;
833 }
834
835 /* Create the first level instance dir
836 * In turn, the nested blocks beneath
837 * be registered as well
838 */
839 err = edac_device_create_instances(eda
840 if (err) {
841 debugf0("%s() edac_device_crea
842 "returned err= %d\n",
843 goto err_remove_link;
844 }
845
846
847 debugf4("%s() create-instances done, i
848 __func__, edac_dev->dev_idx);
849
850 return 0;
851
852 /* Error unwind stack */
853 err_remove_link:
854 /* remove the sym link */
855 sysfs_remove_link(&edac_dev->kobj, EDA
856
857 err_remove_main_attribs:
858 edac_device_remove_main_sysfs_attribut
859
860 err_out:
861 return err;
862 }
863
864 /*
865 * edac_device_remove_sysfs() destructor
866 *
867 * given an edac_device struct, tear down the
868 */
869 void edac_device_remove_sysfs(struct edac_devi
870 {
871 debugf0("%s()\n", __func__);
872
873 /* remove any main attributes for this
874 edac_device_remove_main_sysfs_attribut
875
876 /* remove the device sym link */
877 sysfs_remove_link(&edac_dev->kobj, EDA
878
879 /* walk the instance/block kobject tre
880 edac_device_delete_instances(edac_dev)
881 }
882
| This page was automatically generated by the LXR engine. |