i5000_edac.c 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585
  1. /*
  2. * Intel 5000(P/V/X) class Memory Controllers kernel module
  3. *
  4. * This file may be distributed under the terms of the
  5. * GNU General Public License.
  6. *
  7. * Written by Douglas Thompson Linux Networx (http://lnxi.com)
  8. * [email protected]
  9. *
  10. * This module is based on the following document:
  11. *
  12. * Intel 5000X Chipset Memory Controller Hub (MCH) - Datasheet
  13. * http://developer.intel.com/design/chipsets/datashts/313070.htm
  14. *
  15. */
  16. #include <linux/module.h>
  17. #include <linux/init.h>
  18. #include <linux/pci.h>
  19. #include <linux/pci_ids.h>
  20. #include <linux/slab.h>
  21. #include <linux/edac.h>
  22. #include <asm/mmzone.h>
  23. #include "edac_module.h"
  24. /*
  25. * Alter this version for the I5000 module when modifications are made
  26. */
  27. #define I5000_REVISION " Ver: 2.0.12"
  28. #define EDAC_MOD_STR "i5000_edac"
  29. #define i5000_printk(level, fmt, arg...) \
  30. edac_printk(level, "i5000", fmt, ##arg)
  31. #define i5000_mc_printk(mci, level, fmt, arg...) \
  32. edac_mc_chipset_printk(mci, level, "i5000", fmt, ##arg)
  33. #ifndef PCI_DEVICE_ID_INTEL_FBD_0
  34. #define PCI_DEVICE_ID_INTEL_FBD_0 0x25F5
  35. #endif
  36. #ifndef PCI_DEVICE_ID_INTEL_FBD_1
  37. #define PCI_DEVICE_ID_INTEL_FBD_1 0x25F6
  38. #endif
  39. /* Device 16,
  40. * Function 0: System Address
  41. * Function 1: Memory Branch Map, Control, Errors Register
  42. * Function 2: FSB Error Registers
  43. *
  44. * All 3 functions of Device 16 (0,1,2) share the SAME DID
  45. */
  46. #define PCI_DEVICE_ID_INTEL_I5000_DEV16 0x25F0
  47. /* OFFSETS for Function 0 */
  48. /* OFFSETS for Function 1 */
  49. #define AMBASE 0x48
  50. #define MAXCH 0x56
  51. #define MAXDIMMPERCH 0x57
  52. #define TOLM 0x6C
  53. #define REDMEMB 0x7C
  54. #define RED_ECC_LOCATOR(x) ((x) & 0x3FFFF)
  55. #define REC_ECC_LOCATOR_EVEN(x) ((x) & 0x001FF)
  56. #define REC_ECC_LOCATOR_ODD(x) ((x) & 0x3FE00)
  57. #define MIR0 0x80
  58. #define MIR1 0x84
  59. #define MIR2 0x88
  60. #define AMIR0 0x8C
  61. #define AMIR1 0x90
  62. #define AMIR2 0x94
  63. #define FERR_FAT_FBD 0x98
  64. #define NERR_FAT_FBD 0x9C
  65. #define EXTRACT_FBDCHAN_INDX(x) (((x)>>28) & 0x3)
  66. #define FERR_FAT_FBDCHAN 0x30000000
  67. #define FERR_FAT_M3ERR 0x00000004
  68. #define FERR_FAT_M2ERR 0x00000002
  69. #define FERR_FAT_M1ERR 0x00000001
  70. #define FERR_FAT_MASK (FERR_FAT_M1ERR | \
  71. FERR_FAT_M2ERR | \
  72. FERR_FAT_M3ERR)
  73. #define FERR_NF_FBD 0xA0
  74. /* Thermal and SPD or BFD errors */
  75. #define FERR_NF_M28ERR 0x01000000
  76. #define FERR_NF_M27ERR 0x00800000
  77. #define FERR_NF_M26ERR 0x00400000
  78. #define FERR_NF_M25ERR 0x00200000
  79. #define FERR_NF_M24ERR 0x00100000
  80. #define FERR_NF_M23ERR 0x00080000
  81. #define FERR_NF_M22ERR 0x00040000
  82. #define FERR_NF_M21ERR 0x00020000
  83. /* Correctable errors */
  84. #define FERR_NF_M20ERR 0x00010000
  85. #define FERR_NF_M19ERR 0x00008000
  86. #define FERR_NF_M18ERR 0x00004000
  87. #define FERR_NF_M17ERR 0x00002000
  88. /* Non-Retry or redundant Retry errors */
  89. #define FERR_NF_M16ERR 0x00001000
  90. #define FERR_NF_M15ERR 0x00000800
  91. #define FERR_NF_M14ERR 0x00000400
  92. #define FERR_NF_M13ERR 0x00000200
  93. /* Uncorrectable errors */
  94. #define FERR_NF_M12ERR 0x00000100
  95. #define FERR_NF_M11ERR 0x00000080
  96. #define FERR_NF_M10ERR 0x00000040
  97. #define FERR_NF_M9ERR 0x00000020
  98. #define FERR_NF_M8ERR 0x00000010
  99. #define FERR_NF_M7ERR 0x00000008
  100. #define FERR_NF_M6ERR 0x00000004
  101. #define FERR_NF_M5ERR 0x00000002
  102. #define FERR_NF_M4ERR 0x00000001
  103. #define FERR_NF_UNCORRECTABLE (FERR_NF_M12ERR | \
  104. FERR_NF_M11ERR | \
  105. FERR_NF_M10ERR | \
  106. FERR_NF_M9ERR | \
  107. FERR_NF_M8ERR | \
  108. FERR_NF_M7ERR | \
  109. FERR_NF_M6ERR | \
  110. FERR_NF_M5ERR | \
  111. FERR_NF_M4ERR)
  112. #define FERR_NF_CORRECTABLE (FERR_NF_M20ERR | \
  113. FERR_NF_M19ERR | \
  114. FERR_NF_M18ERR | \
  115. FERR_NF_M17ERR)
  116. #define FERR_NF_DIMM_SPARE (FERR_NF_M27ERR | \
  117. FERR_NF_M28ERR)
  118. #define FERR_NF_THERMAL (FERR_NF_M26ERR | \
  119. FERR_NF_M25ERR | \
  120. FERR_NF_M24ERR | \
  121. FERR_NF_M23ERR)
  122. #define FERR_NF_SPD_PROTOCOL (FERR_NF_M22ERR)
  123. #define FERR_NF_NORTH_CRC (FERR_NF_M21ERR)
  124. #define FERR_NF_NON_RETRY (FERR_NF_M13ERR | \
  125. FERR_NF_M14ERR | \
  126. FERR_NF_M15ERR)
  127. #define NERR_NF_FBD 0xA4
  128. #define FERR_NF_MASK (FERR_NF_UNCORRECTABLE | \
  129. FERR_NF_CORRECTABLE | \
  130. FERR_NF_DIMM_SPARE | \
  131. FERR_NF_THERMAL | \
  132. FERR_NF_SPD_PROTOCOL | \
  133. FERR_NF_NORTH_CRC | \
  134. FERR_NF_NON_RETRY)
  135. #define EMASK_FBD 0xA8
  136. #define EMASK_FBD_M28ERR 0x08000000
  137. #define EMASK_FBD_M27ERR 0x04000000
  138. #define EMASK_FBD_M26ERR 0x02000000
  139. #define EMASK_FBD_M25ERR 0x01000000
  140. #define EMASK_FBD_M24ERR 0x00800000
  141. #define EMASK_FBD_M23ERR 0x00400000
  142. #define EMASK_FBD_M22ERR 0x00200000
  143. #define EMASK_FBD_M21ERR 0x00100000
  144. #define EMASK_FBD_M20ERR 0x00080000
  145. #define EMASK_FBD_M19ERR 0x00040000
  146. #define EMASK_FBD_M18ERR 0x00020000
  147. #define EMASK_FBD_M17ERR 0x00010000
  148. #define EMASK_FBD_M15ERR 0x00004000
  149. #define EMASK_FBD_M14ERR 0x00002000
  150. #define EMASK_FBD_M13ERR 0x00001000
  151. #define EMASK_FBD_M12ERR 0x00000800
  152. #define EMASK_FBD_M11ERR 0x00000400
  153. #define EMASK_FBD_M10ERR 0x00000200
  154. #define EMASK_FBD_M9ERR 0x00000100
  155. #define EMASK_FBD_M8ERR 0x00000080
  156. #define EMASK_FBD_M7ERR 0x00000040
  157. #define EMASK_FBD_M6ERR 0x00000020
  158. #define EMASK_FBD_M5ERR 0x00000010
  159. #define EMASK_FBD_M4ERR 0x00000008
  160. #define EMASK_FBD_M3ERR 0x00000004
  161. #define EMASK_FBD_M2ERR 0x00000002
  162. #define EMASK_FBD_M1ERR 0x00000001
  163. #define ENABLE_EMASK_FBD_FATAL_ERRORS (EMASK_FBD_M1ERR | \
  164. EMASK_FBD_M2ERR | \
  165. EMASK_FBD_M3ERR)
  166. #define ENABLE_EMASK_FBD_UNCORRECTABLE (EMASK_FBD_M4ERR | \
  167. EMASK_FBD_M5ERR | \
  168. EMASK_FBD_M6ERR | \
  169. EMASK_FBD_M7ERR | \
  170. EMASK_FBD_M8ERR | \
  171. EMASK_FBD_M9ERR | \
  172. EMASK_FBD_M10ERR | \
  173. EMASK_FBD_M11ERR | \
  174. EMASK_FBD_M12ERR)
  175. #define ENABLE_EMASK_FBD_CORRECTABLE (EMASK_FBD_M17ERR | \
  176. EMASK_FBD_M18ERR | \
  177. EMASK_FBD_M19ERR | \
  178. EMASK_FBD_M20ERR)
  179. #define ENABLE_EMASK_FBD_DIMM_SPARE (EMASK_FBD_M27ERR | \
  180. EMASK_FBD_M28ERR)
  181. #define ENABLE_EMASK_FBD_THERMALS (EMASK_FBD_M26ERR | \
  182. EMASK_FBD_M25ERR | \
  183. EMASK_FBD_M24ERR | \
  184. EMASK_FBD_M23ERR)
  185. #define ENABLE_EMASK_FBD_SPD_PROTOCOL (EMASK_FBD_M22ERR)
  186. #define ENABLE_EMASK_FBD_NORTH_CRC (EMASK_FBD_M21ERR)
  187. #define ENABLE_EMASK_FBD_NON_RETRY (EMASK_FBD_M15ERR | \
  188. EMASK_FBD_M14ERR | \
  189. EMASK_FBD_M13ERR)
  190. #define ENABLE_EMASK_ALL (ENABLE_EMASK_FBD_NON_RETRY | \
  191. ENABLE_EMASK_FBD_NORTH_CRC | \
  192. ENABLE_EMASK_FBD_SPD_PROTOCOL | \
  193. ENABLE_EMASK_FBD_THERMALS | \
  194. ENABLE_EMASK_FBD_DIMM_SPARE | \
  195. ENABLE_EMASK_FBD_FATAL_ERRORS | \
  196. ENABLE_EMASK_FBD_CORRECTABLE | \
  197. ENABLE_EMASK_FBD_UNCORRECTABLE)
  198. #define ERR0_FBD 0xAC
  199. #define ERR1_FBD 0xB0
  200. #define ERR2_FBD 0xB4
  201. #define MCERR_FBD 0xB8
  202. #define NRECMEMA 0xBE
  203. #define NREC_BANK(x) (((x)>>12) & 0x7)
  204. #define NREC_RDWR(x) (((x)>>11) & 1)
  205. #define NREC_RANK(x) (((x)>>8) & 0x7)
  206. #define NRECMEMB 0xC0
  207. #define NREC_CAS(x) (((x)>>16) & 0xFFF)
  208. #define NREC_RAS(x) ((x) & 0x7FFF)
  209. #define NRECFGLOG 0xC4
  210. #define NREEECFBDA 0xC8
  211. #define NREEECFBDB 0xCC
  212. #define NREEECFBDC 0xD0
  213. #define NREEECFBDD 0xD4
  214. #define NREEECFBDE 0xD8
  215. #define REDMEMA 0xDC
  216. #define RECMEMA 0xE2
  217. #define REC_BANK(x) (((x)>>12) & 0x7)
  218. #define REC_RDWR(x) (((x)>>11) & 1)
  219. #define REC_RANK(x) (((x)>>8) & 0x7)
  220. #define RECMEMB 0xE4
  221. #define REC_CAS(x) (((x)>>16) & 0xFFFFFF)
  222. #define REC_RAS(x) ((x) & 0x7FFF)
  223. #define RECFGLOG 0xE8
  224. #define RECFBDA 0xEC
  225. #define RECFBDB 0xF0
  226. #define RECFBDC 0xF4
  227. #define RECFBDD 0xF8
  228. #define RECFBDE 0xFC
  229. /* OFFSETS for Function 2 */
  230. /*
  231. * Device 21,
  232. * Function 0: Memory Map Branch 0
  233. *
  234. * Device 22,
  235. * Function 0: Memory Map Branch 1
  236. */
  237. #define PCI_DEVICE_ID_I5000_BRANCH_0 0x25F5
  238. #define PCI_DEVICE_ID_I5000_BRANCH_1 0x25F6
  239. #define AMB_PRESENT_0 0x64
  240. #define AMB_PRESENT_1 0x66
  241. #define MTR0 0x80
  242. #define MTR1 0x84
  243. #define MTR2 0x88
  244. #define MTR3 0x8C
  245. #define NUM_MTRS 4
  246. #define CHANNELS_PER_BRANCH 2
  247. #define MAX_BRANCHES 2
  248. /* Defines to extract the various fields from the
  249. * MTRx - Memory Technology Registers
  250. */
  251. #define MTR_DIMMS_PRESENT(mtr) ((mtr) & (0x1 << 8))
  252. #define MTR_DRAM_WIDTH(mtr) ((((mtr) >> 6) & 0x1) ? 8 : 4)
  253. #define MTR_DRAM_BANKS(mtr) ((((mtr) >> 5) & 0x1) ? 8 : 4)
  254. #define MTR_DRAM_BANKS_ADDR_BITS(mtr) ((MTR_DRAM_BANKS(mtr) == 8) ? 3 : 2)
  255. #define MTR_DIMM_RANK(mtr) (((mtr) >> 4) & 0x1)
  256. #define MTR_DIMM_RANK_ADDR_BITS(mtr) (MTR_DIMM_RANK(mtr) ? 2 : 1)
  257. #define MTR_DIMM_ROWS(mtr) (((mtr) >> 2) & 0x3)
  258. #define MTR_DIMM_ROWS_ADDR_BITS(mtr) (MTR_DIMM_ROWS(mtr) + 13)
  259. #define MTR_DIMM_COLS(mtr) ((mtr) & 0x3)
  260. #define MTR_DIMM_COLS_ADDR_BITS(mtr) (MTR_DIMM_COLS(mtr) + 10)
  261. /* enables the report of miscellaneous messages as CE errors - default off */
  262. static int misc_messages;
  263. /* Enumeration of supported devices */
  264. enum i5000_chips {
  265. I5000P = 0,
  266. I5000V = 1, /* future */
  267. I5000X = 2 /* future */
  268. };
  269. /* Device name and register DID (Device ID) */
  270. struct i5000_dev_info {
  271. const char *ctl_name; /* name for this device */
  272. u16 fsb_mapping_errors; /* DID for the branchmap,control */
  273. };
  274. /* Table of devices attributes supported by this driver */
  275. static const struct i5000_dev_info i5000_devs[] = {
  276. [I5000P] = {
  277. .ctl_name = "I5000",
  278. .fsb_mapping_errors = PCI_DEVICE_ID_INTEL_I5000_DEV16,
  279. },
  280. };
  281. struct i5000_dimm_info {
  282. int megabytes; /* size, 0 means not present */
  283. int dual_rank;
  284. };
  285. #define MAX_CHANNELS 6 /* max possible channels */
  286. #define MAX_CSROWS (8*2) /* max possible csrows per channel */
  287. /* driver private data structure */
  288. struct i5000_pvt {
  289. struct pci_dev *system_address; /* 16.0 */
  290. struct pci_dev *branchmap_werrors; /* 16.1 */
  291. struct pci_dev *fsb_error_regs; /* 16.2 */
  292. struct pci_dev *branch_0; /* 21.0 */
  293. struct pci_dev *branch_1; /* 22.0 */
  294. u16 tolm; /* top of low memory */
  295. union {
  296. u64 ambase; /* AMB BAR */
  297. struct {
  298. u32 ambase_bottom;
  299. u32 ambase_top;
  300. } u __packed;
  301. };
  302. u16 mir0, mir1, mir2;
  303. u16 b0_mtr[NUM_MTRS]; /* Memory Technlogy Reg */
  304. u16 b0_ambpresent0; /* Branch 0, Channel 0 */
  305. u16 b0_ambpresent1; /* Brnach 0, Channel 1 */
  306. u16 b1_mtr[NUM_MTRS]; /* Memory Technlogy Reg */
  307. u16 b1_ambpresent0; /* Branch 1, Channel 8 */
  308. u16 b1_ambpresent1; /* Branch 1, Channel 1 */
  309. /* DIMM information matrix, allocating architecture maximums */
  310. struct i5000_dimm_info dimm_info[MAX_CSROWS][MAX_CHANNELS];
  311. /* Actual values for this controller */
  312. int maxch; /* Max channels */
  313. int maxdimmperch; /* Max DIMMs per channel */
  314. };
  315. /* I5000 MCH error information retrieved from Hardware */
  316. struct i5000_error_info {
  317. /* These registers are always read from the MC */
  318. u32 ferr_fat_fbd; /* First Errors Fatal */
  319. u32 nerr_fat_fbd; /* Next Errors Fatal */
  320. u32 ferr_nf_fbd; /* First Errors Non-Fatal */
  321. u32 nerr_nf_fbd; /* Next Errors Non-Fatal */
  322. /* These registers are input ONLY if there was a Recoverable Error */
  323. u32 redmemb; /* Recoverable Mem Data Error log B */
  324. u16 recmema; /* Recoverable Mem Error log A */
  325. u32 recmemb; /* Recoverable Mem Error log B */
  326. /* These registers are input ONLY if there was a
  327. * Non-Recoverable Error */
  328. u16 nrecmema; /* Non-Recoverable Mem log A */
  329. u32 nrecmemb; /* Non-Recoverable Mem log B */
  330. };
  331. static struct edac_pci_ctl_info *i5000_pci;
  332. /*
  333. * i5000_get_error_info Retrieve the hardware error information from
  334. * the hardware and cache it in the 'info'
  335. * structure
  336. */
  337. static void i5000_get_error_info(struct mem_ctl_info *mci,
  338. struct i5000_error_info *info)
  339. {
  340. struct i5000_pvt *pvt;
  341. u32 value;
  342. pvt = mci->pvt_info;
  343. /* read in the 1st FATAL error register */
  344. pci_read_config_dword(pvt->branchmap_werrors, FERR_FAT_FBD, &value);
  345. /* Mask only the bits that the doc says are valid
  346. */
  347. value &= (FERR_FAT_FBDCHAN | FERR_FAT_MASK);
  348. /* If there is an error, then read in the */
  349. /* NEXT FATAL error register and the Memory Error Log Register A */
  350. if (value & FERR_FAT_MASK) {
  351. info->ferr_fat_fbd = value;
  352. /* harvest the various error data we need */
  353. pci_read_config_dword(pvt->branchmap_werrors,
  354. NERR_FAT_FBD, &info->nerr_fat_fbd);
  355. pci_read_config_word(pvt->branchmap_werrors,
  356. NRECMEMA, &info->nrecmema);
  357. pci_read_config_dword(pvt->branchmap_werrors,
  358. NRECMEMB, &info->nrecmemb);
  359. /* Clear the error bits, by writing them back */
  360. pci_write_config_dword(pvt->branchmap_werrors,
  361. FERR_FAT_FBD, value);
  362. } else {
  363. info->ferr_fat_fbd = 0;
  364. info->nerr_fat_fbd = 0;
  365. info->nrecmema = 0;
  366. info->nrecmemb = 0;
  367. }
  368. /* read in the 1st NON-FATAL error register */
  369. pci_read_config_dword(pvt->branchmap_werrors, FERR_NF_FBD, &value);
  370. /* If there is an error, then read in the 1st NON-FATAL error
  371. * register as well */
  372. if (value & FERR_NF_MASK) {
  373. info->ferr_nf_fbd = value;
  374. /* harvest the various error data we need */
  375. pci_read_config_dword(pvt->branchmap_werrors,
  376. NERR_NF_FBD, &info->nerr_nf_fbd);
  377. pci_read_config_word(pvt->branchmap_werrors,
  378. RECMEMA, &info->recmema);
  379. pci_read_config_dword(pvt->branchmap_werrors,
  380. RECMEMB, &info->recmemb);
  381. pci_read_config_dword(pvt->branchmap_werrors,
  382. REDMEMB, &info->redmemb);
  383. /* Clear the error bits, by writing them back */
  384. pci_write_config_dword(pvt->branchmap_werrors,
  385. FERR_NF_FBD, value);
  386. } else {
  387. info->ferr_nf_fbd = 0;
  388. info->nerr_nf_fbd = 0;
  389. info->recmema = 0;
  390. info->recmemb = 0;
  391. info->redmemb = 0;
  392. }
  393. }
  394. /*
  395. * i5000_process_fatal_error_info(struct mem_ctl_info *mci,
  396. * struct i5000_error_info *info,
  397. * int handle_errors);
  398. *
  399. * handle the Intel FATAL errors, if any
  400. */
  401. static void i5000_process_fatal_error_info(struct mem_ctl_info *mci,
  402. struct i5000_error_info *info,
  403. int handle_errors)
  404. {
  405. char msg[EDAC_MC_LABEL_LEN + 1 + 160];
  406. char *specific = NULL;
  407. u32 allErrors;
  408. int channel;
  409. int bank;
  410. int rank;
  411. int rdwr;
  412. int ras, cas;
  413. /* mask off the Error bits that are possible */
  414. allErrors = (info->ferr_fat_fbd & FERR_FAT_MASK);
  415. if (!allErrors)
  416. return; /* if no error, return now */
  417. channel = EXTRACT_FBDCHAN_INDX(info->ferr_fat_fbd);
  418. /* Use the NON-Recoverable macros to extract data */
  419. bank = NREC_BANK(info->nrecmema);
  420. rank = NREC_RANK(info->nrecmema);
  421. rdwr = NREC_RDWR(info->nrecmema);
  422. ras = NREC_RAS(info->nrecmemb);
  423. cas = NREC_CAS(info->nrecmemb);
  424. edac_dbg(0, "\t\tCSROW= %d Channel= %d (DRAM Bank= %d rdwr= %s ras= %d cas= %d)\n",
  425. rank, channel, bank,
  426. rdwr ? "Write" : "Read", ras, cas);
  427. /* Only 1 bit will be on */
  428. switch (allErrors) {
  429. case FERR_FAT_M1ERR:
  430. specific = "Alert on non-redundant retry or fast "
  431. "reset timeout";
  432. break;
  433. case FERR_FAT_M2ERR:
  434. specific = "Northbound CRC error on non-redundant "
  435. "retry";
  436. break;
  437. case FERR_FAT_M3ERR:
  438. {
  439. static int done;
  440. /*
  441. * This error is generated to inform that the intelligent
  442. * throttling is disabled and the temperature passed the
  443. * specified middle point. Since this is something the BIOS
  444. * should take care of, we'll warn only once to avoid
  445. * worthlessly flooding the log.
  446. */
  447. if (done)
  448. return;
  449. done++;
  450. specific = ">Tmid Thermal event with intelligent "
  451. "throttling disabled";
  452. }
  453. break;
  454. }
  455. /* Form out message */
  456. snprintf(msg, sizeof(msg),
  457. "Bank=%d RAS=%d CAS=%d FATAL Err=0x%x (%s)",
  458. bank, ras, cas, allErrors, specific);
  459. /* Call the helper to output message */
  460. edac_mc_handle_error(HW_EVENT_ERR_FATAL, mci, 1, 0, 0, 0,
  461. channel >> 1, channel & 1, rank,
  462. rdwr ? "Write error" : "Read error",
  463. msg);
  464. }
  465. /*
  466. * i5000_process_fatal_error_info(struct mem_ctl_info *mci,
  467. * struct i5000_error_info *info,
  468. * int handle_errors);
  469. *
  470. * handle the Intel NON-FATAL errors, if any
  471. */
  472. static void i5000_process_nonfatal_error_info(struct mem_ctl_info *mci,
  473. struct i5000_error_info *info,
  474. int handle_errors)
  475. {
  476. char msg[EDAC_MC_LABEL_LEN + 1 + 170];
  477. char *specific = NULL;
  478. u32 allErrors;
  479. u32 ue_errors;
  480. u32 ce_errors;
  481. u32 misc_errors;
  482. int branch;
  483. int channel;
  484. int bank;
  485. int rank;
  486. int rdwr;
  487. int ras, cas;
  488. /* mask off the Error bits that are possible */
  489. allErrors = (info->ferr_nf_fbd & FERR_NF_MASK);
  490. if (!allErrors)
  491. return; /* if no error, return now */
  492. /* ONLY ONE of the possible error bits will be set, as per the docs */
  493. ue_errors = allErrors & FERR_NF_UNCORRECTABLE;
  494. if (ue_errors) {
  495. edac_dbg(0, "\tUncorrected bits= 0x%x\n", ue_errors);
  496. branch = EXTRACT_FBDCHAN_INDX(info->ferr_nf_fbd);
  497. /*
  498. * According with i5000 datasheet, bit 28 has no significance
  499. * for errors M4Err-M12Err and M17Err-M21Err, on FERR_NF_FBD
  500. */
  501. channel = branch & 2;
  502. bank = NREC_BANK(info->nrecmema);
  503. rank = NREC_RANK(info->nrecmema);
  504. rdwr = NREC_RDWR(info->nrecmema);
  505. ras = NREC_RAS(info->nrecmemb);
  506. cas = NREC_CAS(info->nrecmemb);
  507. edac_dbg(0, "\t\tCSROW= %d Channels= %d,%d (Branch= %d DRAM Bank= %d rdwr= %s ras= %d cas= %d)\n",
  508. rank, channel, channel + 1, branch >> 1, bank,
  509. rdwr ? "Write" : "Read", ras, cas);
  510. switch (ue_errors) {
  511. case FERR_NF_M12ERR:
  512. specific = "Non-Aliased Uncorrectable Patrol Data ECC";
  513. break;
  514. case FERR_NF_M11ERR:
  515. specific = "Non-Aliased Uncorrectable Spare-Copy "
  516. "Data ECC";
  517. break;
  518. case FERR_NF_M10ERR:
  519. specific = "Non-Aliased Uncorrectable Mirrored Demand "
  520. "Data ECC";
  521. break;
  522. case FERR_NF_M9ERR:
  523. specific = "Non-Aliased Uncorrectable Non-Mirrored "
  524. "Demand Data ECC";
  525. break;
  526. case FERR_NF_M8ERR:
  527. specific = "Aliased Uncorrectable Patrol Data ECC";
  528. break;
  529. case FERR_NF_M7ERR:
  530. specific = "Aliased Uncorrectable Spare-Copy Data ECC";
  531. break;
  532. case FERR_NF_M6ERR:
  533. specific = "Aliased Uncorrectable Mirrored Demand "
  534. "Data ECC";
  535. break;
  536. case FERR_NF_M5ERR:
  537. specific = "Aliased Uncorrectable Non-Mirrored Demand "
  538. "Data ECC";
  539. break;
  540. case FERR_NF_M4ERR:
  541. specific = "Uncorrectable Data ECC on Replay";
  542. break;
  543. }
  544. /* Form out message */
  545. snprintf(msg, sizeof(msg),
  546. "Rank=%d Bank=%d RAS=%d CAS=%d, UE Err=0x%x (%s)",
  547. rank, bank, ras, cas, ue_errors, specific);
  548. /* Call the helper to output message */
  549. edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, 0, 0, 0,
  550. channel >> 1, -1, rank,
  551. rdwr ? "Write error" : "Read error",
  552. msg);
  553. }
  554. /* Check correctable errors */
  555. ce_errors = allErrors & FERR_NF_CORRECTABLE;
  556. if (ce_errors) {
  557. edac_dbg(0, "\tCorrected bits= 0x%x\n", ce_errors);
  558. branch = EXTRACT_FBDCHAN_INDX(info->ferr_nf_fbd);
  559. channel = 0;
  560. if (REC_ECC_LOCATOR_ODD(info->redmemb))
  561. channel = 1;
  562. /* Convert channel to be based from zero, instead of
  563. * from branch base of 0 */
  564. channel += branch;
  565. bank = REC_BANK(info->recmema);
  566. rank = REC_RANK(info->recmema);
  567. rdwr = REC_RDWR(info->recmema);
  568. ras = REC_RAS(info->recmemb);
  569. cas = REC_CAS(info->recmemb);
  570. edac_dbg(0, "\t\tCSROW= %d Channel= %d (Branch %d DRAM Bank= %d rdwr= %s ras= %d cas= %d)\n",
  571. rank, channel, branch >> 1, bank,
  572. rdwr ? "Write" : "Read", ras, cas);
  573. switch (ce_errors) {
  574. case FERR_NF_M17ERR:
  575. specific = "Correctable Non-Mirrored Demand Data ECC";
  576. break;
  577. case FERR_NF_M18ERR:
  578. specific = "Correctable Mirrored Demand Data ECC";
  579. break;
  580. case FERR_NF_M19ERR:
  581. specific = "Correctable Spare-Copy Data ECC";
  582. break;
  583. case FERR_NF_M20ERR:
  584. specific = "Correctable Patrol Data ECC";
  585. break;
  586. }
  587. /* Form out message */
  588. snprintf(msg, sizeof(msg),
  589. "Rank=%d Bank=%d RDWR=%s RAS=%d "
  590. "CAS=%d, CE Err=0x%x (%s))", branch >> 1, bank,
  591. rdwr ? "Write" : "Read", ras, cas, ce_errors,
  592. specific);
  593. /* Call the helper to output message */
  594. edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 0, 0, 0,
  595. channel >> 1, channel % 2, rank,
  596. rdwr ? "Write error" : "Read error",
  597. msg);
  598. }
  599. if (!misc_messages)
  600. return;
  601. misc_errors = allErrors & (FERR_NF_NON_RETRY | FERR_NF_NORTH_CRC |
  602. FERR_NF_SPD_PROTOCOL | FERR_NF_DIMM_SPARE);
  603. if (misc_errors) {
  604. switch (misc_errors) {
  605. case FERR_NF_M13ERR:
  606. specific = "Non-Retry or Redundant Retry FBD Memory "
  607. "Alert or Redundant Fast Reset Timeout";
  608. break;
  609. case FERR_NF_M14ERR:
  610. specific = "Non-Retry or Redundant Retry FBD "
  611. "Configuration Alert";
  612. break;
  613. case FERR_NF_M15ERR:
  614. specific = "Non-Retry or Redundant Retry FBD "
  615. "Northbound CRC error on read data";
  616. break;
  617. case FERR_NF_M21ERR:
  618. specific = "FBD Northbound CRC error on "
  619. "FBD Sync Status";
  620. break;
  621. case FERR_NF_M22ERR:
  622. specific = "SPD protocol error";
  623. break;
  624. case FERR_NF_M27ERR:
  625. specific = "DIMM-spare copy started";
  626. break;
  627. case FERR_NF_M28ERR:
  628. specific = "DIMM-spare copy completed";
  629. break;
  630. }
  631. branch = EXTRACT_FBDCHAN_INDX(info->ferr_nf_fbd);
  632. /* Form out message */
  633. snprintf(msg, sizeof(msg),
  634. "Err=%#x (%s)", misc_errors, specific);
  635. /* Call the helper to output message */
  636. edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 0, 0, 0,
  637. branch >> 1, -1, -1,
  638. "Misc error", msg);
  639. }
  640. }
  641. /*
  642. * i5000_process_error_info Process the error info that is
  643. * in the 'info' structure, previously retrieved from hardware
  644. */
  645. static void i5000_process_error_info(struct mem_ctl_info *mci,
  646. struct i5000_error_info *info,
  647. int handle_errors)
  648. {
  649. /* First handle any fatal errors that occurred */
  650. i5000_process_fatal_error_info(mci, info, handle_errors);
  651. /* now handle any non-fatal errors that occurred */
  652. i5000_process_nonfatal_error_info(mci, info, handle_errors);
  653. }
  654. /*
  655. * i5000_clear_error Retrieve any error from the hardware
  656. * but do NOT process that error.
  657. * Used for 'clearing' out of previous errors
  658. * Called by the Core module.
  659. */
  660. static void i5000_clear_error(struct mem_ctl_info *mci)
  661. {
  662. struct i5000_error_info info;
  663. i5000_get_error_info(mci, &info);
  664. }
  665. /*
  666. * i5000_check_error Retrieve and process errors reported by the
  667. * hardware. Called by the Core module.
  668. */
  669. static void i5000_check_error(struct mem_ctl_info *mci)
  670. {
  671. struct i5000_error_info info;
  672. i5000_get_error_info(mci, &info);
  673. i5000_process_error_info(mci, &info, 1);
  674. }
  675. /*
  676. * i5000_get_devices Find and perform 'get' operation on the MCH's
  677. * device/functions we want to reference for this driver
  678. *
  679. * Need to 'get' device 16 func 1 and func 2
  680. */
  681. static int i5000_get_devices(struct mem_ctl_info *mci, int dev_idx)
  682. {
  683. //const struct i5000_dev_info *i5000_dev = &i5000_devs[dev_idx];
  684. struct i5000_pvt *pvt;
  685. struct pci_dev *pdev;
  686. pvt = mci->pvt_info;
  687. /* Attempt to 'get' the MCH register we want */
  688. pdev = NULL;
  689. while (1) {
  690. pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
  691. PCI_DEVICE_ID_INTEL_I5000_DEV16, pdev);
  692. /* End of list, leave */
  693. if (pdev == NULL) {
  694. i5000_printk(KERN_ERR,
  695. "'system address,Process Bus' "
  696. "device not found:"
  697. "vendor 0x%x device 0x%x FUNC 1 "
  698. "(broken BIOS?)\n",
  699. PCI_VENDOR_ID_INTEL,
  700. PCI_DEVICE_ID_INTEL_I5000_DEV16);
  701. return 1;
  702. }
  703. /* Scan for device 16 func 1 */
  704. if (PCI_FUNC(pdev->devfn) == 1)
  705. break;
  706. }
  707. pvt->branchmap_werrors = pdev;
  708. /* Attempt to 'get' the MCH register we want */
  709. pdev = NULL;
  710. while (1) {
  711. pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
  712. PCI_DEVICE_ID_INTEL_I5000_DEV16, pdev);
  713. if (pdev == NULL) {
  714. i5000_printk(KERN_ERR,
  715. "MC: 'branchmap,control,errors' "
  716. "device not found:"
  717. "vendor 0x%x device 0x%x Func 2 "
  718. "(broken BIOS?)\n",
  719. PCI_VENDOR_ID_INTEL,
  720. PCI_DEVICE_ID_INTEL_I5000_DEV16);
  721. pci_dev_put(pvt->branchmap_werrors);
  722. return 1;
  723. }
  724. /* Scan for device 16 func 1 */
  725. if (PCI_FUNC(pdev->devfn) == 2)
  726. break;
  727. }
  728. pvt->fsb_error_regs = pdev;
  729. edac_dbg(1, "System Address, processor bus- PCI Bus ID: %s %x:%x\n",
  730. pci_name(pvt->system_address),
  731. pvt->system_address->vendor, pvt->system_address->device);
  732. edac_dbg(1, "Branchmap, control and errors - PCI Bus ID: %s %x:%x\n",
  733. pci_name(pvt->branchmap_werrors),
  734. pvt->branchmap_werrors->vendor,
  735. pvt->branchmap_werrors->device);
  736. edac_dbg(1, "FSB Error Regs - PCI Bus ID: %s %x:%x\n",
  737. pci_name(pvt->fsb_error_regs),
  738. pvt->fsb_error_regs->vendor, pvt->fsb_error_regs->device);
  739. pdev = NULL;
  740. pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
  741. PCI_DEVICE_ID_I5000_BRANCH_0, pdev);
  742. if (pdev == NULL) {
  743. i5000_printk(KERN_ERR,
  744. "MC: 'BRANCH 0' device not found:"
  745. "vendor 0x%x device 0x%x Func 0 (broken BIOS?)\n",
  746. PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_I5000_BRANCH_0);
  747. pci_dev_put(pvt->branchmap_werrors);
  748. pci_dev_put(pvt->fsb_error_regs);
  749. return 1;
  750. }
  751. pvt->branch_0 = pdev;
  752. /* If this device claims to have more than 2 channels then
  753. * fetch Branch 1's information
  754. */
  755. if (pvt->maxch >= CHANNELS_PER_BRANCH) {
  756. pdev = NULL;
  757. pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
  758. PCI_DEVICE_ID_I5000_BRANCH_1, pdev);
  759. if (pdev == NULL) {
  760. i5000_printk(KERN_ERR,
  761. "MC: 'BRANCH 1' device not found:"
  762. "vendor 0x%x device 0x%x Func 0 "
  763. "(broken BIOS?)\n",
  764. PCI_VENDOR_ID_INTEL,
  765. PCI_DEVICE_ID_I5000_BRANCH_1);
  766. pci_dev_put(pvt->branchmap_werrors);
  767. pci_dev_put(pvt->fsb_error_regs);
  768. pci_dev_put(pvt->branch_0);
  769. return 1;
  770. }
  771. pvt->branch_1 = pdev;
  772. }
  773. return 0;
  774. }
  775. /*
  776. * i5000_put_devices 'put' all the devices that we have
  777. * reserved via 'get'
  778. */
  779. static void i5000_put_devices(struct mem_ctl_info *mci)
  780. {
  781. struct i5000_pvt *pvt;
  782. pvt = mci->pvt_info;
  783. pci_dev_put(pvt->branchmap_werrors); /* FUNC 1 */
  784. pci_dev_put(pvt->fsb_error_regs); /* FUNC 2 */
  785. pci_dev_put(pvt->branch_0); /* DEV 21 */
  786. /* Only if more than 2 channels do we release the second branch */
  787. if (pvt->maxch >= CHANNELS_PER_BRANCH)
  788. pci_dev_put(pvt->branch_1); /* DEV 22 */
  789. }
  790. /*
  791. * determine_amb_resent
  792. *
  793. * the information is contained in NUM_MTRS different registers
  794. * determineing which of the NUM_MTRS requires knowing
  795. * which channel is in question
  796. *
  797. * 2 branches, each with 2 channels
  798. * b0_ambpresent0 for channel '0'
  799. * b0_ambpresent1 for channel '1'
  800. * b1_ambpresent0 for channel '2'
  801. * b1_ambpresent1 for channel '3'
  802. */
  803. static int determine_amb_present_reg(struct i5000_pvt *pvt, int channel)
  804. {
  805. int amb_present;
  806. if (channel < CHANNELS_PER_BRANCH) {
  807. if (channel & 0x1)
  808. amb_present = pvt->b0_ambpresent1;
  809. else
  810. amb_present = pvt->b0_ambpresent0;
  811. } else {
  812. if (channel & 0x1)
  813. amb_present = pvt->b1_ambpresent1;
  814. else
  815. amb_present = pvt->b1_ambpresent0;
  816. }
  817. return amb_present;
  818. }
  819. /*
  820. * determine_mtr(pvt, csrow, channel)
  821. *
  822. * return the proper MTR register as determine by the csrow and channel desired
  823. */
  824. static int determine_mtr(struct i5000_pvt *pvt, int slot, int channel)
  825. {
  826. int mtr;
  827. if (channel < CHANNELS_PER_BRANCH)
  828. mtr = pvt->b0_mtr[slot];
  829. else
  830. mtr = pvt->b1_mtr[slot];
  831. return mtr;
  832. }
  833. /*
  834. */
  835. static void decode_mtr(int slot_row, u16 mtr)
  836. {
  837. int ans;
  838. ans = MTR_DIMMS_PRESENT(mtr);
  839. edac_dbg(2, "\tMTR%d=0x%x: DIMMs are %sPresent\n",
  840. slot_row, mtr, ans ? "" : "NOT ");
  841. if (!ans)
  842. return;
  843. edac_dbg(2, "\t\tWIDTH: x%d\n", MTR_DRAM_WIDTH(mtr));
  844. edac_dbg(2, "\t\tNUMBANK: %d bank(s)\n", MTR_DRAM_BANKS(mtr));
  845. edac_dbg(2, "\t\tNUMRANK: %s\n",
  846. MTR_DIMM_RANK(mtr) ? "double" : "single");
  847. edac_dbg(2, "\t\tNUMROW: %s\n",
  848. MTR_DIMM_ROWS(mtr) == 0 ? "8,192 - 13 rows" :
  849. MTR_DIMM_ROWS(mtr) == 1 ? "16,384 - 14 rows" :
  850. MTR_DIMM_ROWS(mtr) == 2 ? "32,768 - 15 rows" :
  851. "reserved");
  852. edac_dbg(2, "\t\tNUMCOL: %s\n",
  853. MTR_DIMM_COLS(mtr) == 0 ? "1,024 - 10 columns" :
  854. MTR_DIMM_COLS(mtr) == 1 ? "2,048 - 11 columns" :
  855. MTR_DIMM_COLS(mtr) == 2 ? "4,096 - 12 columns" :
  856. "reserved");
  857. }
  858. static void handle_channel(struct i5000_pvt *pvt, int slot, int channel,
  859. struct i5000_dimm_info *dinfo)
  860. {
  861. int mtr;
  862. int amb_present_reg;
  863. int addrBits;
  864. mtr = determine_mtr(pvt, slot, channel);
  865. if (MTR_DIMMS_PRESENT(mtr)) {
  866. amb_present_reg = determine_amb_present_reg(pvt, channel);
  867. /* Determine if there is a DIMM present in this DIMM slot */
  868. if (amb_present_reg) {
  869. dinfo->dual_rank = MTR_DIMM_RANK(mtr);
  870. /* Start with the number of bits for a Bank
  871. * on the DRAM */
  872. addrBits = MTR_DRAM_BANKS_ADDR_BITS(mtr);
  873. /* Add the number of ROW bits */
  874. addrBits += MTR_DIMM_ROWS_ADDR_BITS(mtr);
  875. /* add the number of COLUMN bits */
  876. addrBits += MTR_DIMM_COLS_ADDR_BITS(mtr);
  877. /* Dual-rank memories have twice the size */
  878. if (dinfo->dual_rank)
  879. addrBits++;
  880. addrBits += 6; /* add 64 bits per DIMM */
  881. addrBits -= 20; /* divide by 2^^20 */
  882. addrBits -= 3; /* 8 bits per bytes */
  883. dinfo->megabytes = 1 << addrBits;
  884. }
  885. }
  886. }
  887. /*
  888. * calculate_dimm_size
  889. *
  890. * also will output a DIMM matrix map, if debug is enabled, for viewing
  891. * how the DIMMs are populated
  892. */
  893. static void calculate_dimm_size(struct i5000_pvt *pvt)
  894. {
  895. struct i5000_dimm_info *dinfo;
  896. int slot, channel, branch;
  897. char *p, *mem_buffer;
  898. int space, n;
  899. /* ================= Generate some debug output ================= */
  900. space = PAGE_SIZE;
  901. mem_buffer = p = kmalloc(space, GFP_KERNEL);
  902. if (p == NULL) {
  903. i5000_printk(KERN_ERR, "MC: %s:%s() kmalloc() failed\n",
  904. __FILE__, __func__);
  905. return;
  906. }
  907. /* Scan all the actual slots
  908. * and calculate the information for each DIMM
  909. * Start with the highest slot first, to display it first
  910. * and work toward the 0th slot
  911. */
  912. for (slot = pvt->maxdimmperch - 1; slot >= 0; slot--) {
  913. /* on an odd slot, first output a 'boundary' marker,
  914. * then reset the message buffer */
  915. if (slot & 0x1) {
  916. n = snprintf(p, space, "--------------------------"
  917. "--------------------------------");
  918. p += n;
  919. space -= n;
  920. edac_dbg(2, "%s\n", mem_buffer);
  921. p = mem_buffer;
  922. space = PAGE_SIZE;
  923. }
  924. n = snprintf(p, space, "slot %2d ", slot);
  925. p += n;
  926. space -= n;
  927. for (channel = 0; channel < pvt->maxch; channel++) {
  928. dinfo = &pvt->dimm_info[slot][channel];
  929. handle_channel(pvt, slot, channel, dinfo);
  930. if (dinfo->megabytes)
  931. n = snprintf(p, space, "%4d MB %dR| ",
  932. dinfo->megabytes, dinfo->dual_rank + 1);
  933. else
  934. n = snprintf(p, space, "%4d MB | ", 0);
  935. p += n;
  936. space -= n;
  937. }
  938. p += n;
  939. space -= n;
  940. edac_dbg(2, "%s\n", mem_buffer);
  941. p = mem_buffer;
  942. space = PAGE_SIZE;
  943. }
  944. /* Output the last bottom 'boundary' marker */
  945. n = snprintf(p, space, "--------------------------"
  946. "--------------------------------");
  947. p += n;
  948. space -= n;
  949. edac_dbg(2, "%s\n", mem_buffer);
  950. p = mem_buffer;
  951. space = PAGE_SIZE;
  952. /* now output the 'channel' labels */
  953. n = snprintf(p, space, " ");
  954. p += n;
  955. space -= n;
  956. for (channel = 0; channel < pvt->maxch; channel++) {
  957. n = snprintf(p, space, "channel %d | ", channel);
  958. p += n;
  959. space -= n;
  960. }
  961. edac_dbg(2, "%s\n", mem_buffer);
  962. p = mem_buffer;
  963. space = PAGE_SIZE;
  964. n = snprintf(p, space, " ");
  965. p += n;
  966. for (branch = 0; branch < MAX_BRANCHES; branch++) {
  967. n = snprintf(p, space, " branch %d | ", branch);
  968. p += n;
  969. space -= n;
  970. }
  971. /* output the last message and free buffer */
  972. edac_dbg(2, "%s\n", mem_buffer);
  973. kfree(mem_buffer);
  974. }
  975. /*
  976. * i5000_get_mc_regs read in the necessary registers and
  977. * cache locally
  978. *
  979. * Fills in the private data members
  980. */
  981. static void i5000_get_mc_regs(struct mem_ctl_info *mci)
  982. {
  983. struct i5000_pvt *pvt;
  984. u32 actual_tolm;
  985. u16 limit;
  986. int slot_row;
  987. int way0, way1;
  988. pvt = mci->pvt_info;
  989. pci_read_config_dword(pvt->system_address, AMBASE,
  990. &pvt->u.ambase_bottom);
  991. pci_read_config_dword(pvt->system_address, AMBASE + sizeof(u32),
  992. &pvt->u.ambase_top);
  993. edac_dbg(2, "AMBASE= 0x%lx MAXCH= %d MAX-DIMM-Per-CH= %d\n",
  994. (long unsigned int)pvt->ambase, pvt->maxch, pvt->maxdimmperch);
  995. /* Get the Branch Map regs */
  996. pci_read_config_word(pvt->branchmap_werrors, TOLM, &pvt->tolm);
  997. pvt->tolm >>= 12;
  998. edac_dbg(2, "TOLM (number of 256M regions) =%u (0x%x)\n",
  999. pvt->tolm, pvt->tolm);
  1000. actual_tolm = pvt->tolm << 28;
  1001. edac_dbg(2, "Actual TOLM byte addr=%u (0x%x)\n",
  1002. actual_tolm, actual_tolm);
  1003. pci_read_config_word(pvt->branchmap_werrors, MIR0, &pvt->mir0);
  1004. pci_read_config_word(pvt->branchmap_werrors, MIR1, &pvt->mir1);
  1005. pci_read_config_word(pvt->branchmap_werrors, MIR2, &pvt->mir2);
  1006. /* Get the MIR[0-2] regs */
  1007. limit = (pvt->mir0 >> 4) & 0x0FFF;
  1008. way0 = pvt->mir0 & 0x1;
  1009. way1 = pvt->mir0 & 0x2;
  1010. edac_dbg(2, "MIR0: limit= 0x%x WAY1= %u WAY0= %x\n",
  1011. limit, way1, way0);
  1012. limit = (pvt->mir1 >> 4) & 0x0FFF;
  1013. way0 = pvt->mir1 & 0x1;
  1014. way1 = pvt->mir1 & 0x2;
  1015. edac_dbg(2, "MIR1: limit= 0x%x WAY1= %u WAY0= %x\n",
  1016. limit, way1, way0);
  1017. limit = (pvt->mir2 >> 4) & 0x0FFF;
  1018. way0 = pvt->mir2 & 0x1;
  1019. way1 = pvt->mir2 & 0x2;
  1020. edac_dbg(2, "MIR2: limit= 0x%x WAY1= %u WAY0= %x\n",
  1021. limit, way1, way0);
  1022. /* Get the MTR[0-3] regs */
  1023. for (slot_row = 0; slot_row < NUM_MTRS; slot_row++) {
  1024. int where = MTR0 + (slot_row * sizeof(u32));
  1025. pci_read_config_word(pvt->branch_0, where,
  1026. &pvt->b0_mtr[slot_row]);
  1027. edac_dbg(2, "MTR%d where=0x%x B0 value=0x%x\n",
  1028. slot_row, where, pvt->b0_mtr[slot_row]);
  1029. if (pvt->maxch >= CHANNELS_PER_BRANCH) {
  1030. pci_read_config_word(pvt->branch_1, where,
  1031. &pvt->b1_mtr[slot_row]);
  1032. edac_dbg(2, "MTR%d where=0x%x B1 value=0x%x\n",
  1033. slot_row, where, pvt->b1_mtr[slot_row]);
  1034. } else {
  1035. pvt->b1_mtr[slot_row] = 0;
  1036. }
  1037. }
  1038. /* Read and dump branch 0's MTRs */
  1039. edac_dbg(2, "Memory Technology Registers:\n");
  1040. edac_dbg(2, " Branch 0:\n");
  1041. for (slot_row = 0; slot_row < NUM_MTRS; slot_row++) {
  1042. decode_mtr(slot_row, pvt->b0_mtr[slot_row]);
  1043. }
  1044. pci_read_config_word(pvt->branch_0, AMB_PRESENT_0,
  1045. &pvt->b0_ambpresent0);
  1046. edac_dbg(2, "\t\tAMB-Branch 0-present0 0x%x:\n", pvt->b0_ambpresent0);
  1047. pci_read_config_word(pvt->branch_0, AMB_PRESENT_1,
  1048. &pvt->b0_ambpresent1);
  1049. edac_dbg(2, "\t\tAMB-Branch 0-present1 0x%x:\n", pvt->b0_ambpresent1);
  1050. /* Only if we have 2 branchs (4 channels) */
  1051. if (pvt->maxch < CHANNELS_PER_BRANCH) {
  1052. pvt->b1_ambpresent0 = 0;
  1053. pvt->b1_ambpresent1 = 0;
  1054. } else {
  1055. /* Read and dump branch 1's MTRs */
  1056. edac_dbg(2, " Branch 1:\n");
  1057. for (slot_row = 0; slot_row < NUM_MTRS; slot_row++) {
  1058. decode_mtr(slot_row, pvt->b1_mtr[slot_row]);
  1059. }
  1060. pci_read_config_word(pvt->branch_1, AMB_PRESENT_0,
  1061. &pvt->b1_ambpresent0);
  1062. edac_dbg(2, "\t\tAMB-Branch 1-present0 0x%x:\n",
  1063. pvt->b1_ambpresent0);
  1064. pci_read_config_word(pvt->branch_1, AMB_PRESENT_1,
  1065. &pvt->b1_ambpresent1);
  1066. edac_dbg(2, "\t\tAMB-Branch 1-present1 0x%x:\n",
  1067. pvt->b1_ambpresent1);
  1068. }
  1069. /* Go and determine the size of each DIMM and place in an
  1070. * orderly matrix */
  1071. calculate_dimm_size(pvt);
  1072. }
  1073. /*
  1074. * i5000_init_csrows Initialize the 'csrows' table within
  1075. * the mci control structure with the
  1076. * addressing of memory.
  1077. *
  1078. * return:
  1079. * 0 success
  1080. * 1 no actual memory found on this MC
  1081. */
  1082. static int i5000_init_csrows(struct mem_ctl_info *mci)
  1083. {
  1084. struct i5000_pvt *pvt;
  1085. struct dimm_info *dimm;
  1086. int empty;
  1087. int max_csrows;
  1088. int mtr;
  1089. int csrow_megs;
  1090. int channel;
  1091. int slot;
  1092. pvt = mci->pvt_info;
  1093. max_csrows = pvt->maxdimmperch * 2;
  1094. empty = 1; /* Assume NO memory */
  1095. /*
  1096. * FIXME: The memory layout used to map slot/channel into the
  1097. * real memory architecture is weird: branch+slot are "csrows"
  1098. * and channel is channel. That required an extra array (dimm_info)
  1099. * to map the dimms. A good cleanup would be to remove this array,
  1100. * and do a loop here with branch, channel, slot
  1101. */
  1102. for (slot = 0; slot < max_csrows; slot++) {
  1103. for (channel = 0; channel < pvt->maxch; channel++) {
  1104. mtr = determine_mtr(pvt, slot, channel);
  1105. if (!MTR_DIMMS_PRESENT(mtr))
  1106. continue;
  1107. dimm = edac_get_dimm(mci, channel / MAX_BRANCHES,
  1108. channel % MAX_BRANCHES, slot);
  1109. csrow_megs = pvt->dimm_info[slot][channel].megabytes;
  1110. dimm->grain = 8;
  1111. /* Assume DDR2 for now */
  1112. dimm->mtype = MEM_FB_DDR2;
  1113. /* ask what device type on this row */
  1114. if (MTR_DRAM_WIDTH(mtr) == 8)
  1115. dimm->dtype = DEV_X8;
  1116. else
  1117. dimm->dtype = DEV_X4;
  1118. dimm->edac_mode = EDAC_S8ECD8ED;
  1119. dimm->nr_pages = csrow_megs << 8;
  1120. }
  1121. empty = 0;
  1122. }
  1123. return empty;
  1124. }
  1125. /*
  1126. * i5000_enable_error_reporting
  1127. * Turn on the memory reporting features of the hardware
  1128. */
  1129. static void i5000_enable_error_reporting(struct mem_ctl_info *mci)
  1130. {
  1131. struct i5000_pvt *pvt;
  1132. u32 fbd_error_mask;
  1133. pvt = mci->pvt_info;
  1134. /* Read the FBD Error Mask Register */
  1135. pci_read_config_dword(pvt->branchmap_werrors, EMASK_FBD,
  1136. &fbd_error_mask);
  1137. /* Enable with a '0' */
  1138. fbd_error_mask &= ~(ENABLE_EMASK_ALL);
  1139. pci_write_config_dword(pvt->branchmap_werrors, EMASK_FBD,
  1140. fbd_error_mask);
  1141. }
  1142. /*
  1143. * i5000_get_dimm_and_channel_counts(pdev, &nr_csrows, &num_channels)
  1144. *
  1145. * ask the device how many channels are present and how many CSROWS
  1146. * as well
  1147. */
  1148. static void i5000_get_dimm_and_channel_counts(struct pci_dev *pdev,
  1149. int *num_dimms_per_channel,
  1150. int *num_channels)
  1151. {
  1152. u8 value;
  1153. /* Need to retrieve just how many channels and dimms per channel are
  1154. * supported on this memory controller
  1155. */
  1156. pci_read_config_byte(pdev, MAXDIMMPERCH, &value);
  1157. *num_dimms_per_channel = (int)value;
  1158. pci_read_config_byte(pdev, MAXCH, &value);
  1159. *num_channels = (int)value;
  1160. }
  1161. /*
  1162. * i5000_probe1 Probe for ONE instance of device to see if it is
  1163. * present.
  1164. * return:
  1165. * 0 for FOUND a device
  1166. * < 0 for error code
  1167. */
  1168. static int i5000_probe1(struct pci_dev *pdev, int dev_idx)
  1169. {
  1170. struct mem_ctl_info *mci;
  1171. struct edac_mc_layer layers[3];
  1172. struct i5000_pvt *pvt;
  1173. int num_channels;
  1174. int num_dimms_per_channel;
  1175. edac_dbg(0, "MC: pdev bus %u dev=0x%x fn=0x%x\n",
  1176. pdev->bus->number,
  1177. PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
  1178. /* We only are looking for func 0 of the set */
  1179. if (PCI_FUNC(pdev->devfn) != 0)
  1180. return -ENODEV;
  1181. /* Ask the devices for the number of CSROWS and CHANNELS so
  1182. * that we can calculate the memory resources, etc
  1183. *
  1184. * The Chipset will report what it can handle which will be greater
  1185. * or equal to what the motherboard manufacturer will implement.
  1186. *
  1187. * As we don't have a motherboard identification routine to determine
  1188. * actual number of slots/dimms per channel, we thus utilize the
  1189. * resource as specified by the chipset. Thus, we might have
  1190. * have more DIMMs per channel than actually on the mobo, but this
  1191. * allows the driver to support up to the chipset max, without
  1192. * some fancy mobo determination.
  1193. */
  1194. i5000_get_dimm_and_channel_counts(pdev, &num_dimms_per_channel,
  1195. &num_channels);
  1196. edac_dbg(0, "MC: Number of Branches=2 Channels= %d DIMMS= %d\n",
  1197. num_channels, num_dimms_per_channel);
  1198. /* allocate a new MC control structure */
  1199. layers[0].type = EDAC_MC_LAYER_BRANCH;
  1200. layers[0].size = MAX_BRANCHES;
  1201. layers[0].is_virt_csrow = false;
  1202. layers[1].type = EDAC_MC_LAYER_CHANNEL;
  1203. layers[1].size = num_channels / MAX_BRANCHES;
  1204. layers[1].is_virt_csrow = false;
  1205. layers[2].type = EDAC_MC_LAYER_SLOT;
  1206. layers[2].size = num_dimms_per_channel;
  1207. layers[2].is_virt_csrow = true;
  1208. mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers, sizeof(*pvt));
  1209. if (mci == NULL)
  1210. return -ENOMEM;
  1211. edac_dbg(0, "MC: mci = %p\n", mci);
  1212. mci->pdev = &pdev->dev; /* record ptr to the generic device */
  1213. pvt = mci->pvt_info;
  1214. pvt->system_address = pdev; /* Record this device in our private */
  1215. pvt->maxch = num_channels;
  1216. pvt->maxdimmperch = num_dimms_per_channel;
  1217. /* 'get' the pci devices we want to reserve for our use */
  1218. if (i5000_get_devices(mci, dev_idx))
  1219. goto fail0;
  1220. /* Time to get serious */
  1221. i5000_get_mc_regs(mci); /* retrieve the hardware registers */
  1222. mci->mc_idx = 0;
  1223. mci->mtype_cap = MEM_FLAG_FB_DDR2;
  1224. mci->edac_ctl_cap = EDAC_FLAG_NONE;
  1225. mci->edac_cap = EDAC_FLAG_NONE;
  1226. mci->mod_name = "i5000_edac.c";
  1227. mci->ctl_name = i5000_devs[dev_idx].ctl_name;
  1228. mci->dev_name = pci_name(pdev);
  1229. mci->ctl_page_to_phys = NULL;
  1230. /* Set the function pointer to an actual operation function */
  1231. mci->edac_check = i5000_check_error;
  1232. /* initialize the MC control structure 'csrows' table
  1233. * with the mapping and control information */
  1234. if (i5000_init_csrows(mci)) {
  1235. edac_dbg(0, "MC: Setting mci->edac_cap to EDAC_FLAG_NONE because i5000_init_csrows() returned nonzero value\n");
  1236. mci->edac_cap = EDAC_FLAG_NONE; /* no csrows found */
  1237. } else {
  1238. edac_dbg(1, "MC: Enable error reporting now\n");
  1239. i5000_enable_error_reporting(mci);
  1240. }
  1241. /* add this new MC control structure to EDAC's list of MCs */
  1242. if (edac_mc_add_mc(mci)) {
  1243. edac_dbg(0, "MC: failed edac_mc_add_mc()\n");
  1244. /* FIXME: perhaps some code should go here that disables error
  1245. * reporting if we just enabled it
  1246. */
  1247. goto fail1;
  1248. }
  1249. i5000_clear_error(mci);
  1250. /* allocating generic PCI control info */
  1251. i5000_pci = edac_pci_create_generic_ctl(&pdev->dev, EDAC_MOD_STR);
  1252. if (!i5000_pci) {
  1253. printk(KERN_WARNING
  1254. "%s(): Unable to create PCI control\n",
  1255. __func__);
  1256. printk(KERN_WARNING
  1257. "%s(): PCI error report via EDAC not setup\n",
  1258. __func__);
  1259. }
  1260. return 0;
  1261. /* Error exit unwinding stack */
  1262. fail1:
  1263. i5000_put_devices(mci);
  1264. fail0:
  1265. edac_mc_free(mci);
  1266. return -ENODEV;
  1267. }
  1268. /*
  1269. * i5000_init_one constructor for one instance of device
  1270. *
  1271. * returns:
  1272. * negative on error
  1273. * count (>= 0)
  1274. */
  1275. static int i5000_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
  1276. {
  1277. int rc;
  1278. edac_dbg(0, "MC:\n");
  1279. /* wake up device */
  1280. rc = pci_enable_device(pdev);
  1281. if (rc)
  1282. return rc;
  1283. /* now probe and enable the device */
  1284. return i5000_probe1(pdev, id->driver_data);
  1285. }
  1286. /*
  1287. * i5000_remove_one destructor for one instance of device
  1288. *
  1289. */
  1290. static void i5000_remove_one(struct pci_dev *pdev)
  1291. {
  1292. struct mem_ctl_info *mci;
  1293. edac_dbg(0, "\n");
  1294. if (i5000_pci)
  1295. edac_pci_release_generic_ctl(i5000_pci);
  1296. if ((mci = edac_mc_del_mc(&pdev->dev)) == NULL)
  1297. return;
  1298. /* retrieve references to resources, and free those resources */
  1299. i5000_put_devices(mci);
  1300. edac_mc_free(mci);
  1301. }
  1302. /*
  1303. * pci_device_id table for which devices we are looking for
  1304. *
  1305. * The "E500P" device is the first device supported.
  1306. */
  1307. static const struct pci_device_id i5000_pci_tbl[] = {
  1308. {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_I5000_DEV16),
  1309. .driver_data = I5000P},
  1310. {0,} /* 0 terminated list. */
  1311. };
  1312. MODULE_DEVICE_TABLE(pci, i5000_pci_tbl);
  1313. /*
  1314. * i5000_driver pci_driver structure for this module
  1315. *
  1316. */
  1317. static struct pci_driver i5000_driver = {
  1318. .name = KBUILD_BASENAME,
  1319. .probe = i5000_init_one,
  1320. .remove = i5000_remove_one,
  1321. .id_table = i5000_pci_tbl,
  1322. };
  1323. /*
  1324. * i5000_init Module entry function
  1325. * Try to initialize this module for its devices
  1326. */
  1327. static int __init i5000_init(void)
  1328. {
  1329. int pci_rc;
  1330. edac_dbg(2, "MC:\n");
  1331. /* Ensure that the OPSTATE is set correctly for POLL or NMI */
  1332. opstate_init();
  1333. pci_rc = pci_register_driver(&i5000_driver);
  1334. return (pci_rc < 0) ? pci_rc : 0;
  1335. }
  1336. /*
  1337. * i5000_exit() Module exit function
  1338. * Unregister the driver
  1339. */
  1340. static void __exit i5000_exit(void)
  1341. {
  1342. edac_dbg(2, "MC:\n");
  1343. pci_unregister_driver(&i5000_driver);
  1344. }
  1345. module_init(i5000_init);
  1346. module_exit(i5000_exit);
  1347. MODULE_LICENSE("GPL");
  1348. MODULE_AUTHOR
  1349. ("Linux Networx (http://lnxi.com) Doug Thompson <[email protected]>");
  1350. MODULE_DESCRIPTION("MC Driver for Intel I5000 memory controllers - "
  1351. I5000_REVISION);
  1352. module_param(edac_op_state, int, 0444);
  1353. MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
  1354. module_param(misc_messages, int, 0444);
  1355. MODULE_PARM_DESC(misc_messages, "Log miscellaneous non fatal messages");