]> Git Repo - J-linux.git/blob - drivers/ras/amd/atl/umc.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / drivers / ras / amd / atl / umc.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * AMD Address Translation Library
4  *
5  * umc.c : Unified Memory Controller (UMC) topology helpers
6  *
7  * Copyright (c) 2023, Advanced Micro Devices, Inc.
8  * All Rights Reserved.
9  *
10  * Author: Yazen Ghannam <[email protected]>
11  */
12
13 #include "internal.h"
14
15 /*
16  * MI300 has a fixed, model-specific mapping between a UMC instance and
17  * its related Data Fabric Coherent Station instance.
18  *
19  * The MCA_IPID_UMC[InstanceId] field holds a unique identifier for the
20  * UMC instance within a Node. Use this to find the appropriate Coherent
21  * Station ID.
22  *
23  * Redundant bits were removed from the map below.
24  */
25 static const u16 umc_coh_st_map[32] = {
26         0x393, 0x293, 0x193, 0x093,
27         0x392, 0x292, 0x192, 0x092,
28         0x391, 0x291, 0x191, 0x091,
29         0x390, 0x290, 0x190, 0x090,
30         0x793, 0x693, 0x593, 0x493,
31         0x792, 0x692, 0x592, 0x492,
32         0x791, 0x691, 0x591, 0x491,
33         0x790, 0x690, 0x590, 0x490,
34 };
35
36 #define UMC_ID_MI300 GENMASK(23, 12)
37 static u8 get_coh_st_inst_id_mi300(struct atl_err *err)
38 {
39         u16 umc_id = FIELD_GET(UMC_ID_MI300, err->ipid);
40         u8 i;
41
42         for (i = 0; i < ARRAY_SIZE(umc_coh_st_map); i++) {
43                 if (umc_id == umc_coh_st_map[i])
44                         break;
45         }
46
47         WARN_ON_ONCE(i >= ARRAY_SIZE(umc_coh_st_map));
48
49         return i;
50 }
51
52 /* XOR the bits in @val. */
53 static u16 bitwise_xor_bits(u16 val)
54 {
55         u16 tmp = 0;
56         u8 i;
57
58         for (i = 0; i < 16; i++)
59                 tmp ^= (val >> i) & 0x1;
60
61         return tmp;
62 }
63
64 struct xor_bits {
65         bool    xor_enable;
66         u16     col_xor;
67         u32     row_xor;
68 };
69
70 #define NUM_BANK_BITS   4
71 #define NUM_COL_BITS    5
72 #define NUM_SID_BITS    2
73
74 static struct {
75         /* UMC::CH::AddrHashBank */
76         struct xor_bits bank[NUM_BANK_BITS];
77
78         /* UMC::CH::AddrHashPC */
79         struct xor_bits pc;
80
81         /* UMC::CH::AddrHashPC2 */
82         u8              bank_xor;
83 } addr_hash;
84
85 static struct {
86         u8 bank[NUM_BANK_BITS];
87         u8 col[NUM_COL_BITS];
88         u8 sid[NUM_SID_BITS];
89         u8 num_row_lo;
90         u8 num_row_hi;
91         u8 row_lo;
92         u8 row_hi;
93         u8 pc;
94 } bit_shifts;
95
96 #define MI300_UMC_CH_BASE       0x90000
97 #define MI300_ADDR_CFG          (MI300_UMC_CH_BASE + 0x30)
98 #define MI300_ADDR_SEL          (MI300_UMC_CH_BASE + 0x40)
99 #define MI300_COL_SEL_LO        (MI300_UMC_CH_BASE + 0x50)
100 #define MI300_ADDR_SEL_2        (MI300_UMC_CH_BASE + 0xA4)
101 #define MI300_ADDR_HASH_BANK0   (MI300_UMC_CH_BASE + 0xC8)
102 #define MI300_ADDR_HASH_PC      (MI300_UMC_CH_BASE + 0xE0)
103 #define MI300_ADDR_HASH_PC2     (MI300_UMC_CH_BASE + 0xE4)
104
105 #define ADDR_HASH_XOR_EN        BIT(0)
106 #define ADDR_HASH_COL_XOR       GENMASK(13, 1)
107 #define ADDR_HASH_ROW_XOR       GENMASK(31, 14)
108 #define ADDR_HASH_BANK_XOR      GENMASK(5, 0)
109
110 #define ADDR_CFG_NUM_ROW_LO     GENMASK(11, 8)
111 #define ADDR_CFG_NUM_ROW_HI     GENMASK(15, 12)
112
113 #define ADDR_SEL_BANK0          GENMASK(3, 0)
114 #define ADDR_SEL_BANK1          GENMASK(7, 4)
115 #define ADDR_SEL_BANK2          GENMASK(11, 8)
116 #define ADDR_SEL_BANK3          GENMASK(15, 12)
117 #define ADDR_SEL_BANK4          GENMASK(20, 16)
118 #define ADDR_SEL_ROW_LO         GENMASK(27, 24)
119 #define ADDR_SEL_ROW_HI         GENMASK(31, 28)
120
121 #define COL_SEL_LO_COL0         GENMASK(3, 0)
122 #define COL_SEL_LO_COL1         GENMASK(7, 4)
123 #define COL_SEL_LO_COL2         GENMASK(11, 8)
124 #define COL_SEL_LO_COL3         GENMASK(15, 12)
125 #define COL_SEL_LO_COL4         GENMASK(19, 16)
126
127 #define ADDR_SEL_2_BANK5        GENMASK(4, 0)
128 #define ADDR_SEL_2_CHAN         GENMASK(15, 12)
129
130 /*
131  * Read UMC::CH::AddrHash{Bank,PC,PC2} registers to get XOR bits used
132  * for hashing.
133  *
134  * Also, read UMC::CH::Addr{Cfg,Sel,Sel2} and UMC::CH:ColSelLo registers to
135  * get the values needed to reconstruct the normalized address. Apply additional
136  * offsets to the raw register values, as needed.
137  *
138  * Do this during module init, since the values will not change during run time.
139  *
140  * These registers are instantiated for each UMC across each AMD Node.
141  * However, they should be identically programmed due to the fixed hardware
142  * design of MI300 systems. So read the values from Node 0 UMC 0 and keep a
143  * single global structure for simplicity.
144  */
145 int get_umc_info_mi300(void)
146 {
147         u32 temp;
148         int ret;
149         u8 i;
150
151         for (i = 0; i < NUM_BANK_BITS; i++) {
152                 ret = amd_smn_read(0, MI300_ADDR_HASH_BANK0 + (i * 4), &temp);
153                 if (ret)
154                         return ret;
155
156                 addr_hash.bank[i].xor_enable = FIELD_GET(ADDR_HASH_XOR_EN,  temp);
157                 addr_hash.bank[i].col_xor    = FIELD_GET(ADDR_HASH_COL_XOR, temp);
158                 addr_hash.bank[i].row_xor    = FIELD_GET(ADDR_HASH_ROW_XOR, temp);
159         }
160
161         ret = amd_smn_read(0, MI300_ADDR_HASH_PC, &temp);
162         if (ret)
163                 return ret;
164
165         addr_hash.pc.xor_enable = FIELD_GET(ADDR_HASH_XOR_EN,  temp);
166         addr_hash.pc.col_xor    = FIELD_GET(ADDR_HASH_COL_XOR, temp);
167         addr_hash.pc.row_xor    = FIELD_GET(ADDR_HASH_ROW_XOR, temp);
168
169         ret = amd_smn_read(0, MI300_ADDR_HASH_PC2, &temp);
170         if (ret)
171                 return ret;
172
173         addr_hash.bank_xor = FIELD_GET(ADDR_HASH_BANK_XOR, temp);
174
175         ret = amd_smn_read(0, MI300_ADDR_CFG, &temp);
176         if (ret)
177                 return ret;
178
179         bit_shifts.num_row_hi = FIELD_GET(ADDR_CFG_NUM_ROW_HI, temp);
180         bit_shifts.num_row_lo = 10 + FIELD_GET(ADDR_CFG_NUM_ROW_LO, temp);
181
182         ret = amd_smn_read(0, MI300_ADDR_SEL, &temp);
183         if (ret)
184                 return ret;
185
186         bit_shifts.bank[0] = 5 + FIELD_GET(ADDR_SEL_BANK0, temp);
187         bit_shifts.bank[1] = 5 + FIELD_GET(ADDR_SEL_BANK1, temp);
188         bit_shifts.bank[2] = 5 + FIELD_GET(ADDR_SEL_BANK2, temp);
189         bit_shifts.bank[3] = 5 + FIELD_GET(ADDR_SEL_BANK3, temp);
190         /* Use BankBit4 for the SID0 position. */
191         bit_shifts.sid[0]  = 5 + FIELD_GET(ADDR_SEL_BANK4, temp);
192         bit_shifts.row_lo  = 12 + FIELD_GET(ADDR_SEL_ROW_LO, temp);
193         bit_shifts.row_hi  = 24 + FIELD_GET(ADDR_SEL_ROW_HI, temp);
194
195         ret = amd_smn_read(0, MI300_COL_SEL_LO, &temp);
196         if (ret)
197                 return ret;
198
199         bit_shifts.col[0] = 2 + FIELD_GET(COL_SEL_LO_COL0, temp);
200         bit_shifts.col[1] = 2 + FIELD_GET(COL_SEL_LO_COL1, temp);
201         bit_shifts.col[2] = 2 + FIELD_GET(COL_SEL_LO_COL2, temp);
202         bit_shifts.col[3] = 2 + FIELD_GET(COL_SEL_LO_COL3, temp);
203         bit_shifts.col[4] = 2 + FIELD_GET(COL_SEL_LO_COL4, temp);
204
205         ret = amd_smn_read(0, MI300_ADDR_SEL_2, &temp);
206         if (ret)
207                 return ret;
208
209         /* Use BankBit5 for the SID1 position. */
210         bit_shifts.sid[1] = 5 + FIELD_GET(ADDR_SEL_2_BANK5, temp);
211         bit_shifts.pc     = 5 + FIELD_GET(ADDR_SEL_2_CHAN, temp);
212
213         return 0;
214 }
215
216 /*
217  * MI300 systems report a DRAM address in MCA_ADDR for DRAM ECC errors. This must
218  * be converted to the intermediate normalized address (NA) before translating to a
219  * system physical address.
220  *
221  * The DRAM address includes bank, row, and column. Also included are bits for
222  * pseudochannel (PC) and stack ID (SID).
223  *
224  * Abbreviations: (S)tack ID, (P)seudochannel, (R)ow, (B)ank, (C)olumn, (Z)ero
225  *
226  * The MCA address format is as follows:
227  *      MCA_ADDR[27:0] = {S[1:0], P[0], R[14:0], B[3:0], C[4:0], Z[0]}
228  *
229  * Additionally, the PC and Bank bits may be hashed. This must be accounted for before
230  * reconstructing the normalized address.
231  */
232 #define MI300_UMC_MCA_COL       GENMASK(5, 1)
233 #define MI300_UMC_MCA_BANK      GENMASK(9, 6)
234 #define MI300_UMC_MCA_ROW       GENMASK(24, 10)
235 #define MI300_UMC_MCA_PC        BIT(25)
236 #define MI300_UMC_MCA_SID       GENMASK(27, 26)
237
238 static unsigned long convert_dram_to_norm_addr_mi300(unsigned long addr)
239 {
240         u16 i, col, row, bank, pc, sid;
241         u32 temp;
242
243         col  = FIELD_GET(MI300_UMC_MCA_COL,  addr);
244         bank = FIELD_GET(MI300_UMC_MCA_BANK, addr);
245         row  = FIELD_GET(MI300_UMC_MCA_ROW,  addr);
246         pc   = FIELD_GET(MI300_UMC_MCA_PC,   addr);
247         sid  = FIELD_GET(MI300_UMC_MCA_SID,  addr);
248
249         /* Calculate hash for each Bank bit. */
250         for (i = 0; i < NUM_BANK_BITS; i++) {
251                 if (!addr_hash.bank[i].xor_enable)
252                         continue;
253
254                 temp  = bitwise_xor_bits(col & addr_hash.bank[i].col_xor);
255                 temp ^= bitwise_xor_bits(row & addr_hash.bank[i].row_xor);
256                 bank ^= temp << i;
257         }
258
259         /* Calculate hash for PC bit. */
260         if (addr_hash.pc.xor_enable) {
261                 temp  = bitwise_xor_bits(col  & addr_hash.pc.col_xor);
262                 temp ^= bitwise_xor_bits(row  & addr_hash.pc.row_xor);
263                 /* Bits SID[1:0] act as Bank[5:4] for PC hash, so apply them here. */
264                 temp ^= bitwise_xor_bits((bank | sid << NUM_BANK_BITS) & addr_hash.bank_xor);
265                 pc   ^= temp;
266         }
267
268         /* Reconstruct the normalized address starting with NA[4:0] = 0 */
269         addr  = 0;
270
271         /* Column bits */
272         for (i = 0; i < NUM_COL_BITS; i++) {
273                 temp  = (col >> i) & 0x1;
274                 addr |= temp << bit_shifts.col[i];
275         }
276
277         /* Bank bits */
278         for (i = 0; i < NUM_BANK_BITS; i++) {
279                 temp  = (bank >> i) & 0x1;
280                 addr |= temp << bit_shifts.bank[i];
281         }
282
283         /* Row lo bits */
284         for (i = 0; i < bit_shifts.num_row_lo; i++) {
285                 temp  = (row >> i) & 0x1;
286                 addr |= temp << (i + bit_shifts.row_lo);
287         }
288
289         /* Row hi bits */
290         for (i = 0; i < bit_shifts.num_row_hi; i++) {
291                 temp  = (row >> (i + bit_shifts.num_row_lo)) & 0x1;
292                 addr |= temp << (i + bit_shifts.row_hi);
293         }
294
295         /* PC bit */
296         addr |= pc << bit_shifts.pc;
297
298         /* SID bits */
299         for (i = 0; i < NUM_SID_BITS; i++) {
300                 temp  = (sid >> i) & 0x1;
301                 addr |= temp << bit_shifts.sid[i];
302         }
303
304         pr_debug("Addr=0x%016lx", addr);
305         pr_debug("Bank=%u Row=%u Column=%u PC=%u SID=%u", bank, row, col, pc, sid);
306
307         return addr;
308 }
309
310 /*
311  * When a DRAM ECC error occurs on MI300 systems, it is recommended to retire
312  * all memory within that DRAM row. This applies to the memory with a DRAM
313  * bank.
314  *
315  * To find the memory addresses, loop through permutations of the DRAM column
316  * bits and find the System Physical address of each. The column bits are used
317  * to calculate the intermediate Normalized address, so all permutations should
318  * be checked.
319  *
320  * See amd_atl::convert_dram_to_norm_addr_mi300() for MI300 address formats.
321  */
322 #define MI300_NUM_COL           BIT(HWEIGHT(MI300_UMC_MCA_COL))
323 static void retire_row_mi300(struct atl_err *a_err)
324 {
325         unsigned long addr;
326         struct page *p;
327         u8 col;
328
329         for (col = 0; col < MI300_NUM_COL; col++) {
330                 a_err->addr &= ~MI300_UMC_MCA_COL;
331                 a_err->addr |= FIELD_PREP(MI300_UMC_MCA_COL, col);
332
333                 addr = amd_convert_umc_mca_addr_to_sys_addr(a_err);
334                 if (IS_ERR_VALUE(addr))
335                         continue;
336
337                 addr = PHYS_PFN(addr);
338
339                 /*
340                  * Skip invalid or already poisoned pages to avoid unnecessary
341                  * error messages from memory_failure().
342                  */
343                 p = pfn_to_online_page(addr);
344                 if (!p)
345                         continue;
346
347                 if (PageHWPoison(p))
348                         continue;
349
350                 memory_failure(addr, 0);
351         }
352 }
353
354 void amd_retire_dram_row(struct atl_err *a_err)
355 {
356         if (df_cfg.rev == DF4p5 && df_cfg.flags.heterogeneous)
357                 return retire_row_mi300(a_err);
358 }
359 EXPORT_SYMBOL_GPL(amd_retire_dram_row);
360
361 static unsigned long get_addr(unsigned long addr)
362 {
363         if (df_cfg.rev == DF4p5 && df_cfg.flags.heterogeneous)
364                 return convert_dram_to_norm_addr_mi300(addr);
365
366         return addr;
367 }
368
369 #define MCA_IPID_INST_ID_HI     GENMASK_ULL(47, 44)
370 static u8 get_die_id(struct atl_err *err)
371 {
372         /*
373          * AMD Node ID is provided in MCA_IPID[InstanceIdHi], and this
374          * needs to be divided by 4 to get the internal Die ID.
375          */
376         if (df_cfg.rev == DF4p5 && df_cfg.flags.heterogeneous) {
377                 u8 node_id = FIELD_GET(MCA_IPID_INST_ID_HI, err->ipid);
378
379                 return node_id >> 2;
380         }
381
382         /*
383          * For CPUs, this is the AMD Node ID modulo the number
384          * of AMD Nodes per socket.
385          */
386         return topology_amd_node_id(err->cpu) % topology_amd_nodes_per_pkg();
387 }
388
389 #define UMC_CHANNEL_NUM GENMASK(31, 20)
390 static u8 get_coh_st_inst_id(struct atl_err *err)
391 {
392         if (df_cfg.rev == DF4p5 && df_cfg.flags.heterogeneous)
393                 return get_coh_st_inst_id_mi300(err);
394
395         return FIELD_GET(UMC_CHANNEL_NUM, err->ipid);
396 }
397
398 unsigned long convert_umc_mca_addr_to_sys_addr(struct atl_err *err)
399 {
400         u8 socket_id = topology_physical_package_id(err->cpu);
401         u8 coh_st_inst_id = get_coh_st_inst_id(err);
402         unsigned long addr = get_addr(err->addr);
403         u8 die_id = get_die_id(err);
404         unsigned long ret_addr;
405
406         pr_debug("socket_id=0x%x die_id=0x%x coh_st_inst_id=0x%x addr=0x%016lx",
407                  socket_id, die_id, coh_st_inst_id, addr);
408
409         ret_addr = prm_umc_norm_to_sys_addr(socket_id, err->ipid, addr);
410         if (!IS_ERR_VALUE(ret_addr))
411                 return ret_addr;
412
413         return norm_to_sys_addr(socket_id, die_id, coh_st_inst_id, addr);
414 }
This page took 0.050755 seconds and 4 git commands to generate.