Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
| 2 | |
Elyes Haouas | 17a9849 | 2022-12-18 09:28:31 +0100 | [diff] [blame] | 3 | #include <console/console.h> |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 4 | #include <delay.h> |
Elyes Haouas | 17a9849 | 2022-12-18 09:28:31 +0100 | [diff] [blame] | 5 | #include <device/mmio.h> |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 6 | #include <intelblocks/crashlog.h> |
Elyes Haouas | 17a9849 | 2022-12-18 09:28:31 +0100 | [diff] [blame] | 7 | #include <intelblocks/pmc_ipc.h> |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 8 | #include <string.h> |
| 9 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 10 | int __weak cl_get_cpu_record_size(void) |
| 11 | { |
| 12 | return 0; |
| 13 | } |
| 14 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 15 | int __weak cl_get_pmc_record_size(void) |
| 16 | { |
| 17 | return 0; |
| 18 | } |
| 19 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 20 | u32 __weak cl_get_cpu_bar_addr(void) |
| 21 | { |
| 22 | return 0; |
| 23 | } |
| 24 | |
Pratikkumar Prajapati | e4893d6 | 2023-05-30 12:30:36 -0700 | [diff] [blame] | 25 | int __weak cl_get_ioe_record_size(void) |
| 26 | { |
| 27 | return 0; |
| 28 | } |
| 29 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 30 | u32 __weak cl_get_cpu_tmp_bar(void) |
| 31 | { |
| 32 | return 0; |
| 33 | } |
| 34 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 35 | u32 __weak cl_get_cpu_mb_int_addr(void) |
| 36 | { |
| 37 | return 0; |
| 38 | } |
| 39 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 40 | int __weak cl_get_total_data_size(void) |
| 41 | { |
| 42 | return cl_get_cpu_record_size() + cl_get_pmc_record_size(); |
| 43 | } |
| 44 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 45 | bool __weak cl_pmc_sram_has_mmio_access(void) |
| 46 | { |
| 47 | return false; |
| 48 | } |
| 49 | |
Pratikkumar Prajapati | e4893d6 | 2023-05-30 12:30:36 -0700 | [diff] [blame] | 50 | bool __weak cl_ioe_sram_has_mmio_access(void) |
| 51 | { |
| 52 | return false; |
| 53 | } |
| 54 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 55 | bool __weak cpu_crashlog_support(void) |
| 56 | { |
| 57 | return false; |
| 58 | } |
| 59 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 60 | bool __weak pmc_crashlog_support(void) |
| 61 | { |
| 62 | return false; |
| 63 | } |
| 64 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 65 | bool __weak cl_cpu_data_present(void) |
| 66 | { |
| 67 | return false; |
| 68 | } |
| 69 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 70 | bool __weak cl_pmc_data_present(void) |
| 71 | { |
| 72 | return false; |
| 73 | } |
| 74 | |
Pratikkumar Prajapati | e4893d6 | 2023-05-30 12:30:36 -0700 | [diff] [blame] | 75 | bool __weak cl_ioe_data_present(void) |
| 76 | { |
| 77 | return false; |
| 78 | } |
| 79 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 80 | __weak void reset_discovery_buffers(void) {} |
| 81 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 82 | __weak void update_new_pmc_crashlog_size(u32 *pmc_crash_size) {} |
| 83 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 84 | __weak void update_new_cpu_crashlog_size(u32 *cpu_crash_size) {} |
| 85 | |
Pratikkumar Prajapati | e4893d6 | 2023-05-30 12:30:36 -0700 | [diff] [blame] | 86 | __weak void update_new_ioe_crashlog_size(u32 *ioe_crash_size) {} |
| 87 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 88 | pmc_ipc_discovery_buf_t __weak cl_get_pmc_discovery_buf(void) |
| 89 | { |
| 90 | pmc_ipc_discovery_buf_t discov_buf; |
| 91 | memset(&discov_buf, 0, sizeof(pmc_ipc_discovery_buf_t)); |
| 92 | return discov_buf; |
| 93 | } |
| 94 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 95 | pmc_crashlog_desc_table_t __weak cl_get_pmc_descriptor_table(void) |
| 96 | { |
| 97 | pmc_crashlog_desc_table_t desc_tab; |
| 98 | memset(&desc_tab, 0, sizeof(pmc_crashlog_desc_table_t)); |
| 99 | return desc_tab; |
| 100 | } |
| 101 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 102 | cpu_crashlog_discovery_table_t __weak cl_get_cpu_discovery_table(void) |
| 103 | { |
| 104 | cpu_crashlog_discovery_table_t cpu_disc_tab; |
| 105 | memset(&cpu_disc_tab, 0, sizeof(cpu_crashlog_discovery_table_t)); |
| 106 | return cpu_disc_tab; |
| 107 | } |
| 108 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 109 | int cpu_cl_poll_mailbox_ready(u32 cl_mailbox_addr) |
| 110 | { |
| 111 | cpu_crashlog_mailbox_t cl_mailbox_interface; |
| 112 | u16 stall_cnt = 0; |
| 113 | |
| 114 | do { |
| 115 | cl_mailbox_interface.data = read32((u32 *)cl_mailbox_addr); |
Pratikkumar Prajapati | 5849f5b | 2023-08-15 11:45:15 -0700 | [diff] [blame] | 116 | udelay(CPU_CRASHLOG_WAIT_STALL); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 117 | stall_cnt++; |
| 118 | } while ((cl_mailbox_interface.fields.busy == 1) |
Pratikkumar Prajapati | 5849f5b | 2023-08-15 11:45:15 -0700 | [diff] [blame] | 119 | && stall_cnt < CPU_CRASHLOG_WAIT_TIMEOUT); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 120 | |
| 121 | if ((cl_mailbox_interface.fields.busy == 1) |
Pratikkumar Prajapati | 5849f5b | 2023-08-15 11:45:15 -0700 | [diff] [blame] | 122 | && (stall_cnt >= CPU_CRASHLOG_WAIT_TIMEOUT)) { |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 123 | printk(BIOS_ERR, "CPU crashlog mailbox timed out.\n"); |
| 124 | return 0; |
| 125 | } |
| 126 | |
| 127 | return 1; |
| 128 | } |
| 129 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 130 | int cpu_cl_mailbox_cmd(u8 cmd, u8 param) |
| 131 | { |
| 132 | cpu_crashlog_mailbox_t cl_mailbox_intf; |
| 133 | u32 cl_base_addr; |
| 134 | |
| 135 | memset(&cl_mailbox_intf, 0, sizeof(cpu_crashlog_mailbox_t)); |
| 136 | |
| 137 | cl_base_addr = cl_get_cpu_bar_addr(); |
| 138 | |
| 139 | cl_mailbox_intf.fields.command = cmd; |
| 140 | cl_mailbox_intf.fields.param = param; |
| 141 | cl_mailbox_intf.fields.busy = 1; |
| 142 | |
| 143 | write32((u32 *)(cl_base_addr + cl_get_cpu_mb_int_addr()), |
| 144 | cl_mailbox_intf.data); |
| 145 | |
| 146 | cpu_cl_poll_mailbox_ready(cl_base_addr + cl_get_cpu_mb_int_addr()); |
| 147 | |
| 148 | return 1; |
| 149 | } |
| 150 | |
Pratikkumar Prajapati | 42258e3 | 2023-08-15 11:53:17 -0700 | [diff] [blame] | 151 | int __weak cpu_cl_clear_data(void) |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 152 | { |
| 153 | return cpu_cl_mailbox_cmd(CPU_CRASHLOG_CMD_CLEAR, 0); |
| 154 | } |
| 155 | |
Pratikkumar Prajapati | 0f56f83 | 2023-08-15 11:56:29 -0700 | [diff] [blame] | 156 | void __weak cpu_cl_rearm(void) |
| 157 | { |
| 158 | /* empty implementation */ |
| 159 | } |
| 160 | |
| 161 | void __weak cpu_cl_cleanup(void) |
| 162 | { |
| 163 | /* empty implementation */ |
| 164 | } |
| 165 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 166 | int pmc_cl_gen_descriptor_table(u32 desc_table_addr, |
| 167 | pmc_crashlog_desc_table_t *descriptor_table) |
| 168 | { |
| 169 | int total_data_size = 0; |
| 170 | descriptor_table->numb_regions = read32((u32 *)desc_table_addr); |
| 171 | printk(BIOS_DEBUG, "CL PMC desc table: numb of regions is 0x%x at addr 0x%x\n", |
| 172 | descriptor_table->numb_regions, desc_table_addr); |
| 173 | for (int i = 0; i < descriptor_table->numb_regions; i++) { |
Bora Guvendik | adb5253 | 2023-01-17 12:09:56 -0800 | [diff] [blame] | 174 | if (i >= ARRAY_SIZE(descriptor_table->regions)) { |
| 175 | printk(BIOS_ERR, "Maximum number of PMC crashLog descriptor table exceeded (%u/%zu)\n", |
| 176 | descriptor_table->numb_regions, |
| 177 | ARRAY_SIZE(descriptor_table->regions)); |
| 178 | break; |
| 179 | } |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 180 | desc_table_addr += 4; |
| 181 | descriptor_table->regions[i].data = read32((u32 *)(desc_table_addr)); |
| 182 | total_data_size += descriptor_table->regions[i].bits.size * sizeof(u32); |
| 183 | printk(BIOS_DEBUG, "CL PMC desc table: region 0x%x has size 0x%x at offset 0x%x\n", |
| 184 | i, descriptor_table->regions[i].bits.size, |
| 185 | descriptor_table->regions[i].bits.offset); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 186 | } |
| 187 | return total_data_size; |
| 188 | } |
| 189 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 190 | bool __weak pmc_cl_discovery(void) |
| 191 | { |
| 192 | return false; |
| 193 | } |
| 194 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 195 | bool __weak cpu_cl_discovery(void) |
| 196 | { |
| 197 | return false; |
| 198 | } |
| 199 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 200 | int cl_pmc_re_arm_after_reset(void) |
| 201 | { |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 202 | const struct pmc_ipc_buffer req = { 0 }; |
| 203 | struct pmc_ipc_buffer res; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 204 | uint32_t cmd_reg; |
| 205 | int r; |
| 206 | |
| 207 | cmd_reg = pmc_make_ipc_cmd(PMC_IPC_CMD_CRASHLOG, |
| 208 | PMC_IPC_CMD_ID_CRASHLOG_RE_ARM_ON_RESET, |
| 209 | PMC_IPC_CMD_SIZE_SHIFT); |
| 210 | |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 211 | r = pmc_send_ipc_cmd(cmd_reg, &req, &res); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 212 | |
| 213 | if (r < 0) { |
| 214 | printk(BIOS_ERR, "pmc_send_ipc_cmd failed in %s\n", __func__); |
| 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | return r; |
| 219 | } |
| 220 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 221 | /* Sends PMC IPC to clear CrashLog from PMC SSRAM area */ |
| 222 | int cl_pmc_clear(void) |
| 223 | { |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 224 | const struct pmc_ipc_buffer req = { 0 }; |
| 225 | struct pmc_ipc_buffer res; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 226 | uint32_t cmd_reg; |
| 227 | int r; |
| 228 | |
| 229 | cmd_reg = pmc_make_ipc_cmd(PMC_IPC_CMD_CRASHLOG, |
| 230 | PMC_IPC_CMD_ID_CRASHLOG_ERASE, |
| 231 | PMC_IPC_CMD_SIZE_SHIFT); |
| 232 | |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 233 | r = pmc_send_ipc_cmd(cmd_reg, &req, &res); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 234 | |
| 235 | if (r < 0) { |
| 236 | printk(BIOS_ERR, "pmc_send_ipc_cmd failed in %s\n", __func__); |
| 237 | return 0; |
| 238 | } |
| 239 | |
| 240 | return r; |
| 241 | } |
| 242 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 243 | /* |
| 244 | * Sends PMC IPC to populate CrashLog on all reboot. |
| 245 | * The SSRAM area will be cleared on G3 by PMC automatically |
| 246 | */ |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 247 | int cl_pmc_en_gen_on_all_reboot(void) |
| 248 | { |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 249 | const struct pmc_ipc_buffer req = { 0 }; |
| 250 | struct pmc_ipc_buffer res; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 251 | uint32_t cmd_reg; |
| 252 | int r; |
| 253 | |
| 254 | cmd_reg = pmc_make_ipc_cmd(PMC_IPC_CMD_CRASHLOG, |
| 255 | PMC_IPC_CMD_ID_CRASHLOG_ON_RESET, |
| 256 | PMC_IPC_CMD_SIZE_SHIFT); |
| 257 | |
John Zhao | 8557613 | 2021-07-06 10:51:16 -0700 | [diff] [blame] | 258 | r = pmc_send_ipc_cmd(cmd_reg, &req, &res); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 259 | |
| 260 | if (r < 0) { |
| 261 | printk(BIOS_ERR, "pmc_send_ipc_cmd failed in %s\n", __func__); |
| 262 | return 0; |
| 263 | } |
| 264 | |
| 265 | return r; |
| 266 | } |
| 267 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 268 | bool discover_crashlog(void) |
| 269 | { |
| 270 | bool cpu_cl_discovered = false, pmc_cl_discovered = false; |
| 271 | |
| 272 | reset_discovery_buffers(); |
| 273 | |
| 274 | /* PCH crashLog discovery */ |
| 275 | pmc_cl_discovered = pmc_cl_discovery(); |
| 276 | |
| 277 | /* CPU crashLog discovery */ |
| 278 | cpu_cl_discovered = cpu_cl_discovery(); |
| 279 | |
| 280 | return (cpu_cl_discovered || pmc_cl_discovered); |
| 281 | } |
| 282 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 283 | bool cl_copy_data_from_sram(u32 src_bar, |
| 284 | u32 offset, |
| 285 | u32 size, |
| 286 | u32 *dest_addr, |
| 287 | u32 buffer_index, |
| 288 | bool pmc_sram) |
| 289 | { |
| 290 | if (src_bar == 0) { |
| 291 | printk(BIOS_ERR, "Invalid bar 0x%x and offset 0x%x for %s\n", |
| 292 | src_bar, offset, __func__); |
| 293 | return false; |
| 294 | } |
| 295 | |
| 296 | u32 src_addr = src_bar + offset; |
| 297 | |
| 298 | u32 data = read32((u32 *)src_addr); |
Pratikkumar Prajapati | 5f3b654 | 2023-05-30 11:28:21 -0700 | [diff] [blame] | 299 | |
| 300 | /* First 32bits of the record must not be 0xdeadbeef */ |
| 301 | if (data == INVALID_CRASHLOG_RECORD) { |
| 302 | printk(BIOS_DEBUG, "Invalid data 0x%x at offset 0x%x from addr 0x%x\n", |
| 303 | data, offset, src_bar); |
| 304 | return false; |
| 305 | } |
| 306 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 307 | /* PMC: copy if 1st DWORD in buffer is not zero and its 31st bit is not set */ |
| 308 | if (pmc_sram && !(data && !(data & BIT(31)))) { |
| 309 | printk(BIOS_DEBUG, "Invalid data 0x%x at offset 0x%x from addr 0x%x" |
| 310 | " of PMC SRAM.\n", data, offset, src_bar); |
| 311 | return false; |
| 312 | } |
| 313 | /*CPU: don't copy if 1st DWORD in first buffer is zero */ |
| 314 | if (!pmc_sram && !data && (buffer_index == 0)) { |
| 315 | printk(BIOS_DEBUG, "Invalid data 0x%x at offset 0x%x from addr 0x%x" |
| 316 | " of telemetry SRAM.\n", data, offset, src_bar); |
| 317 | return false; |
| 318 | } |
| 319 | |
| 320 | u32 copied = 0; |
| 321 | while (copied < size) { |
| 322 | /* DW by DW copy: byte access to PMC SRAM not allowed */ |
| 323 | *dest_addr = read32((u32 *)src_addr); |
| 324 | dest_addr++; |
| 325 | src_addr += 4; |
| 326 | copied++; |
| 327 | } |
| 328 | return true; |
| 329 | } |
| 330 | |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 331 | cl_node_t *malloc_cl_node(size_t len) |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 332 | { |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 333 | cl_node_t *node = malloc(sizeof(cl_node_t)); |
| 334 | if (!node) |
| 335 | return NULL; |
| 336 | |
| 337 | node->data = malloc(len * sizeof(u32)); |
| 338 | if (!(node->data)) |
| 339 | return NULL; |
| 340 | |
| 341 | node->size = len * sizeof(u32); |
| 342 | node->next = NULL; |
| 343 | |
| 344 | return node; |
| 345 | } |
| 346 | |
| 347 | void free_cl_node(cl_node_t *node) |
| 348 | { |
| 349 | if (!node) |
| 350 | return; |
| 351 | if (node->data) |
| 352 | free(node->data); |
| 353 | free(node); |
| 354 | } |
| 355 | |
| 356 | void __weak cl_get_pmc_sram_data(cl_node_t *head) |
| 357 | { |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 358 | u32 tmp_bar_addr = cl_get_cpu_tmp_bar(); |
| 359 | u32 pmc_crashLog_size = cl_get_pmc_record_size(); |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 360 | cl_node_t *cl_cur = head; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 361 | |
Subrata Banik | b0ddae6 | 2023-03-28 17:44:20 +0530 | [diff] [blame] | 362 | if (!cl_pmc_sram_has_mmio_access() || !tmp_bar_addr) |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 363 | return; |
| 364 | |
| 365 | pmc_ipc_discovery_buf_t discovery_buf = cl_get_pmc_discovery_buf(); |
| 366 | |
| 367 | if (discovery_buf.bits.supported != 1) { |
| 368 | printk(BIOS_DEBUG, "PCH crashlog feature not supported.\n"); |
| 369 | goto pmc_send_re_arm_after_reset; |
| 370 | } |
| 371 | |
| 372 | /* Get the size of data to copy */ |
| 373 | if (discovery_buf.bits.discov_mechanism == 1) { |
| 374 | if (discovery_buf.bits.base_offset & BIT(31)) { |
| 375 | printk(BIOS_DEBUG, "PCH discovery to be used is disabled.\n"); |
| 376 | goto pmc_send_re_arm_after_reset; |
| 377 | } |
| 378 | printk(BIOS_DEBUG, "PMC crashLog size in discovery mode : 0x%X\n", |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 379 | pmc_crashLog_size); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 380 | } else { |
| 381 | if (discovery_buf.bits.dis) { |
| 382 | printk(BIOS_DEBUG, "PCH crashlog is disabled in legacy mode.\n"); |
| 383 | return; |
| 384 | } |
| 385 | pmc_crashLog_size = (discovery_buf.bits.size != 0) ? |
| 386 | discovery_buf.bits.size : 0xC00; |
| 387 | printk(BIOS_DEBUG, "PMC crashLog size in legacy mode : 0x%X\n", |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 388 | pmc_crashLog_size); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 389 | } |
| 390 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 391 | bool pmc_sram = true; |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 392 | pmc_crashlog_desc_table_t descriptor_table = cl_get_pmc_descriptor_table(); |
| 393 | |
| 394 | /* goto tail node */ |
| 395 | while (cl_cur && cl_cur->next) { |
| 396 | cl_cur = cl_cur->next; |
| 397 | } |
| 398 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 399 | if (discovery_buf.bits.discov_mechanism == 1) { |
| 400 | for (int i = 0; i < descriptor_table.numb_regions; i++) { |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 401 | cl_node_t *cl_node = malloc_cl_node(descriptor_table.regions[i].bits.size); |
| 402 | if (!cl_node) { |
| 403 | printk(BIOS_DEBUG, "failed to allocate cl_node [region = %d]\n", i); |
| 404 | goto pmc_send_re_arm_after_reset; |
| 405 | } |
| 406 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 407 | if (cl_copy_data_from_sram(tmp_bar_addr, |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 408 | descriptor_table.regions[i].bits.offset, |
| 409 | descriptor_table.regions[i].bits.size, |
| 410 | cl_node->data, |
| 411 | i, |
| 412 | pmc_sram)) { |
| 413 | cl_cur->next = cl_node; |
| 414 | cl_cur = cl_cur->next; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 415 | } else { |
| 416 | pmc_crashLog_size -= descriptor_table.regions[i].bits.size * |
| 417 | sizeof(u32); |
| 418 | printk(BIOS_DEBUG, "discover mode PMC crashlog size adjusted" |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 419 | " to: 0x%x\n", pmc_crashLog_size); |
| 420 | /* free cl_node */ |
| 421 | free_cl_node(cl_node); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 422 | } |
| 423 | } |
| 424 | } else { |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 425 | cl_node_t *cl_node = malloc_cl_node(discovery_buf.bits.size); |
| 426 | if (!cl_node) { |
| 427 | printk(BIOS_DEBUG, "failed to allocate cl_node\n"); |
| 428 | goto pmc_send_re_arm_after_reset; |
| 429 | } |
| 430 | |
| 431 | if (cl_copy_data_from_sram(tmp_bar_addr, |
| 432 | discovery_buf.bits.base_offset, |
| 433 | discovery_buf.bits.size, |
| 434 | cl_node->data, |
| 435 | 0, |
| 436 | pmc_sram)) { |
| 437 | cl_cur->next = cl_node; |
| 438 | cl_cur = cl_cur->next; |
| 439 | } else { |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 440 | pmc_crashLog_size -= discovery_buf.bits.size * sizeof(u32); |
| 441 | printk(BIOS_DEBUG, "legacy mode PMC crashlog size adjusted to: 0x%x\n", |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 442 | pmc_crashLog_size); |
| 443 | /* free cl_node */ |
| 444 | free_cl_node(cl_node); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 445 | } |
| 446 | } |
| 447 | |
| 448 | update_new_pmc_crashlog_size(&pmc_crashLog_size); |
| 449 | |
| 450 | pmc_send_re_arm_after_reset: |
| 451 | /* when bit 7 of discov cmd resp is set -> bit 2 of size field */ |
| 452 | if (discovery_buf.bits.size & BIT(2)) |
| 453 | cl_pmc_re_arm_after_reset(); |
| 454 | |
| 455 | /* Clear the SSRAM region after copying the error log */ |
| 456 | cl_pmc_clear(); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 457 | } |
| 458 | |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 459 | void cl_get_cpu_sram_data(cl_node_t *head) |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 460 | { |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 461 | cl_node_t *cl_cur = head; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 462 | u32 m_cpu_crashLog_size = cl_get_cpu_record_size(); |
| 463 | cpu_crashlog_discovery_table_t cpu_cl_disc_tab = cl_get_cpu_discovery_table(); |
| 464 | |
| 465 | if (m_cpu_crashLog_size < 1) { |
| 466 | printk(BIOS_DEBUG, "%s: no data to collect.\n", __func__); |
| 467 | return; |
| 468 | } |
| 469 | |
| 470 | printk(BIOS_DEBUG, "CPU crash data size: 0x%X bytes in 0x%X region(s).\n", |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 471 | m_cpu_crashLog_size, cpu_cl_disc_tab.header.fields.count); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 472 | |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 473 | /* goto tail node */ |
| 474 | while (cl_cur && cl_cur->next) { |
| 475 | cl_cur = cl_cur->next; |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 476 | } |
| 477 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 478 | for (int i = 0 ; i < cpu_cl_disc_tab.header.fields.count ; i++) { |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 479 | u32 cpu_bar_addr = cl_get_cpu_bar_addr(); |
| 480 | bool pmc_sram = false; |
| 481 | |
| 482 | if (!cpu_cl_disc_tab.buffers[i].fields.size) { |
| 483 | continue; |
| 484 | } |
| 485 | |
| 486 | cl_node_t *cl_node = malloc_cl_node(cpu_cl_disc_tab.buffers[i].fields.size); |
| 487 | if (!cl_node) { |
| 488 | printk(BIOS_DEBUG, "failed to allocate cl_node [buffer = %d]\n", i); |
| 489 | return; |
| 490 | } |
| 491 | |
| 492 | if (cl_copy_data_from_sram(cpu_bar_addr, |
| 493 | cpu_cl_disc_tab.buffers[i].fields.offset, |
| 494 | cpu_cl_disc_tab.buffers[i].fields.size, |
| 495 | cl_node->data, |
| 496 | i, |
| 497 | pmc_sram)) { |
| 498 | cl_cur->next = cl_node; |
| 499 | cl_cur = cl_cur->next; |
| 500 | |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 501 | } else { |
| 502 | m_cpu_crashLog_size -= cpu_cl_disc_tab.buffers[i].fields.size |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 503 | * sizeof(u32); |
| 504 | free_cl_node(cl_node); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 505 | /* for CPU skip all buffers if the 1st one is not valid */ |
| 506 | if (i == 0) { |
| 507 | m_cpu_crashLog_size = 0; |
| 508 | break; |
| 509 | } |
| 510 | } |
| 511 | } |
| 512 | |
| 513 | update_new_cpu_crashlog_size(&m_cpu_crashLog_size); |
| 514 | |
| 515 | /* clear telemetry SRAM region */ |
| 516 | cpu_cl_clear_data(); |
Pratikkumar Prajapati | 0f56f83 | 2023-08-15 11:56:29 -0700 | [diff] [blame] | 517 | /* perform any SOC specific cleanup */ |
| 518 | cpu_cl_cleanup(); |
| 519 | /* rearm crashlog */ |
| 520 | cpu_cl_rearm(); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 521 | } |
| 522 | |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 523 | void collect_pmc_and_cpu_crashlog_from_srams(cl_node_t *head) |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 524 | { |
| 525 | if (pmc_crashlog_support() && cl_pmc_data_present() |
| 526 | && (cl_get_pmc_record_size() > 0)) { |
Curtis Chen | b89c798 | 2021-12-07 18:01:57 +0800 | [diff] [blame] | 527 | if (CONFIG(SOC_INTEL_CRASHLOG_ON_RESET)) { |
| 528 | cl_pmc_en_gen_on_all_reboot(); |
| 529 | printk(BIOS_DEBUG, "Crashlog collection enabled on every reboot.\n"); |
| 530 | } |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 531 | cl_get_pmc_sram_data(head); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 532 | } else { |
| 533 | printk(BIOS_DEBUG, "Skipping PMC crashLog collection. Data not present.\n"); |
| 534 | } |
| 535 | |
| 536 | printk(BIOS_DEBUG, "m_cpu_crashLog_size : 0x%X bytes\n", cl_get_cpu_record_size()); |
| 537 | |
| 538 | if (cpu_crashlog_support() && cl_cpu_data_present() |
| 539 | && (cl_get_cpu_record_size() > 0)) { |
| 540 | printk(BIOS_DEBUG, "CPU crashLog present.\n"); |
Pratikkumar Prajapati | 4db9213 | 2023-10-05 13:12:12 -0700 | [diff] [blame] | 541 | cl_get_cpu_sram_data(head); |
Francois Toguo | 15cbc3b | 2021-01-26 10:27:49 -0800 | [diff] [blame] | 542 | } else { |
| 543 | printk(BIOS_DEBUG, "Skipping CPU crashLog collection. Data not present.\n"); |
| 544 | } |
| 545 | } |