Blame view
drivers/edac/edac_core.h
27.5 KB
7c9281d76 drivers/edac: spl... |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
/* * Defines, structures, APIs for edac_core module * * (C) 2007 Linux Networx (http://lnxi.com) * This file may be distributed under the terms of the * GNU General Public License. * * Written by Thayne Harbaugh * Based on work by Dan Hollis <goemon at anime dot net> and others. * http://www.anime.net/~goemon/linux-ecc/ * * NMI handling support added by * Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com> * * Refactored for multi-source files: * Doug Thompson <norsk5@xmission.com> * */ #ifndef _EDAC_CORE_H_ #define _EDAC_CORE_H_ #include <linux/kernel.h> #include <linux/types.h> #include <linux/module.h> #include <linux/spinlock.h> #include <linux/smp.h> #include <linux/pci.h> #include <linux/time.h> #include <linux/nmi.h> #include <linux/rcupdate.h> #include <linux/completion.h> #include <linux/kobject.h> #include <linux/platform_device.h> |
e27e3dac6 drivers/edac: add... |
35 36 |
#include <linux/sysdev.h> #include <linux/workqueue.h> |
7c9281d76 drivers/edac: spl... |
37 38 |
#define EDAC_MC_LABEL_LEN 31 |
e27e3dac6 drivers/edac: add... |
39 40 41 |
#define EDAC_DEVICE_NAME_LEN 31 #define EDAC_ATTRIB_VALUE_LEN 15 #define MC_PROC_NAME_MAX_LEN 7 |
7c9281d76 drivers/edac: spl... |
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
#if PAGE_SHIFT < 20 #define PAGES_TO_MiB( pages ) ( ( pages ) >> ( 20 - PAGE_SHIFT ) ) #else /* PAGE_SHIFT > 20 */ #define PAGES_TO_MiB( pages ) ( ( pages ) << ( PAGE_SHIFT - 20 ) ) #endif #define edac_printk(level, prefix, fmt, arg...) \ printk(level "EDAC " prefix ": " fmt, ##arg) #define edac_mc_printk(mci, level, fmt, arg...) \ printk(level "EDAC MC%d: " fmt, mci->mc_idx, ##arg) #define edac_mc_chipset_printk(mci, level, prefix, fmt, arg...) \ printk(level "EDAC " prefix " MC%d: " fmt, mci->mc_idx, ##arg) |
e27e3dac6 drivers/edac: add... |
57 58 |
#define edac_device_printk(ctl, level, fmt, arg...) \ printk(level "EDAC DEVICE%d: " fmt, ctl->dev_idx, ##arg) |
91b99041c drivers/edac: upd... |
59 60 |
#define edac_pci_printk(ctl, level, fmt, arg...) \ printk(level "EDAC PCI%d: " fmt, ctl->pci_idx, ##arg) |
7c9281d76 drivers/edac: spl... |
61 62 63 64 65 66 67 |
/* prefixes for edac_printk() and edac_mc_printk() */ #define EDAC_MC "MC" #define EDAC_PCI "PCI" #define EDAC_DEBUG "DEBUG" #ifdef CONFIG_EDAC_DEBUG extern int edac_debug_level; |
239642fe1 edac: add memory ... |
68 |
extern const char *edac_mem_types[]; |
7c9281d76 drivers/edac: spl... |
69 |
|
d357cbb44 edac: fold __func... |
70 71 72 73 74 |
#define edac_debug_printk(level, fmt, arg...) \ do { \ if (level <= edac_debug_level) \ edac_printk(KERN_DEBUG, EDAC_DEBUG, \ "%s: " fmt, __func__, ##arg); \ |
cc18e3cd5 edac: add more ve... |
75 |
} while (0) |
7c9281d76 drivers/edac: spl... |
76 77 78 79 80 81 |
#define debugf0( ... ) edac_debug_printk(0, __VA_ARGS__ ) #define debugf1( ... ) edac_debug_printk(1, __VA_ARGS__ ) #define debugf2( ... ) edac_debug_printk(2, __VA_ARGS__ ) #define debugf3( ... ) edac_debug_printk(3, __VA_ARGS__ ) #define debugf4( ... ) edac_debug_printk(4, __VA_ARGS__ ) |
079708b91 drivers/edac: cor... |
82 |
#else /* !CONFIG_EDAC_DEBUG */ |
7c9281d76 drivers/edac: spl... |
83 84 85 86 87 88 |
#define debugf0( ... ) #define debugf1( ... ) #define debugf2( ... ) #define debugf3( ... ) #define debugf4( ... ) |
079708b91 drivers/edac: cor... |
89 |
#endif /* !CONFIG_EDAC_DEBUG */ |
7c9281d76 drivers/edac: spl... |
90 |
|
7c9281d76 drivers/edac: spl... |
91 92 |
#define PCI_VEND_DEV(vend, dev) PCI_VENDOR_ID_ ## vend, \ PCI_DEVICE_ID_ ## vend ## _ ## dev |
17aa7e034 dev_name introduc... |
93 |
#define edac_dev_name(dev) (dev)->dev_name |
7c9281d76 drivers/edac: spl... |
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 |
/* memory devices */ enum dev_type { DEV_UNKNOWN = 0, DEV_X1, DEV_X2, DEV_X4, DEV_X8, DEV_X16, DEV_X32, /* Do these parts exist? */ DEV_X64 /* Do these parts exist? */ }; #define DEV_FLAG_UNKNOWN BIT(DEV_UNKNOWN) #define DEV_FLAG_X1 BIT(DEV_X1) #define DEV_FLAG_X2 BIT(DEV_X2) #define DEV_FLAG_X4 BIT(DEV_X4) #define DEV_FLAG_X8 BIT(DEV_X8) #define DEV_FLAG_X16 BIT(DEV_X16) #define DEV_FLAG_X32 BIT(DEV_X32) #define DEV_FLAG_X64 BIT(DEV_X64) /* memory types */ enum mem_type { MEM_EMPTY = 0, /* Empty csrow */ MEM_RESERVED, /* Reserved csrow type */ MEM_UNKNOWN, /* Unknown csrow type */ MEM_FPM, /* Fast page mode */ MEM_EDO, /* Extended data out */ MEM_BEDO, /* Burst Extended data out */ MEM_SDR, /* Single data rate SDRAM */ MEM_RDR, /* Registered single data rate SDRAM */ MEM_DDR, /* Double data rate SDRAM */ MEM_RDDR, /* Registered Double data rate SDRAM */ MEM_RMBS, /* Rambus DRAM */ |
079708b91 drivers/edac: cor... |
129 130 131 |
MEM_DDR2, /* DDR2 RAM */ MEM_FB_DDR2, /* fully buffered DDR2 */ MEM_RDDR2, /* Registered DDR2 RAM */ |
1d5f726cb drivers-edac: add... |
132 |
MEM_XDR, /* Rambus XDR */ |
b1cfebc92 edac: add DDR3 me... |
133 134 |
MEM_DDR3, /* DDR3 RAM */ MEM_RDDR3, /* Registered DDR3 RAM */ |
7c9281d76 drivers/edac: spl... |
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 |
}; #define MEM_FLAG_EMPTY BIT(MEM_EMPTY) #define MEM_FLAG_RESERVED BIT(MEM_RESERVED) #define MEM_FLAG_UNKNOWN BIT(MEM_UNKNOWN) #define MEM_FLAG_FPM BIT(MEM_FPM) #define MEM_FLAG_EDO BIT(MEM_EDO) #define MEM_FLAG_BEDO BIT(MEM_BEDO) #define MEM_FLAG_SDR BIT(MEM_SDR) #define MEM_FLAG_RDR BIT(MEM_RDR) #define MEM_FLAG_DDR BIT(MEM_DDR) #define MEM_FLAG_RDDR BIT(MEM_RDDR) #define MEM_FLAG_RMBS BIT(MEM_RMBS) #define MEM_FLAG_DDR2 BIT(MEM_DDR2) #define MEM_FLAG_FB_DDR2 BIT(MEM_FB_DDR2) #define MEM_FLAG_RDDR2 BIT(MEM_RDDR2) |
1d5f726cb drivers-edac: add... |
151 |
#define MEM_FLAG_XDR BIT(MEM_XDR) |
b1cfebc92 edac: add DDR3 me... |
152 153 |
#define MEM_FLAG_DDR3 BIT(MEM_DDR3) #define MEM_FLAG_RDDR3 BIT(MEM_RDDR3) |
7c9281d76 drivers/edac: spl... |
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 |
/* chipset Error Detection and Correction capabilities and mode */ enum edac_type { EDAC_UNKNOWN = 0, /* Unknown if ECC is available */ EDAC_NONE, /* Doesnt support ECC */ EDAC_RESERVED, /* Reserved ECC type */ EDAC_PARITY, /* Detects parity errors */ EDAC_EC, /* Error Checking - no correction */ EDAC_SECDED, /* Single bit error correction, Double detection */ EDAC_S2ECD2ED, /* Chipkill x2 devices - do these exist? */ EDAC_S4ECD4ED, /* Chipkill x4 devices */ EDAC_S8ECD8ED, /* Chipkill x8 devices */ EDAC_S16ECD16ED, /* Chipkill x16 devices */ }; #define EDAC_FLAG_UNKNOWN BIT(EDAC_UNKNOWN) #define EDAC_FLAG_NONE BIT(EDAC_NONE) #define EDAC_FLAG_PARITY BIT(EDAC_PARITY) #define EDAC_FLAG_EC BIT(EDAC_EC) #define EDAC_FLAG_SECDED BIT(EDAC_SECDED) #define EDAC_FLAG_S2ECD2ED BIT(EDAC_S2ECD2ED) #define EDAC_FLAG_S4ECD4ED BIT(EDAC_S4ECD4ED) #define EDAC_FLAG_S8ECD8ED BIT(EDAC_S8ECD8ED) #define EDAC_FLAG_S16ECD16ED BIT(EDAC_S16ECD16ED) /* scrubbing capabilities */ enum scrub_type { SCRUB_UNKNOWN = 0, /* Unknown if scrubber is available */ SCRUB_NONE, /* No scrubber */ SCRUB_SW_PROG, /* SW progressive (sequential) scrubbing */ SCRUB_SW_SRC, /* Software scrub only errors */ SCRUB_SW_PROG_SRC, /* Progressive software scrub from an error */ SCRUB_SW_TUNABLE, /* Software scrub frequency is tunable */ SCRUB_HW_PROG, /* HW progressive (sequential) scrubbing */ SCRUB_HW_SRC, /* Hardware scrub only errors */ SCRUB_HW_PROG_SRC, /* Progressive hardware scrub from an error */ SCRUB_HW_TUNABLE /* Hardware scrub frequency is tunable */ }; #define SCRUB_FLAG_SW_PROG BIT(SCRUB_SW_PROG) |
522a94bd1 drivers/edac: cor... |
194 195 |
#define SCRUB_FLAG_SW_SRC BIT(SCRUB_SW_SRC) #define SCRUB_FLAG_SW_PROG_SRC BIT(SCRUB_SW_PROG_SRC) |
7c9281d76 drivers/edac: spl... |
196 197 |
#define SCRUB_FLAG_SW_TUN BIT(SCRUB_SW_SCRUB_TUNABLE) #define SCRUB_FLAG_HW_PROG BIT(SCRUB_HW_PROG) |
522a94bd1 drivers/edac: cor... |
198 199 |
#define SCRUB_FLAG_HW_SRC BIT(SCRUB_HW_SRC) #define SCRUB_FLAG_HW_PROG_SRC BIT(SCRUB_HW_PROG_SRC) |
7c9281d76 drivers/edac: spl... |
200 201 202 |
#define SCRUB_FLAG_HW_TUN BIT(SCRUB_HW_TUNABLE) /* FIXME - should have notify capabilities: NMI, LOG, PROC, etc */ |
91b99041c drivers/edac: upd... |
203 204 205 206 207 208 |
/* EDAC internal operation states */ #define OP_ALLOC 0x100 #define OP_RUNNING_POLL 0x201 #define OP_RUNNING_INTERRUPT 0x202 #define OP_RUNNING_POLL_INTR 0x203 #define OP_OFFLINE 0x300 |
7c9281d76 drivers/edac: spl... |
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 |
/* * There are several things to be aware of that aren't at all obvious: * * * SOCKETS, SOCKET SETS, BANKS, ROWS, CHIP-SELECT ROWS, CHANNELS, etc.. * * These are some of the many terms that are thrown about that don't always * mean what people think they mean (Inconceivable!). In the interest of * creating a common ground for discussion, terms and their definitions * will be established. * * Memory devices: The individual chip on a memory stick. These devices * commonly output 4 and 8 bits each. Grouping several * of these in parallel provides 64 bits which is common * for a memory stick. * * Memory Stick: A printed circuit board that agregates multiple * memory devices in parallel. This is the atomic * memory component that is purchaseable by Joe consumer * and loaded into a memory socket. * * Socket: A physical connector on the motherboard that accepts * a single memory stick. * * Channel: Set of memory devices on a memory stick that must be * grouped in parallel with one or more additional * channels from other memory sticks. This parallel * grouping of the output from multiple channels are * necessary for the smallest granularity of memory access. * Some memory controllers are capable of single channel - * which means that memory sticks can be loaded * individually. Other memory controllers are only * capable of dual channel - which means that memory * sticks must be loaded as pairs (see "socket set"). * * Chip-select row: All of the memory devices that are selected together. * for a single, minimum grain of memory access. * This selects all of the parallel memory devices across * all of the parallel channels. Common chip-select rows * for single channel are 64 bits, for dual channel 128 * bits. * * Single-Ranked stick: A Single-ranked stick has 1 chip-select row of memmory. * Motherboards commonly drive two chip-select pins to * a memory stick. A single-ranked stick, will occupy * only one of those rows. The other will be unused. * * Double-Ranked stick: A double-ranked stick has two chip-select rows which * access different sets of memory devices. The two * rows cannot be accessed concurrently. * * Double-sided stick: DEPRECATED TERM, see Double-Ranked stick. * A double-sided stick has two chip-select rows which * access different sets of memory devices. The two * rows cannot be accessed concurrently. "Double-sided" * is irrespective of the memory devices being mounted * on both sides of the memory stick. * |
411c94038 trivial: fix typo... |
267 |
* Socket set: All of the memory sticks that are required for |
7c9281d76 drivers/edac: spl... |
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 |
* a single memory access or all of the memory sticks * spanned by a chip-select row. A single socket set * has two chip-select rows and if double-sided sticks * are used these will occupy those chip-select rows. * * Bank: This term is avoided because it is unclear when * needing to distinguish between chip-select rows and * socket sets. * * Controller pages: * * Physical pages: * * Virtual pages: * * * STRUCTURE ORGANIZATION AND CHOICES * * * * PS - I enjoyed writing all that about as much as you enjoyed reading it. */ struct channel_info { int chan_idx; /* channel index */ u32 ce_count; /* Correctable Errors for this CHANNEL */ |
079708b91 drivers/edac: cor... |
294 |
char label[EDAC_MC_LABEL_LEN + 1]; /* DIMM label on motherboard */ |
7c9281d76 drivers/edac: spl... |
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 |
struct csrow_info *csrow; /* the parent */ }; struct csrow_info { unsigned long first_page; /* first page number in dimm */ unsigned long last_page; /* last page number in dimm */ unsigned long page_mask; /* used for interleaving - * 0UL for non intlv */ u32 nr_pages; /* number of pages in csrow */ u32 grain; /* granularity of reported error in bytes */ int csrow_idx; /* the chip-select row */ enum dev_type dtype; /* memory device type */ u32 ue_count; /* Uncorrectable Errors for this csrow */ u32 ce_count; /* Correctable Errors for this csrow */ enum mem_type mtype; /* memory csrow type */ enum edac_type edac_mode; /* EDAC mode for this csrow */ struct mem_ctl_info *mci; /* the parent */ struct kobject kobj; /* sysfs kobject for this csrow */ |
7c9281d76 drivers/edac: spl... |
315 |
|
8096cfafb drivers/edac: fix... |
316 |
/* channel information for this csrow */ |
7c9281d76 drivers/edac: spl... |
317 318 319 |
u32 nr_channels; struct channel_info *channels; }; |
9fa2fc2e2 edac_core: Allow ... |
320 |
struct mcidev_sysfs_group { |
b968759ee edac: Create an u... |
321 322 323 324 325 326 327 328 |
const char *name; /* group name */ struct mcidev_sysfs_attribute *mcidev_attr; /* group attributes */ }; struct mcidev_sysfs_group_kobj { struct list_head list; /* list for all instances within a mc */ struct kobject kobj; /* kobj for the group */ |
cc301b3ae edac: store/show ... |
329 |
|
b968759ee edac: Create an u... |
330 |
struct mcidev_sysfs_group *grp; /* group description table */ |
cc301b3ae edac: store/show ... |
331 |
struct mem_ctl_info *mci; /* the parent */ |
9fa2fc2e2 edac_core: Allow ... |
332 |
}; |
42a8e397a drivers/edac: add... |
333 334 335 336 337 |
/* mcidev_sysfs_attribute structure * used for driver sysfs attributes and in mem_ctl_info * sysfs top level entries */ struct mcidev_sysfs_attribute { |
b968759ee edac: Create an u... |
338 |
/* It should use either attr or grp */ |
9fa2fc2e2 edac_core: Allow ... |
339 |
struct attribute attr; |
b968759ee edac: Create an u... |
340 |
struct mcidev_sysfs_group *grp; /* Points to a group of attributes */ |
9fa2fc2e2 edac_core: Allow ... |
341 |
|
b968759ee edac: Create an u... |
342 |
/* Ops for show/store values at the attribute - not used on group */ |
42a8e397a drivers/edac: add... |
343 344 345 346 347 348 |
ssize_t (*show)(struct mem_ctl_info *,char *); ssize_t (*store)(struct mem_ctl_info *, const char *,size_t); }; /* MEMORY controller information structure */ |
7c9281d76 drivers/edac: spl... |
349 |
struct mem_ctl_info { |
079708b91 drivers/edac: cor... |
350 |
struct list_head link; /* for global list of mem_ctl_info structs */ |
1c3631ff1 drivers/edac: fix... |
351 352 |
struct module *owner; /* Module owner of this control struct */ |
7c9281d76 drivers/edac: spl... |
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 |
unsigned long mtype_cap; /* memory types supported by mc */ unsigned long edac_ctl_cap; /* Mem controller EDAC capabilities */ unsigned long edac_cap; /* configuration capabilities - this is * closely related to edac_ctl_cap. The * difference is that the controller may be * capable of s4ecd4ed which would be listed * in edac_ctl_cap, but if channels aren't * capable of s4ecd4ed then the edac_cap would * not have that capability. */ unsigned long scrub_cap; /* chipset scrub capabilities */ enum scrub_type scrub_mode; /* current scrub mode */ /* Translates sdram memory scrub rate given in bytes/sec to the internal representation and configures whatever else needs to be configured. |
079708b91 drivers/edac: cor... |
369 |
*/ |
eba042a81 edac, mc: Improve... |
370 |
int (*set_sdram_scrub_rate) (struct mem_ctl_info * mci, u32 bw); |
7c9281d76 drivers/edac: spl... |
371 372 373 374 |
/* Get the current sdram memory scrub rate from the internal representation and converts it to the closest matching bandwith in bytes/sec. |
079708b91 drivers/edac: cor... |
375 376 |
*/ int (*get_sdram_scrub_rate) (struct mem_ctl_info * mci, u32 * bw); |
7c9281d76 drivers/edac: spl... |
377 |
|
42a8e397a drivers/edac: add... |
378 |
|
7c9281d76 drivers/edac: spl... |
379 380 381 382 383 384 385 386 387 |
/* pointer to edac checking routine */ void (*edac_check) (struct mem_ctl_info * mci); /* * Remaps memory pages: controller pages to physical pages. * For most MC's, this will be NULL. */ /* FIXME - why not send the phys page to begin with? */ unsigned long (*ctl_page_to_phys) (struct mem_ctl_info * mci, |
079708b91 drivers/edac: cor... |
388 |
unsigned long page); |
7c9281d76 drivers/edac: spl... |
389 390 391 392 393 394 395 396 397 398 399 400 |
int mc_idx; int nr_csrows; struct csrow_info *csrows; /* * FIXME - what about controllers on other busses? - IDs must be * unique. dev pointer should be sufficiently unique, but * BUS:SLOT.FUNC numbers may not be unique. */ struct device *dev; const char *mod_name; const char *mod_ver; const char *ctl_name; |
c4192705f drivers/edac: add... |
401 |
const char *dev_name; |
7c9281d76 drivers/edac: spl... |
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
char proc_name[MC_PROC_NAME_MAX_LEN + 1]; void *pvt_info; u32 ue_noinfo_count; /* Uncorrectable Errors w/o info */ u32 ce_noinfo_count; /* Correctable Errors w/o info */ u32 ue_count; /* Total Uncorrectable Errors for this MC */ u32 ce_count; /* Total Correctable Errors for this MC */ unsigned long start_time; /* mci load start time (in jiffies) */ /* this stuff is for safe removal of mc devices from global list while * NMI handlers may be traversing list */ struct rcu_head rcu; struct completion complete; /* edac sysfs device control */ struct kobject edac_mci_kobj; |
81d87cb13 drivers/edac: mod... |
418 |
|
b968759ee edac: Create an u... |
419 420 |
/* list for all grp instances within a mc */ struct list_head grp_kobj_list; |
42a8e397a drivers/edac: add... |
421 422 423 424 425 426 427 428 429 430 431 |
/* Additional top controller level attributes, but specified * by the low level driver. * * Set by the low level driver to provide attributes at the * controller level, same level as 'ue_count' and 'ce_count' above. * An array of structures, NULL terminated * * If attributes are desired, then set to array of attributes * If no attributes are desired, leave NULL */ struct mcidev_sysfs_attribute *mc_driver_sysfs_attributes; |
81d87cb13 drivers/edac: mod... |
432 |
/* work struct for this MC */ |
81d87cb13 drivers/edac: mod... |
433 |
struct delayed_work work; |
86aa8cb7b drivers/edac: cle... |
434 |
|
81d87cb13 drivers/edac: mod... |
435 436 |
/* the internal state of this controller instance */ int op_state; |
7c9281d76 drivers/edac: spl... |
437 |
}; |
e27e3dac6 drivers/edac: add... |
438 |
/* |
42a8e397a drivers/edac: add... |
439 |
* The following are the structures to provide for a generic |
e27e3dac6 drivers/edac: add... |
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 |
* or abstract 'edac_device'. This set of structures and the * code that implements the APIs for the same, provide for * registering EDAC type devices which are NOT standard memory. * * CPU caches (L1 and L2) * DMA engines * Core CPU swithces * Fabric switch units * PCIe interface controllers * other EDAC/ECC type devices that can be monitored for * errors, etc. * * It allows for a 2 level set of hiearchry. For example: * * cache could be composed of L1, L2 and L3 levels of cache. * Each CPU core would have its own L1 cache, while sharing * L2 and maybe L3 caches. * * View them arranged, via the sysfs presentation: * /sys/devices/system/edac/.. * * mc/ <existing memory device directory> * cpu/cpu0/.. <L1 and L2 block directory> * /L1-cache/ce_count * /ue_count * /L2-cache/ce_count * /ue_count * cpu/cpu1/.. <L1 and L2 block directory> * /L1-cache/ce_count * /ue_count * /L2-cache/ce_count * /ue_count * ... * * the L1 and L2 directories would be "edac_device_block's" */ struct edac_device_counter { |
079708b91 drivers/edac: cor... |
478 479 |
u32 ue_count; u32 ce_count; |
e27e3dac6 drivers/edac: add... |
480 |
}; |
fd309a9d8 drivers/edac: fix... |
481 482 483 |
/* forward reference */ struct edac_device_ctl_info; struct edac_device_block; |
e27e3dac6 drivers/edac: add... |
484 |
|
fd309a9d8 drivers/edac: fix... |
485 486 487 488 489 490 491 492 493 |
/* edac_dev_sysfs_attribute structure * used for driver sysfs attributes in mem_ctl_info * for extra controls and attributes: * like high level error Injection controls */ struct edac_dev_sysfs_attribute { struct attribute attr; ssize_t (*show)(struct edac_device_ctl_info *, char *); ssize_t (*store)(struct edac_device_ctl_info *, const char *, size_t); |
e27e3dac6 drivers/edac: add... |
494 |
}; |
fd309a9d8 drivers/edac: fix... |
495 |
/* edac_dev_sysfs_block_attribute structure |
b2a4ac0c2 drivers/edac: fix... |
496 |
* |
fd309a9d8 drivers/edac: fix... |
497 |
* used in leaf 'block' nodes for adding controls/attributes |
b2a4ac0c2 drivers/edac: fix... |
498 499 500 501 502 503 504 505 |
* * each block in each instance of the containing control structure * can have an array of the following. The show and store functions * will be filled in with the show/store function in the * low level driver. * * The 'value' field will be the actual value field used for * counting |
e27e3dac6 drivers/edac: add... |
506 |
*/ |
fd309a9d8 drivers/edac: fix... |
507 508 509 510 511 512 |
struct edac_dev_sysfs_block_attribute { struct attribute attr; ssize_t (*show)(struct kobject *, struct attribute *, char *); ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); struct edac_device_block *block; |
fd309a9d8 drivers/edac: fix... |
513 |
unsigned int value; |
e27e3dac6 drivers/edac: add... |
514 515 516 517 518 |
}; /* device block control structure */ struct edac_device_block { struct edac_device_instance *instance; /* Up Pointer */ |
079708b91 drivers/edac: cor... |
519 |
char name[EDAC_DEVICE_NAME_LEN + 1]; |
e27e3dac6 drivers/edac: add... |
520 521 |
struct edac_device_counter counters; /* basic UE and CE counters */ |
079708b91 drivers/edac: cor... |
522 |
int nr_attribs; /* how many attributes */ |
fd309a9d8 drivers/edac: fix... |
523 524 525 |
/* this block's attributes, could be NULL */ struct edac_dev_sysfs_block_attribute *block_attributes; |
e27e3dac6 drivers/edac: add... |
526 527 528 |
/* edac sysfs device control */ struct kobject kobj; |
e27e3dac6 drivers/edac: add... |
529 530 531 532 533 534 535 536 |
}; /* device instance control structure */ struct edac_device_instance { struct edac_device_ctl_info *ctl; /* Up pointer */ char name[EDAC_DEVICE_NAME_LEN + 4]; struct edac_device_counter counters; /* instance counters */ |
079708b91 drivers/edac: cor... |
537 |
u32 nr_blocks; /* how many blocks */ |
e27e3dac6 drivers/edac: add... |
538 539 540 541 |
struct edac_device_block *blocks; /* block array */ /* edac sysfs device control */ struct kobject kobj; |
e27e3dac6 drivers/edac: add... |
542 |
}; |
42a8e397a drivers/edac: add... |
543 |
|
e27e3dac6 drivers/edac: add... |
544 545 546 547 548 549 550 |
/* * Abstract edac_device control info structure * */ struct edac_device_ctl_info { /* for global list of edac_device_ctl_info structs */ struct list_head link; |
1c3631ff1 drivers/edac: fix... |
551 |
struct module *owner; /* Module owner of this control struct */ |
e27e3dac6 drivers/edac: add... |
552 553 554 555 556 557 558 559 |
int dev_idx; /* Per instance controls for this edac_device */ int log_ue; /* boolean for logging UEs */ int log_ce; /* boolean for logging CEs */ int panic_on_ue; /* boolean for panic'ing on an UE */ unsigned poll_msec; /* number of milliseconds to poll interval */ unsigned long delay; /* number of jiffies for poll_msec */ |
42a8e397a drivers/edac: add... |
560 561 562 563 564 565 566 567 568 569 570 571 572 573 |
/* Additional top controller level attributes, but specified * by the low level driver. * * Set by the low level driver to provide attributes at the * controller level, same level as 'ue_count' and 'ce_count' above. * An array of structures, NULL terminated * * If attributes are desired, then set to array of attributes * If no attributes are desired, leave NULL */ struct edac_dev_sysfs_attribute *sysfs_attributes; /* pointer to main 'edac' class in sysfs */ struct sysdev_class *edac_class; |
e27e3dac6 drivers/edac: add... |
574 575 576 |
/* the internal state of this controller instance */ int op_state; |
e27e3dac6 drivers/edac: add... |
577 |
/* work struct for this instance */ |
e27e3dac6 drivers/edac: add... |
578 |
struct delayed_work work; |
e27e3dac6 drivers/edac: add... |
579 580 |
/* pointer to edac polling checking routine: |
079708b91 drivers/edac: cor... |
581 582 583 |
* If NOT NULL: points to polling check routine * If NULL: Then assumes INTERRUPT operation, where * MC driver will receive events |
e27e3dac6 drivers/edac: add... |
584 585 586 587 588 589 590 |
*/ void (*edac_check) (struct edac_device_ctl_info * edac_dev); struct device *dev; /* pointer to device structure */ const char *mod_name; /* module name */ const char *ctl_name; /* edac controller name */ |
c4192705f drivers/edac: add... |
591 |
const char *dev_name; /* pci/platform/etc... name */ |
e27e3dac6 drivers/edac: add... |
592 593 |
void *pvt_info; /* pointer to 'private driver' info */ |
079708b91 drivers/edac: cor... |
594 |
unsigned long start_time; /* edac_device load start time (jiffies) */ |
e27e3dac6 drivers/edac: add... |
595 596 597 598 599 |
/* these are for safe removal of mc devices from global list while * NMI handlers may be traversing list */ struct rcu_head rcu; |
1c3631ff1 drivers/edac: fix... |
600 |
struct completion removal_complete; |
e27e3dac6 drivers/edac: add... |
601 602 603 |
/* sysfs top name under 'edac' directory * and instance name: |
079708b91 drivers/edac: cor... |
604 605 606 607 |
* cpu/cpu0/... * cpu/cpu1/... * cpu/cpu2/... * ... |
e27e3dac6 drivers/edac: add... |
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 |
*/ char name[EDAC_DEVICE_NAME_LEN + 1]; /* Number of instances supported on this control structure * and the array of those instances */ u32 nr_instances; struct edac_device_instance *instances; /* Event counters for the this whole EDAC Device */ struct edac_device_counter counters; /* edac sysfs device control for the 'name' * device this structure controls */ struct kobject kobj; |
e27e3dac6 drivers/edac: add... |
624 625 626 |
}; /* To get from the instance's wq to the beginning of the ctl structure */ |
81d87cb13 drivers/edac: mod... |
627 628 |
#define to_edac_mem_ctl_work(w) \ container_of(w, struct mem_ctl_info, work) |
e27e3dac6 drivers/edac: add... |
629 630 |
#define to_edac_device_ctl_work(w) \ container_of(w,struct edac_device_ctl_info,work) |
e27e3dac6 drivers/edac: add... |
631 632 633 634 635 636 |
/* * The alloc() and free() functions for the 'edac_device' control info * structure. A MC driver will allocate one of these for each edac_device * it is going to control/register with the EDAC CORE. */ extern struct edac_device_ctl_info *edac_device_alloc_ctl_info( |
079708b91 drivers/edac: cor... |
637 |
unsigned sizeof_private, |
fd309a9d8 drivers/edac: fix... |
638 639 |
char *edac_device_name, unsigned nr_instances, char *edac_block_name, unsigned nr_blocks, |
079708b91 drivers/edac: cor... |
640 |
unsigned offset_value, |
fd309a9d8 drivers/edac: fix... |
641 |
struct edac_dev_sysfs_block_attribute *block_attributes, |
d45e7823b drivers/edac: fix... |
642 643 |
unsigned nr_attribs, int device_index); |
e27e3dac6 drivers/edac: add... |
644 645 646 647 648 649 650 651 |
/* The offset value can be: * -1 indicating no offset value * 0 for zero-based block numbers * 1 for 1-based block number * other for other-based block number */ #define BLOCK_OFFSET_VALUE_OFF ((unsigned) -1) |
079708b91 drivers/edac: cor... |
652 |
extern void edac_device_free_ctl_info(struct edac_device_ctl_info *ctl_info); |
e27e3dac6 drivers/edac: add... |
653 |
|
7c9281d76 drivers/edac: spl... |
654 |
#ifdef CONFIG_PCI |
91b99041c drivers/edac: upd... |
655 |
struct edac_pci_counter { |
079708b91 drivers/edac: cor... |
656 657 |
atomic_t pe_count; atomic_t npe_count; |
91b99041c drivers/edac: upd... |
658 659 660 661 662 663 664 665 666 667 668 |
}; /* * Abstract edac_pci control info structure * */ struct edac_pci_ctl_info { /* for global list of edac_pci_ctl_info structs */ struct list_head link; int pci_idx; |
91b99041c drivers/edac: upd... |
669 670 671 672 673 |
struct sysdev_class *edac_class; /* pointer to class */ /* the internal state of this controller instance */ int op_state; /* work struct for this instance */ |
91b99041c drivers/edac: upd... |
674 |
struct delayed_work work; |
91b99041c drivers/edac: upd... |
675 676 |
/* pointer to edac polling checking routine: |
079708b91 drivers/edac: cor... |
677 678 679 |
* If NOT NULL: points to polling check routine * If NULL: Then assumes INTERRUPT operation, where * MC driver will receive events |
91b99041c drivers/edac: upd... |
680 681 682 683 684 685 686 687 688 689 |
*/ void (*edac_check) (struct edac_pci_ctl_info * edac_dev); struct device *dev; /* pointer to device structure */ const char *mod_name; /* module name */ const char *ctl_name; /* edac controller name */ const char *dev_name; /* pci/platform/etc... name */ void *pvt_info; /* pointer to 'private driver' info */ |
079708b91 drivers/edac: cor... |
690 |
unsigned long start_time; /* edac_pci load start time (jiffies) */ |
91b99041c drivers/edac: upd... |
691 692 693 694 695 696 697 698 699 |
/* these are for safe removal of devices from global list while * NMI handlers may be traversing list */ struct rcu_head rcu; struct completion complete; /* sysfs top name under 'edac' directory * and instance name: |
079708b91 drivers/edac: cor... |
700 701 702 703 |
* cpu/cpu0/... * cpu/cpu1/... * cpu/cpu2/... * ... |
91b99041c drivers/edac: upd... |
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 |
*/ char name[EDAC_DEVICE_NAME_LEN + 1]; /* Event counters for the this whole EDAC Device */ struct edac_pci_counter counters; /* edac sysfs device control for the 'name' * device this structure controls */ struct kobject kobj; struct completion kobj_complete; }; #define to_edac_pci_ctl_work(w) \ container_of(w, struct edac_pci_ctl_info,work) |
7c9281d76 drivers/edac: spl... |
719 720 |
/* write all or some bits in a byte-register*/ static inline void pci_write_bits8(struct pci_dev *pdev, int offset, u8 value, |
079708b91 drivers/edac: cor... |
721 |
u8 mask) |
7c9281d76 drivers/edac: spl... |
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 |
{ if (mask != 0xff) { u8 buf; pci_read_config_byte(pdev, offset, &buf); value &= mask; buf &= ~mask; value |= buf; } pci_write_config_byte(pdev, offset, value); } /* write all or some bits in a word-register*/ static inline void pci_write_bits16(struct pci_dev *pdev, int offset, |
079708b91 drivers/edac: cor... |
737 |
u16 value, u16 mask) |
7c9281d76 drivers/edac: spl... |
738 739 740 741 742 743 744 745 746 747 748 749 |
{ if (mask != 0xffff) { u16 buf; pci_read_config_word(pdev, offset, &buf); value &= mask; buf &= ~mask; value |= buf; } pci_write_config_word(pdev, offset, value); } |
e6da46b27 edac: fix local p... |
750 751 752 753 754 755 756 757 758 |
/* * pci_write_bits32 * * edac local routine to do pci_write_config_dword, but adds * a mask parameter. If mask is all ones, ignore the mask. * Otherwise utilize the mask to isolate specified bits * * write all or some bits in a dword-register */ |
7c9281d76 drivers/edac: spl... |
759 |
static inline void pci_write_bits32(struct pci_dev *pdev, int offset, |
079708b91 drivers/edac: cor... |
760 |
u32 value, u32 mask) |
7c9281d76 drivers/edac: spl... |
761 |
{ |
e6da46b27 edac: fix local p... |
762 |
if (mask != 0xffffffff) { |
7c9281d76 drivers/edac: spl... |
763 764 765 766 767 768 769 770 771 772 |
u32 buf; pci_read_config_dword(pdev, offset, &buf); value &= mask; buf &= ~mask; value |= buf; } pci_write_config_dword(pdev, offset, value); } |
079708b91 drivers/edac: cor... |
773 |
#endif /* CONFIG_PCI */ |
7c9281d76 drivers/edac: spl... |
774 |
|
b8f6f9755 drivers/edac: fix... |
775 776 777 778 |
extern struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows, unsigned nr_chans, int edac_index); extern int edac_mc_add_mc(struct mem_ctl_info *mci); extern void edac_mc_free(struct mem_ctl_info *mci); |
079708b91 drivers/edac: cor... |
779 |
extern struct mem_ctl_info *edac_mc_find(int idx); |
079708b91 drivers/edac: cor... |
780 |
extern struct mem_ctl_info *edac_mc_del_mc(struct device *dev); |
7c9281d76 drivers/edac: spl... |
781 |
extern int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, |
079708b91 drivers/edac: cor... |
782 |
unsigned long page); |
7c9281d76 drivers/edac: spl... |
783 784 785 786 787 788 789 790 791 792 793 794 |
/* * The no info errors are used when error overflows are reported. * There are a limited number of error logging registers that can * be exausted. When all registers are exhausted and an additional * error occurs then an error overflow register records that an * error occured and the type of error, but doesn't have any * further information. The ce/ue versions make for cleaner * reporting logic and function interface - reduces conditional * statement clutter and extra function arguments. */ extern void edac_mc_handle_ce(struct mem_ctl_info *mci, |
079708b91 drivers/edac: cor... |
795 796 797 798 |
unsigned long page_frame_number, unsigned long offset_in_page, unsigned long syndrome, int row, int channel, const char *msg); |
7c9281d76 drivers/edac: spl... |
799 |
extern void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, |
079708b91 drivers/edac: cor... |
800 |
const char *msg); |
7c9281d76 drivers/edac: spl... |
801 |
extern void edac_mc_handle_ue(struct mem_ctl_info *mci, |
079708b91 drivers/edac: cor... |
802 803 804 |
unsigned long page_frame_number, unsigned long offset_in_page, int row, const char *msg); |
7c9281d76 drivers/edac: spl... |
805 |
extern void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, |
079708b91 drivers/edac: cor... |
806 807 808 809 810 811 |
const char *msg); extern void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci, unsigned int csrow, unsigned int channel0, unsigned int channel1, char *msg); extern void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci, unsigned int csrow, unsigned int channel, char *msg); |
7c9281d76 drivers/edac: spl... |
812 813 |
/* |
e27e3dac6 drivers/edac: add... |
814 |
* edac_device APIs |
7c9281d76 drivers/edac: spl... |
815 |
*/ |
d45e7823b drivers/edac: fix... |
816 |
extern int edac_device_add_device(struct edac_device_ctl_info *edac_dev); |
079708b91 drivers/edac: cor... |
817 |
extern struct edac_device_ctl_info *edac_device_del_device(struct device *dev); |
e27e3dac6 drivers/edac: add... |
818 |
extern void edac_device_handle_ue(struct edac_device_ctl_info *edac_dev, |
b8f6f9755 drivers/edac: fix... |
819 |
int inst_nr, int block_nr, const char *msg); |
e27e3dac6 drivers/edac: add... |
820 |
extern void edac_device_handle_ce(struct edac_device_ctl_info *edac_dev, |
b8f6f9755 drivers/edac: fix... |
821 |
int inst_nr, int block_nr, const char *msg); |
1dc9b70d7 edac: add edac_de... |
822 |
extern int edac_device_alloc_index(void); |
e27e3dac6 drivers/edac: add... |
823 |
|
91b99041c drivers/edac: upd... |
824 825 826 |
/* * edac_pci APIs */ |
b8f6f9755 drivers/edac: fix... |
827 828 |
extern struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt, const char *edac_pci_name); |
91b99041c drivers/edac: upd... |
829 830 |
extern void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci); |
b8f6f9755 drivers/edac: fix... |
831 832 |
extern void edac_pci_reset_delay_period(struct edac_pci_ctl_info *pci, unsigned long value); |
91b99041c drivers/edac: upd... |
833 |
|
8641a3845 edac: Add edac_pc... |
834 |
extern int edac_pci_alloc_index(void); |
91b99041c drivers/edac: upd... |
835 |
extern int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx); |
079708b91 drivers/edac: cor... |
836 |
extern struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev); |
91b99041c drivers/edac: upd... |
837 |
|
b8f6f9755 drivers/edac: fix... |
838 839 840 |
extern struct edac_pci_ctl_info *edac_pci_create_generic_ctl( struct device *dev, const char *mod_name); |
91b99041c drivers/edac: upd... |
841 842 843 844 845 846 847 848 |
extern void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci); extern int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci); extern void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci); /* * edac misc APIs */ |
494d0d55b drivers/edac: mod... |
849 |
extern char *edac_op_state_to_string(int op_state); |
7c9281d76 drivers/edac: spl... |
850 851 |
#endif /* _EDAC_CORE_H_ */ |