Jonathan Zhang | 7919d61 | 2020-04-02 17:27:54 -0700 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
| 2 | |
| 3 | #include <assert.h> |
Jonathan Zhang | b7cf7d3 | 2020-04-02 20:03:48 -0700 | [diff] [blame] | 4 | #include <device/device.h> |
Jonathan Zhang | bea1980 | 2020-04-13 19:34:53 -0700 | [diff] [blame] | 5 | #include <device/pci.h> |
Jonathan Zhang | b7cf7d3 | 2020-04-02 20:03:48 -0700 | [diff] [blame] | 6 | #include <intelblocks/cpulib.h> |
Jonathan Zhang | bea1980 | 2020-04-13 19:34:53 -0700 | [diff] [blame] | 7 | #include <soc/pci_devs.h> |
Jonathan Zhang | 7919d61 | 2020-04-02 17:27:54 -0700 | [diff] [blame] | 8 | #include <soc/soc_util.h> |
Marc Jones | 18960ce | 2020-11-02 12:41:12 -0700 | [diff] [blame] | 9 | #include <soc/util.h> |
Johnny Lin | 3435f81 | 2023-01-17 10:43:19 +0800 | [diff] [blame] | 10 | #include <pc80/mc146818rtc.h> |
Jonathan Zhang | 7919d61 | 2020-04-02 17:27:54 -0700 | [diff] [blame] | 11 | |
Jonathan Zhang | 3172f98 | 2020-05-28 17:53:48 -0700 | [diff] [blame] | 12 | const struct SystemMemoryMapHob *get_system_memory_map(void) |
| 13 | { |
| 14 | size_t hob_size; |
| 15 | const uint8_t mem_hob_guid[16] = FSP_SYSTEM_MEMORYMAP_HOB_GUID; |
Johnny Lin | 91c8ccd | 2020-08-16 00:13:29 +0800 | [diff] [blame] | 16 | const struct SystemMemoryMapHob **memmap_addr; |
Jonathan Zhang | 3172f98 | 2020-05-28 17:53:48 -0700 | [diff] [blame] | 17 | |
Johnny Lin | 91c8ccd | 2020-08-16 00:13:29 +0800 | [diff] [blame] | 18 | memmap_addr = (const struct SystemMemoryMapHob **) |
| 19 | fsp_find_extension_hob_by_guid(mem_hob_guid, &hob_size); |
| 20 | /* hob_size is the size of the 8-byte address not the hob data */ |
Elyes Haouas | f1ba7d6 | 2022-09-13 10:03:44 +0200 | [diff] [blame] | 21 | assert(memmap_addr && hob_size != 0); |
Johnny Lin | 91c8ccd | 2020-08-16 00:13:29 +0800 | [diff] [blame] | 22 | /* assert the pointer to the hob is not NULL */ |
Elyes Haouas | f1ba7d6 | 2022-09-13 10:03:44 +0200 | [diff] [blame] | 23 | assert(*memmap_addr); |
Jonathan Zhang | 3172f98 | 2020-05-28 17:53:48 -0700 | [diff] [blame] | 24 | |
Johnny Lin | 91c8ccd | 2020-08-16 00:13:29 +0800 | [diff] [blame] | 25 | return *memmap_addr; |
Jonathan Zhang | 3172f98 | 2020-05-28 17:53:48 -0700 | [diff] [blame] | 26 | } |
| 27 | |
Arthur Heymans | 550f55e | 2022-08-24 14:44:26 +0200 | [diff] [blame] | 28 | bool stack_needs_resource_alloc(const STACK_RES *res) |
Jonathan Zhang | 7919d61 | 2020-04-02 17:27:54 -0700 | [diff] [blame] | 29 | { |
Arthur Heymans | 6408ada | 2020-11-12 17:33:00 +0100 | [diff] [blame] | 30 | return res->Personality == TYPE_UBOX_IIO; |
Jonathan Zhang | 7919d61 | 2020-04-02 17:27:54 -0700 | [diff] [blame] | 31 | } |
Jonathan Zhang | bea1980 | 2020-04-13 19:34:53 -0700 | [diff] [blame] | 32 | |
Arthur Heymans | 550f55e | 2022-08-24 14:44:26 +0200 | [diff] [blame] | 33 | bool is_pcie_iio_stack_res(const STACK_RES *res) |
| 34 | { |
| 35 | return stack_needs_resource_alloc(res); |
| 36 | } |
| 37 | |
Jonathan Zhang | ca520a7 | 2023-01-23 18:14:53 -0800 | [diff] [blame] | 38 | uint8_t get_stack_busno(const uint8_t stack) |
| 39 | { |
| 40 | if (stack >= MAX_IIO_STACK) { |
| 41 | printk(BIOS_ERR, "%s: Stack %u does not exist!\n", __func__, stack); |
| 42 | return 0; |
| 43 | } |
| 44 | const pci_devfn_t dev = PCI_DEV(UBOX_DECS_BUS, UBOX_DECS_DEV, UBOX_DECS_FUNC); |
| 45 | const uint16_t offset = stack / 4 ? UBOX_DECS_CPUBUSNO1_CSR : UBOX_DECS_CPUBUSNO_CSR; |
| 46 | return pci_io_read_config32(dev, offset) >> (8 * (stack % 4)) & 0xff; |
| 47 | } |
| 48 | |
Marc Jones | 5851f9d | 2020-11-02 15:30:10 -0700 | [diff] [blame] | 49 | uint32_t get_socket_stack_busno(uint32_t socket, uint32_t stack) |
Jonathan Zhang | bea1980 | 2020-04-13 19:34:53 -0700 | [diff] [blame] | 50 | { |
| 51 | const IIO_UDS *hob = get_iio_uds(); |
| 52 | |
Patrick Rudolph | ac02857 | 2023-07-14 17:44:33 +0200 | [diff] [blame] | 53 | assert(socket < CONFIG_MAX_SOCKET && stack < MAX_LOGIC_IIO_STACK); |
Jonathan Zhang | bea1980 | 2020-04-13 19:34:53 -0700 | [diff] [blame] | 54 | |
| 55 | return hob->PlatformData.IIO_resource[socket].StackRes[stack].BusBase; |
| 56 | } |
| 57 | |
Jonathan Zhang | ca520a7 | 2023-01-23 18:14:53 -0800 | [diff] [blame] | 58 | uint32_t get_socket_ubox_busno(uint32_t socket) |
| 59 | { |
| 60 | if (socket == 0) |
| 61 | return get_stack_busno(PCU_IIO_STACK); |
| 62 | |
| 63 | return get_socket_stack_busno(socket, PCU_IIO_STACK); |
| 64 | } |
| 65 | |
Marc Jones | 995a7e2 | 2020-10-28 17:08:54 -0600 | [diff] [blame] | 66 | /* |
| 67 | * EX: CPX-SP |
| 68 | * Ports Stack Stack(HOB) IioConfigIou |
| 69 | * ========================================== |
| 70 | * 0 CSTACK stack 0 IOU0 |
| 71 | * 1A..1D PSTACKZ stack 1 IOU1 |
| 72 | * 2A..2D PSTACK1 stack 2 IOU2 |
| 73 | * 3A..3D PSTACK2 stack 4 IOU3 |
| 74 | */ |
| 75 | int soc_get_stack_for_port(int port) |
| 76 | { |
| 77 | if (port == PORT_0) |
| 78 | return CSTACK; |
| 79 | else if (port >= PORT_1A && port <= PORT_1D) |
| 80 | return PSTACK0; |
| 81 | else if (port >= PORT_2A && port <= PORT_2D) |
| 82 | return PSTACK1; |
| 83 | else if (port >= PORT_3A && port <= PORT_3D) |
| 84 | return PSTACK2; |
| 85 | else |
| 86 | return -1; |
| 87 | } |
Arthur Heymans | a1cc557 | 2020-11-06 12:53:33 +0100 | [diff] [blame] | 88 | |
| 89 | uint8_t soc_get_iio_ioapicid(int socket, int stack) |
| 90 | { |
| 91 | uint8_t ioapic_id = socket ? 0xf : 0x9; |
| 92 | switch (stack) { |
| 93 | case CSTACK: |
| 94 | break; |
| 95 | case PSTACK0: |
| 96 | ioapic_id += 1; |
| 97 | break; |
| 98 | case PSTACK1: |
| 99 | ioapic_id += 2; |
| 100 | break; |
| 101 | case PSTACK2: |
| 102 | ioapic_id += 3; |
| 103 | break; |
| 104 | default: |
| 105 | return 0xff; |
| 106 | } |
| 107 | return ioapic_id; |
| 108 | } |
Johnny Lin | 3435f81 | 2023-01-17 10:43:19 +0800 | [diff] [blame] | 109 | |
| 110 | void soc_set_mrc_cold_boot_flag(bool cold_boot_required) |
| 111 | { |
| 112 | uint8_t mrc_status = cmos_read(CMOS_OFFSET_MRC_STATUS); |
| 113 | uint8_t new_mrc_status = (mrc_status & 0xfe) | cold_boot_required; |
| 114 | printk(BIOS_SPEW, "MRC status: 0x%02x want 0x%02x\n", mrc_status, new_mrc_status); |
| 115 | if (new_mrc_status != mrc_status) { |
| 116 | cmos_write(new_mrc_status, CMOS_OFFSET_MRC_STATUS); |
| 117 | } |
| 118 | } |