Angel Pons | 3bd1e3d | 2020-04-05 15:47:17 +0200 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0-only */ |
| 2 | /* This file is part of the coreboot project. */ |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 3 | |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 4 | #include <device/pci_ids.h> |
Patrick Rudolph | e56189c | 2018-04-18 10:11:59 +0200 | [diff] [blame] | 5 | #include <device/pci_ops.h> |
Rizwan Qureshi | 1222a73 | 2016-08-23 14:31:23 +0530 | [diff] [blame] | 6 | #include <fsp/api.h> |
| 7 | #include <soc/ramstage.h> |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 8 | #include <soc/vr_config.h> |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 9 | #include <console/console.h> |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 10 | #include <intelblocks/cpulib.h> |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 11 | |
Michael Niewöhner | e4c784b | 2020-03-31 00:28:57 +0200 | [diff] [blame] | 12 | /* Default values for domain configuration. */ |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 13 | static const struct vr_config default_configs[NUM_VR_DOMAINS] = { |
| 14 | [VR_SYSTEM_AGENT] = { |
| 15 | .vr_config_enable = 1, |
| 16 | .psi1threshold = VR_CFG_AMP(20), |
| 17 | .psi2threshold = VR_CFG_AMP(4), |
| 18 | .psi3threshold = VR_CFG_AMP(1), |
Michael Niewöhner | e4c784b | 2020-03-31 00:28:57 +0200 | [diff] [blame] | 19 | .psi3enable = 1, |
| 20 | .psi4enable = 1, |
Patrick Rudolph | b824f7d | 2019-12-09 08:56:39 +0100 | [diff] [blame] | 21 | .imon_slope = 0, |
| 22 | .imon_offset = 0, |
| 23 | .icc_max = 0, |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 24 | .voltage_limit = 1520, |
| 25 | }, |
| 26 | [VR_IA_CORE] = { |
| 27 | .vr_config_enable = 1, |
| 28 | .psi1threshold = VR_CFG_AMP(20), |
| 29 | .psi2threshold = VR_CFG_AMP(5), |
| 30 | .psi3threshold = VR_CFG_AMP(1), |
Michael Niewöhner | e4c784b | 2020-03-31 00:28:57 +0200 | [diff] [blame] | 31 | .psi3enable = 1, |
| 32 | .psi4enable = 1, |
Patrick Rudolph | b824f7d | 2019-12-09 08:56:39 +0100 | [diff] [blame] | 33 | .imon_slope = 0, |
| 34 | .imon_offset = 0, |
| 35 | .icc_max = 0, |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 36 | .voltage_limit = 1520, |
| 37 | }, |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 38 | [VR_GT_UNSLICED] = { |
| 39 | .vr_config_enable = 1, |
| 40 | .psi1threshold = VR_CFG_AMP(20), |
| 41 | .psi2threshold = VR_CFG_AMP(5), |
| 42 | .psi3threshold = VR_CFG_AMP(1), |
Michael Niewöhner | e4c784b | 2020-03-31 00:28:57 +0200 | [diff] [blame] | 43 | .psi3enable = 1, |
| 44 | .psi4enable = 1, |
Patrick Rudolph | b824f7d | 2019-12-09 08:56:39 +0100 | [diff] [blame] | 45 | .imon_slope = 0, |
| 46 | .imon_offset = 0, |
| 47 | .icc_max = 0, |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 48 | .voltage_limit = 1520, |
| 49 | }, |
| 50 | [VR_GT_SLICED] = { |
| 51 | .vr_config_enable = 1, |
| 52 | .psi1threshold = VR_CFG_AMP(20), |
| 53 | .psi2threshold = VR_CFG_AMP(5), |
| 54 | .psi3threshold = VR_CFG_AMP(1), |
Michael Niewöhner | e4c784b | 2020-03-31 00:28:57 +0200 | [diff] [blame] | 55 | .psi3enable = 1, |
| 56 | .psi4enable = 1, |
Patrick Rudolph | b824f7d | 2019-12-09 08:56:39 +0100 | [diff] [blame] | 57 | .imon_slope = 0, |
| 58 | .imon_offset = 0, |
| 59 | .icc_max = 0, |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 60 | .voltage_limit = 1520, |
| 61 | }, |
| 62 | }; |
| 63 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 64 | static uint16_t get_sku_icc_max(int domain) |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 65 | { |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 66 | const uint16_t tdp = cpu_get_power_max(); |
| 67 | |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 68 | static uint16_t mch_id = 0, igd_id = 0; |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 69 | if (!mch_id) { |
| 70 | struct device *dev = pcidev_path_on_root(SA_DEVFN_ROOT); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 71 | mch_id = dev ? pci_read_config16(dev, PCI_DEVICE_ID) : 0xffff; |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 72 | } |
| 73 | if (!igd_id) { |
| 74 | struct device *dev = pcidev_path_on_root(SA_DEVFN_IGD); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 75 | igd_id = dev ? pci_read_config16(dev, PCI_DEVICE_ID) : 0xffff; |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 76 | } |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 77 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 78 | /* |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 79 | * Iccmax table from Doc #559100 Section 7.2 DC Specifications, the |
| 80 | * Iccmax is the same among KBL-Y but KBL-U/R. |
| 81 | * Addendum for AML-Y #594883, IccMax for IA core is 28A. |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 82 | * KBL-S #335195, KBL-H #335190, SKL-S #332687, SKL-H #332986, |
| 83 | * SKL-U/Y #332990 |
| 84 | * |
| 85 | * Platform Segment SA IA GT (GT/GTx) |
| 86 | * --------------------------------------------------------------------- |
| 87 | * KBL/SKL-S (95W) quad 11.1 100 45 |
| 88 | * SKL-S (80W) quad 11.1 82 45 |
| 89 | * KBL/SKL-S (65W) quad 11.1 79 45 |
| 90 | * SKL-S (45W) quad 11.1 70 0 |
| 91 | * KBL/SKL-S (35W) quad 11.1 66 35 |
| 92 | * SKL-S (25W) quad 11.1 55 35 |
| 93 | * |
| 94 | * KBL/SKL-S (54W) dual 11.1 58 48 |
| 95 | * KBL/SKL-S (51W) dual 11.1 45 48 |
| 96 | * KBL/SKL-S (35W) dual 11.1 40 48 |
| 97 | * |
| 98 | * SKL-H + OPC (65W) GT4 quad 8 74 105/24 |
| 99 | * SKL-H + OPC (45W) GT4 quad 8 74 94/20 |
| 100 | * SKL-H + OPC (35W) GT4 quad 8 66 94/20 |
| 101 | * |
| 102 | * SKL-H (35W) GT2 dual 11.1 60 55 |
| 103 | * |
| 104 | * KBL/SKL-H (45W) GT2 quad 11.1 68 55 |
| 105 | * KBL-H (18W) GT2 quad 6.6 60 55 |
| 106 | * |
| 107 | * SKL-U + OPC (28W) GT3 dual 5.1 32 57/19 |
| 108 | * SKL-U + OPC (15W) GT3 dual 5.1 29 57/19 |
| 109 | * SKL-U (15W) GT2 dual 4.5 29 31 |
| 110 | * |
Maxim Polyakov | c56ca6b | 2019-10-15 14:13:28 +0300 | [diff] [blame] | 111 | * KBL-U + OPC (28W) GT3 dual 5.1 32 57/19 |
| 112 | * KBL-U + OPC (15W) GT3 dual 5.1 32 57/19 |
| 113 | * KBL-U (15W) GT1/2 dual 4.5 32 31 |
| 114 | * KBL-U [*] (15W) GT1 quad 4.5 29 31 |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 115 | * |
| 116 | * KBL-U/R (15W) GT2 quad 6 64 31 |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 117 | * |
| 118 | * SKL/KBL-Y (6W) 4.1 24 24 |
| 119 | * SKL/KBL-Y (4.5W) 4.1 24 24 |
Maxim Polyakov | c56ca6b | 2019-10-15 14:13:28 +0300 | [diff] [blame] | 120 | * |
| 121 | * [*] Pentium/Celeron CPUs with HD Graphics 610 |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 122 | */ |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 123 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 124 | switch (mch_id) { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 125 | case PCI_DEVICE_ID_INTEL_SKL_ID_S_2: /* fallthrough */ |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 126 | case PCI_DEVICE_ID_INTEL_KBL_ID_S: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 127 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(11.1, 40, 48, 48); |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 128 | if (tdp >= 54) |
| 129 | icc_max[VR_IA_CORE] = VR_CFG_AMP(58); |
| 130 | else if (tdp >= 51) |
| 131 | icc_max[VR_IA_CORE] = VR_CFG_AMP(45); |
| 132 | |
| 133 | return icc_max[domain]; |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 134 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 135 | case PCI_DEVICE_ID_INTEL_SKL_ID_S_4: /* fallthrough */ |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 136 | case PCI_DEVICE_ID_INTEL_KBL_ID_DT_2: /* fallthrough */ |
| 137 | case PCI_DEVICE_ID_INTEL_KBL_ID_DT: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 138 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(11.1, 55, 45, 45); |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 139 | if (tdp >= 91) |
| 140 | icc_max[VR_IA_CORE] = VR_CFG_AMP(100); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 141 | else if (tdp >= 80) |
| 142 | icc_max[VR_IA_CORE] = VR_CFG_AMP(82); |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 143 | else if (tdp >= 65) |
| 144 | icc_max[VR_IA_CORE] = VR_CFG_AMP(79); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 145 | else if (tdp >= 45) { |
| 146 | icc_max[VR_IA_CORE] = VR_CFG_AMP(70); |
| 147 | icc_max[VR_GT_SLICED] = 0; |
| 148 | icc_max[VR_GT_UNSLICED] = 0; |
| 149 | } else if (tdp >= 25) { |
| 150 | if (tdp >= 35) |
| 151 | icc_max[VR_IA_CORE] = VR_CFG_AMP(66); |
| 152 | |
Maxim Polyakov | b4383fc | 2019-08-29 16:51:37 +0300 | [diff] [blame] | 153 | icc_max[VR_GT_SLICED] = VR_CFG_AMP(35); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 154 | icc_max[VR_GT_UNSLICED] = VR_CFG_AMP(35); |
Maxim Polyakov | b4383fc | 2019-08-29 16:51:37 +0300 | [diff] [blame] | 155 | } |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 156 | |
| 157 | return icc_max[domain]; |
| 158 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 159 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_4: { |
| 160 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(11.1, 60, 94, 20); |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 161 | if (tdp >= 45) { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 162 | icc_max[VR_IA_CORE] = VR_CFG_AMP(74); |
| 163 | if (tdp >= 65) { |
| 164 | icc_max[VR_GT_SLICED] = VR_CFG_AMP(105); |
| 165 | icc_max[VR_GT_UNSLICED] = VR_CFG_AMP(24); |
| 166 | } |
| 167 | } |
| 168 | return icc_max[domain]; |
| 169 | } |
| 170 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_2: /* fallthrough */ |
| 171 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_EM: /* fallthrough */ |
| 172 | case PCI_DEVICE_ID_INTEL_KBL_ID_H: { |
| 173 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(6.6, 60, 55, 55); |
| 174 | if (tdp >= 35) { |
| 175 | if (tdp >= 45) |
| 176 | icc_max[VR_IA_CORE] = VR_CFG_AMP(68); |
| 177 | |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 178 | icc_max[VR_SYSTEM_AGENT] = VR_CFG_AMP(11.1); |
Patrick Rudolph | 69e826d | 2019-08-14 10:23:30 +0200 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | return icc_max[domain]; |
| 182 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 183 | case PCI_DEVICE_ID_INTEL_SKL_ID_U: { |
| 184 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(5.1, 29, 57, 19); |
| 185 | if (tdp >= 28) |
| 186 | icc_max[VR_IA_CORE] = VR_CFG_AMP(32); |
| 187 | else if (igd_id != PCI_DEVICE_ID_INTEL_SKL_GT3E_SULTM_1) { |
| 188 | const uint16_t icc_max_gt2[NUM_VR_DOMAINS] = |
| 189 | VR_CFG_ALL_DOMAINS_ICC(4.5, 29, 31, 31); |
| 190 | |
| 191 | return icc_max_gt2[domain]; |
| 192 | } |
| 193 | return icc_max[domain]; |
| 194 | } |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 195 | case PCI_DEVICE_ID_INTEL_KBL_U_R: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 196 | const uint16_t icc_max[NUM_VR_DOMAINS] = |
| 197 | VR_CFG_ALL_DOMAINS_ICC(6, 64, 31, 31); |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 198 | return icc_max[domain]; |
| 199 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 200 | case PCI_DEVICE_ID_INTEL_SKL_ID_Y: /* fallthrough */ |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 201 | case PCI_DEVICE_ID_INTEL_KBL_ID_Y: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 202 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(4.1, 24, 24, 24); |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 203 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 204 | if (igd_id == PCI_DEVICE_ID_INTEL_AML_GT2_ULX) |
| 205 | icc_max[VR_IA_CORE] = VR_CFG_AMP(28); |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 206 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 207 | return icc_max[domain]; |
| 208 | } |
| 209 | case PCI_DEVICE_ID_INTEL_KBL_ID_U: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 210 | uint16_t icc_max[NUM_VR_DOMAINS] = VR_CFG_ALL_DOMAINS_ICC(4.5, 32, 31, 31); |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 211 | |
Maxim Polyakov | c56ca6b | 2019-10-15 14:13:28 +0300 | [diff] [blame] | 212 | if (igd_id == PCI_DEVICE_ID_INTEL_KBL_GT1_SULTM) |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 213 | icc_max[VR_IA_CORE] = VR_CFG_AMP(29); |
| 214 | |
Maxim Polyakov | c56ca6b | 2019-10-15 14:13:28 +0300 | [diff] [blame] | 215 | else if ((igd_id == PCI_DEVICE_ID_INTEL_KBL_GT3E_SULTM_1) || |
| 216 | (igd_id == PCI_DEVICE_ID_INTEL_KBL_GT3E_SULTM_2)) { |
| 217 | const uint16_t icc_max_gt3[NUM_VR_DOMAINS] = |
| 218 | VR_CFG_ALL_DOMAINS_ICC(5.1, 32, 57, 19); |
| 219 | |
| 220 | return icc_max_gt3[domain]; |
| 221 | } |
| 222 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 223 | return icc_max[domain]; |
| 224 | } |
| 225 | default: |
Angel Pons | 0e2d515 | 2020-04-16 23:52:55 +0200 | [diff] [blame^] | 226 | printk(BIOS_ERR, "ERROR: Unknown MCH (0x%x) in %s\n", mch_id, __func__); |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 227 | } |
| 228 | return 0; |
Gaggery Tsai | e1a75d4 | 2018-01-02 12:13:40 +0800 | [diff] [blame] | 229 | } |
| 230 | |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 231 | static uint16_t get_sku_ac_dc_loadline(const int domain) |
| 232 | { |
| 233 | static uint16_t mch_id = 0, igd_id = 0; |
| 234 | if (!mch_id) { |
| 235 | struct device *dev = pcidev_path_on_root(SA_DEVFN_ROOT); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 236 | mch_id = dev ? pci_read_config16(dev, PCI_DEVICE_ID) : 0xffff; |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 237 | } |
| 238 | if (!igd_id) { |
| 239 | struct device *dev = pcidev_path_on_root(SA_DEVFN_IGD); |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 240 | igd_id = dev ? pci_read_config16(dev, PCI_DEVICE_ID) : 0xffff; |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | switch (mch_id) { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 244 | case PCI_DEVICE_ID_INTEL_SKL_ID_S_2: /* fallthrough */ |
| 245 | case PCI_DEVICE_ID_INTEL_SKL_ID_S_4: /* fallthrough */ |
| 246 | case PCI_DEVICE_ID_INTEL_KBL_ID_S: /* fallthrough */ |
| 247 | case PCI_DEVICE_ID_INTEL_KBL_ID_DT: /* fallthrough */ |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 248 | case PCI_DEVICE_ID_INTEL_KBL_ID_DT_2: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 249 | /* SA Loadline is not specified */ |
| 250 | const uint16_t loadline[NUM_VR_DOMAINS] = |
| 251 | VR_CFG_ALL_DOMAINS_LOADLINE(0, 2.1, 3.1, 3.1); |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 252 | return loadline[domain]; |
| 253 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 254 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_2: /* fallthrough */ |
| 255 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_EM: /* fallthrough */ |
| 256 | case PCI_DEVICE_ID_INTEL_SKL_ID_H_4: /* fallthrough */ |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 257 | case PCI_DEVICE_ID_INTEL_KBL_ID_H: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 258 | const uint16_t loadline[NUM_VR_DOMAINS] = |
| 259 | VR_CFG_ALL_DOMAINS_LOADLINE(10, 1.8, 2.65, 2.65); |
| 260 | |
| 261 | if (igd_id == PCI_DEVICE_ID_INTEL_SKL_GT4_SHALM) { |
| 262 | const uint16_t loadline_gt4[NUM_VR_DOMAINS] = |
| 263 | VR_CFG_ALL_DOMAINS_LOADLINE(6, 1.6, 1.4, 6); |
| 264 | return loadline_gt4[domain]; |
| 265 | } |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 266 | |
| 267 | return loadline[domain]; |
| 268 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 269 | case PCI_DEVICE_ID_INTEL_SKL_ID_Y: /* fallthrough */ |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 270 | case PCI_DEVICE_ID_INTEL_KBL_ID_Y: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 271 | uint16_t loadline[NUM_VR_DOMAINS] = |
| 272 | VR_CFG_ALL_DOMAINS_LOADLINE(18, 5.9, 5.7, 5.7); |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 273 | |
| 274 | if (igd_id == PCI_DEVICE_ID_INTEL_AML_GT2_ULX) |
| 275 | loadline[VR_IA_CORE] = VR_CFG_MOHMS(4); |
| 276 | |
| 277 | return loadline[domain]; |
| 278 | } |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 279 | case PCI_DEVICE_ID_INTEL_SKL_ID_U: /* fallthrough */ |
| 280 | case PCI_DEVICE_ID_INTEL_KBL_U_R: /* fallthrough */ |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 281 | case PCI_DEVICE_ID_INTEL_KBL_ID_U: { |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 282 | uint16_t loadline[NUM_VR_DOMAINS] = |
| 283 | VR_CFG_ALL_DOMAINS_LOADLINE(10.3, 2.4, 3.1, 3.1); |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 284 | |
Maxim Polyakov | 24ba850 | 2019-08-29 18:40:19 +0300 | [diff] [blame] | 285 | if ((igd_id == PCI_DEVICE_ID_INTEL_SKL_GT3E_SULTM_1) || |
| 286 | (igd_id == PCI_DEVICE_ID_INTEL_SKL_GT3E_SULTM_2) || |
| 287 | (igd_id == PCI_DEVICE_ID_INTEL_KBL_GT3E_SULTM_1) || |
Maxim Polyakov | 9d68cb2 | 2019-10-03 17:07:21 +0300 | [diff] [blame] | 288 | (igd_id == PCI_DEVICE_ID_INTEL_KBL_GT3E_SULTM_2)) { |
Maxim Polyakov | 7235913 | 2019-10-03 16:50:04 +0300 | [diff] [blame] | 289 | loadline[VR_GT_UNSLICED] = VR_CFG_MOHMS(2); |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 290 | loadline[VR_GT_SLICED] = VR_CFG_MOHMS(6); |
| 291 | } |
| 292 | |
| 293 | return loadline[domain]; |
| 294 | } |
| 295 | default: |
Angel Pons | 0e2d515 | 2020-04-16 23:52:55 +0200 | [diff] [blame^] | 296 | printk(BIOS_ERR, "ERROR: Unknown MCH (0x%x) in %s\n", mch_id, __func__); |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 297 | } |
| 298 | return 0; |
| 299 | } |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 300 | |
Rizwan Qureshi | 1222a73 | 2016-08-23 14:31:23 +0530 | [diff] [blame] | 301 | void fill_vr_domain_config(void *params, |
| 302 | int domain, const struct vr_config *chip_cfg) |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 303 | { |
Rizwan Qureshi | 1222a73 | 2016-08-23 14:31:23 +0530 | [diff] [blame] | 304 | FSP_SIL_UPD *vr_params = (FSP_SIL_UPD *)params; |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 305 | const struct vr_config *cfg; |
| 306 | |
| 307 | if (domain < 0 || domain >= NUM_VR_DOMAINS) |
| 308 | return; |
| 309 | |
| 310 | /* Use device tree override if requested. */ |
| 311 | if (chip_cfg->vr_config_enable) |
| 312 | cfg = chip_cfg; |
| 313 | else |
| 314 | cfg = &default_configs[domain]; |
| 315 | |
Rizwan Qureshi | 1222a73 | 2016-08-23 14:31:23 +0530 | [diff] [blame] | 316 | vr_params->VrConfigEnable[domain] = cfg->vr_config_enable; |
| 317 | vr_params->Psi1Threshold[domain] = cfg->psi1threshold; |
| 318 | vr_params->Psi2Threshold[domain] = cfg->psi2threshold; |
| 319 | vr_params->Psi3Threshold[domain] = cfg->psi3threshold; |
| 320 | vr_params->Psi3Enable[domain] = cfg->psi3enable; |
| 321 | vr_params->Psi4Enable[domain] = cfg->psi4enable; |
| 322 | vr_params->ImonSlope[domain] = cfg->imon_slope; |
| 323 | vr_params->ImonOffset[domain] = cfg->imon_offset; |
Patrick Rudolph | b824f7d | 2019-12-09 08:56:39 +0100 | [diff] [blame] | 324 | |
Patrick Rudolph | 50aebaf8 | 2019-08-14 10:07:38 +0200 | [diff] [blame] | 325 | /* If board provided non-zero value, use it. */ |
| 326 | if (cfg->icc_max) |
| 327 | vr_params->IccMax[domain] = cfg->icc_max; |
| 328 | else |
| 329 | vr_params->IccMax[domain] = get_sku_icc_max(domain); |
Rizwan Qureshi | 1222a73 | 2016-08-23 14:31:23 +0530 | [diff] [blame] | 330 | vr_params->VrVoltageLimit[domain] = cfg->voltage_limit; |
Duncan Laurie | 86db469 | 2017-03-14 16:40:06 -0700 | [diff] [blame] | 331 | |
Patrick Rudolph | 9a01623 | 2019-08-14 12:10:48 +0200 | [diff] [blame] | 332 | if (cfg->ac_loadline) |
| 333 | vr_params->AcLoadline[domain] = cfg->ac_loadline; |
| 334 | else |
| 335 | vr_params->AcLoadline[domain] = get_sku_ac_dc_loadline(domain); |
| 336 | if (cfg->dc_loadline) |
| 337 | vr_params->DcLoadline[domain] = cfg->dc_loadline; |
| 338 | else |
| 339 | vr_params->DcLoadline[domain] = get_sku_ac_dc_loadline(domain); |
Aaron Durbin | df21440 | 2015-12-14 16:44:26 -0600 | [diff] [blame] | 340 | } |