drivers/edac/edac_device.h

   1 /*
   2  * Defines, structures, APIs for edac_device
   3  *
   4  * (C) 2007 Linux Networx (http://lnxi.com)
   5  * This file may be distributed under the terms of the
   6  * GNU General Public License.
   7  *
   8  * Written by Thayne Harbaugh
   9  * Based on work by Dan Hollis <goemon at anime dot net> and others.
  10  *      http://www.anime.net/~goemon/linux-ecc/
  11  *
  12  * NMI handling support added by
  13  *     Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>
  14  *
  15  * Refactored for multi-source files:
  16  *      Doug Thompson <norsk5@xmission.com>
  17  *
  18  * Please look at Documentation/driver-api/edac.rst for more info about
  19  * EDAC core structs and functions.
  20  */
  21
  22 #ifndef _EDAC_DEVICE_H_
  23 #define _EDAC_DEVICE_H_
  24
  25 #include <linux/completion.h>
  26 #include <linux/device.h>
  27 #include <linux/edac.h>
  28 #include <linux/kobject.h>
  29 #include <linux/list.h>
  30 #include <linux/types.h>
  31 #include <linux/sysfs.h>
  32 #include <linux/workqueue.h>
  33
  34
  35 /*
  36  * The following are the structures to provide for a generic
  37  * or abstract 'edac_device'. This set of structures and the
  38  * code that implements the APIs for the same, provide for
  39  * registering EDAC type devices which are NOT standard memory.
  40  *
  41  * CPU caches (L1 and L2)
  42  * DMA engines
  43  * Core CPU switches
  44  * Fabric switch units
  45  * PCIe interface controllers
  46  * other EDAC/ECC type devices that can be monitored for
  47  * errors, etc.
  48  *
  49  * It allows for a 2 level set of hierarchy. For example:
  50  *
  51  * cache could be composed of L1, L2 and L3 levels of cache.
  52  * Each CPU core would have its own L1 cache, while sharing
  53  * L2 and maybe L3 caches.
  54  *
  55  * View them arranged, via the sysfs presentation:
  56  * /sys/devices/system/edac/..
  57  *
  58  *      mc/             <existing memory device directory>
  59  *      cpu/cpu0/..     <L1 and L2 block directory>
  60  *              /L1-cache/ce_count
  61  *                       /ue_count
  62  *              /L2-cache/ce_count
  63  *                       /ue_count
  64  *      cpu/cpu1/..     <L1 and L2 block directory>
  65  *              /L1-cache/ce_count
  66  *                       /ue_count
  67  *              /L2-cache/ce_count
  68  *                       /ue_count
  69  *      ...
  70  *
  71  *      the L1 and L2 directories would be "edac_device_block's"
  72  */
  73
  74 struct edac_device_counter {
  75         u32 ue_count;
  76         u32 ce_count;
  77 };
  78
  79 /* forward reference */
  80 struct edac_device_ctl_info;
  81 struct edac_device_block;
  82
  83 /* edac_dev_sysfs_attribute structure
  84  *      used for driver sysfs attributes in mem_ctl_info
  85  *      for extra controls and attributes:
  86  *              like high level error Injection controls
  87  */
  88 struct edac_dev_sysfs_attribute {
  89         struct attribute attr;
  90         ssize_t (*show)(struct edac_device_ctl_info *, char *);
  91         ssize_t (*store)(struct edac_device_ctl_info *, const char *, size_t);
  92 };
  93
  94 /* edac_dev_sysfs_block_attribute structure
  95  *
  96  *      used in leaf 'block' nodes for adding controls/attributes
  97  *
  98  *      each block in each instance of the containing control structure
  99  *      can have an array of the following. The show and store functions
 100  *      will be filled in with the show/store function in the
 101  *      low level driver.
 102  *
 103  *      The 'value' field will be the actual value field used for
 104  *      counting
 105  */
 106 struct edac_dev_sysfs_block_attribute {
 107         struct attribute attr;
 108         ssize_t (*show)(struct kobject *, struct attribute *, char *);
 109         ssize_t (*store)(struct kobject *, struct attribute *,
 110                         const char *, size_t);
 111         struct edac_device_block *block;
 112
 113         unsigned int value;
 114 };
 115
 116 /* device block control structure */
 117 struct edac_device_block {
 118         struct edac_device_instance *instance;  /* Up Pointer */
 119         char name[EDAC_DEVICE_NAME_LEN + 1];
 120
 121         struct edac_device_counter counters;    /* basic UE and CE counters */
 122
 123         int nr_attribs;         /* how many attributes */
 124
 125         /* this block's attributes, could be NULL */
 126         struct edac_dev_sysfs_block_attribute *block_attributes;
 127
 128         /* edac sysfs device control */
 129         struct kobject kobj;
 130 };
 131
 132 /* device instance control structure */
 133 struct edac_device_instance {
 134         struct edac_device_ctl_info *ctl;       /* Up pointer */
 135         char name[EDAC_DEVICE_NAME_LEN + 4];
 136
 137         struct edac_device_counter counters;    /* instance counters */
 138
 139         u32 nr_blocks;          /* how many blocks */
 140         struct edac_device_block *blocks;       /* block array */
 141
 142         /* edac sysfs device control */
 143         struct kobject kobj;
 144 };
 145
 146
 147 /*
 148  * Abstract edac_device control info structure
 149  *
 150  */
 151 struct edac_device_ctl_info {
 152         /* for global list of edac_device_ctl_info structs */
 153         struct list_head link;
 154
 155         struct module *owner;   /* Module owner of this control struct */
 156
 157         int dev_idx;
 158
 159         /* Per instance controls for this edac_device */
 160         int log_ue;             /* boolean for logging UEs */
 161         int log_ce;             /* boolean for logging CEs */
 162         int panic_on_ue;        /* boolean for panic'ing on an UE */
 163         unsigned poll_msec;     /* number of milliseconds to poll interval */
 164         unsigned long delay;    /* number of jiffies for poll_msec */
 165
 166         /* Additional top controller level attributes, but specified
 167          * by the low level driver.
 168          *
 169          * Set by the low level driver to provide attributes at the
 170          * controller level, same level as 'ue_count' and 'ce_count' above.
 171          * An array of structures, NULL terminated
 172          *
 173          * If attributes are desired, then set to array of attributes
 174          * If no attributes are desired, leave NULL
 175          */
 176         struct edac_dev_sysfs_attribute *sysfs_attributes;
 177
 178         /* pointer to main 'edac' subsys in sysfs */
 179         struct bus_type *edac_subsys;
 180
 181         /* the internal state of this controller instance */
 182         int op_state;
 183         /* work struct for this instance */
 184         struct delayed_work work;
 185
 186         /* pointer to edac polling checking routine:
 187          *      If NOT NULL: points to polling check routine
 188          *      If NULL: Then assumes INTERRUPT operation, where
 189          *              MC driver will receive events
 190          */
 191         void (*edac_check) (struct edac_device_ctl_info * edac_dev);
 192
 193         struct device *dev;     /* pointer to device structure */
 194
 195         const char *mod_name;   /* module name */
 196         const char *ctl_name;   /* edac controller  name */
 197         const char *dev_name;   /* pci/platform/etc... name */
 198
 199         void *pvt_info;         /* pointer to 'private driver' info */
 200
 201         unsigned long start_time;       /* edac_device load start time (jiffies) */
 202
 203         struct completion removal_complete;
 204
 205         /* sysfs top name under 'edac' directory
 206          * and instance name:
 207          *      cpu/cpu0/...
 208          *      cpu/cpu1/...
 209          *      cpu/cpu2/...
 210          *      ...
 211          */
 212         char name[EDAC_DEVICE_NAME_LEN + 1];
 213
 214         /* Number of instances supported on this control structure
 215          * and the array of those instances
 216          */
 217         u32 nr_instances;
 218         struct edac_device_instance *instances;
 219
 220         /* Event counters for the this whole EDAC Device */
 221         struct edac_device_counter counters;
 222
 223         /* edac sysfs device control for the 'name'
 224          * device this structure controls
 225          */
 226         struct kobject kobj;
 227 };
 228
 229 /* To get from the instance's wq to the beginning of the ctl structure */
 230 #define to_edac_mem_ctl_work(w) \
 231                 container_of(w, struct mem_ctl_info, work)
 232
 233 #define to_edac_device_ctl_work(w) \
 234                 container_of(w,struct edac_device_ctl_info,work)
 235
 236 /*
 237  * The alloc() and free() functions for the 'edac_device' control info
 238  * structure. A MC driver will allocate one of these for each edac_device
 239  * it is going to control/register with the EDAC CORE.
 240  */
 241 extern struct edac_device_ctl_info *edac_device_alloc_ctl_info(
 242                 unsigned sizeof_private,
 243                 char *edac_device_name, unsigned nr_instances,
 244                 char *edac_block_name, unsigned nr_blocks,
 245                 unsigned offset_value,
 246                 struct edac_dev_sysfs_block_attribute *block_attributes,
 247                 unsigned nr_attribs,
 248                 int device_index);
 249
 250 /* The offset value can be:
 251  *      -1 indicating no offset value
 252  *      0 for zero-based block numbers
 253  *      1 for 1-based block number
 254  *      other for other-based block number
 255  */
 256 #define BLOCK_OFFSET_VALUE_OFF  ((unsigned) -1)
 257
 258 extern void edac_device_free_ctl_info(struct edac_device_ctl_info *ctl_info);
 259
 260 /**
 261  * edac_device_add_device: Insert the 'edac_dev' structure into the
 262  *       edac_device global list and create sysfs entries associated with
 263  *       edac_device structure.
 264  *
 265  * @edac_dev: pointer to edac_device structure to be added to the list
 266  *      'edac_device' structure.
 267  *
 268  * Returns:
 269  *      0 on Success, or an error code on failure
 270  */
 271 extern int edac_device_add_device(struct edac_device_ctl_info *edac_dev);
 272
 273 /**
 274  * edac_device_del_device:
 275  *      Remove sysfs entries for specified edac_device structure and
 276  *      then remove edac_device structure from global list
 277  *
 278  * @dev:
 279  *      Pointer to struct &device representing the edac device
 280  *      structure to remove.
 281  *
 282  * Returns:
 283  *      Pointer to removed edac_device structure,
 284  *      or %NULL if device not found.
 285  */
 286 extern struct edac_device_ctl_info *edac_device_del_device(struct device *dev);
 287
 288 /**
 289  * Log correctable errors.
 290  *
 291  * @edac_dev: pointer to struct &edac_device_ctl_info
 292  * @inst_nr: number of the instance where the CE error happened
 293  * @count: Number of errors to log.
 294  * @block_nr: number of the block where the CE error happened
 295  * @msg: message to be printed
 296  */
 297 void edac_device_handle_ce_count(struct edac_device_ctl_info *edac_dev,
 298                                  unsigned int count, int inst_nr, int block_nr,
 299                                  const char *msg);
 300
 301 /**
 302  * Log uncorrectable errors.
 303  *
 304  * @edac_dev: pointer to struct &edac_device_ctl_info
 305  * @inst_nr: number of the instance where the CE error happened
 306  * @count: Number of errors to log.
 307  * @block_nr: number of the block where the CE error happened
 308  * @msg: message to be printed
 309  */
 310 void edac_device_handle_ue_count(struct edac_device_ctl_info *edac_dev,
 311                                  unsigned int count, int inst_nr, int block_nr,
 312                                  const char *msg);
 313
 314 /**
 315  * edac_device_handle_ce(): Log a single correctable error
 316  *
 317  * @edac_dev: pointer to struct &edac_device_ctl_info
 318  * @inst_nr: number of the instance where the CE error happened
 319  * @block_nr: number of the block where the CE error happened
 320  * @msg: message to be printed
 321  */
 322 static inline void
 323 edac_device_handle_ce(struct edac_device_ctl_info *edac_dev, int inst_nr,
 324                       int block_nr, const char *msg)
 325 {
 326         edac_device_handle_ce_count(edac_dev, 1, inst_nr, block_nr, msg);
 327 }
 328
 329 /**
 330  * edac_device_handle_ue(): Log a single uncorrectable error
 331  *
 332  * @edac_dev: pointer to struct &edac_device_ctl_info
 333  * @inst_nr: number of the instance where the UE error happened
 334  * @block_nr: number of the block where the UE error happened
 335  * @msg: message to be printed
 336  */
 337 static inline void
 338 edac_device_handle_ue(struct edac_device_ctl_info *edac_dev, int inst_nr,
 339                       int block_nr, const char *msg)
 340 {
 341         edac_device_handle_ue_count(edac_dev, 1, inst_nr, block_nr, msg);
 342 }
 343
 344 /**
 345  * edac_device_alloc_index: Allocate a unique device index number
 346  *
 347  * Returns:
 348  *      allocated index number
 349  */
 350 extern int edac_device_alloc_index(void);
 351 extern const char *edac_layer_name[];
 352 #endif