Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 1 | /* |
Stefan Reinauer | 7e61e45 | 2008-01-18 10:35:56 +0000 | [diff] [blame] | 2 | * This file is part of the coreboot project. |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 3 | * |
Timothy Pearson | 367fe8c | 2015-01-23 20:18:56 -0600 | [diff] [blame] | 4 | * Copyright (C) 2015 Timothy Pearson <tpearson@raptorengineeringinc.com>, Raptor Engineering |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 5 | * Copyright (C) 2007 Advanced Micro Devices, Inc. |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License as published by |
| 9 | * the Free Software Foundation; version 2 of the License. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 15 | */ |
| 16 | |
| 17 | #include <console/console.h> |
| 18 | #include <string.h> |
| 19 | #include <arch/acpi.h> |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 20 | #include <arch/acpigen.h> |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 21 | #include <device/pci.h> |
| 22 | #include <cpu/x86/msr.h> |
| 23 | #include <cpu/amd/mtrr.h> |
| 24 | #include <cpu/amd/amdfam10_sysconf.h> |
| 25 | #include "amdfam10.h" |
| 26 | |
Stefan Reinauer | 8677a23 | 2010-12-11 20:33:41 +0000 | [diff] [blame] | 27 | //it seems some functions can be moved arch/x86/boot/acpi.c |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 28 | |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 29 | unsigned long acpi_create_madt_lapic_nmis(unsigned long current, u16 flags, u8 lint) |
| 30 | { |
| 31 | device_t cpu; |
| 32 | int cpu_index = 0; |
| 33 | |
Elyes HAOUAS | 5a7e72f | 2016-08-23 21:36:02 +0200 | [diff] [blame] | 34 | for (cpu = all_devices; cpu; cpu = cpu->next) { |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 35 | if ((cpu->path.type != DEVICE_PATH_APIC) || |
Stefan Reinauer | 0aa37c4 | 2013-02-12 15:20:54 -0800 | [diff] [blame] | 36 | (cpu->bus->dev->path.type != DEVICE_PATH_CPU_CLUSTER)) { |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 37 | continue; |
| 38 | } |
| 39 | if (!cpu->enabled) { |
| 40 | continue; |
| 41 | } |
| 42 | current += acpi_create_madt_lapic_nmi((acpi_madt_lapic_nmi_t *)current, cpu_index, flags, lint); |
| 43 | cpu_index++; |
| 44 | } |
| 45 | return current; |
| 46 | } |
| 47 | |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 48 | unsigned long acpi_create_srat_lapics(unsigned long current) |
| 49 | { |
| 50 | device_t cpu; |
| 51 | int cpu_index = 0; |
| 52 | |
Elyes HAOUAS | 5a7e72f | 2016-08-23 21:36:02 +0200 | [diff] [blame] | 53 | for (cpu = all_devices; cpu; cpu = cpu->next) { |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 54 | if ((cpu->path.type != DEVICE_PATH_APIC) || |
Stefan Reinauer | 0aa37c4 | 2013-02-12 15:20:54 -0800 | [diff] [blame] | 55 | (cpu->bus->dev->path.type != DEVICE_PATH_CPU_CLUSTER)) { |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 56 | continue; |
| 57 | } |
| 58 | if (!cpu->enabled) { |
| 59 | continue; |
| 60 | } |
Stefan Reinauer | c02b4fc | 2010-03-22 11:42:32 +0000 | [diff] [blame] | 61 | printk(BIOS_DEBUG, "SRAT: lapic cpu_index=%02x, node_id=%02x, apic_id=%02x\n", cpu_index, cpu->path.apic.node_id, cpu->path.apic.apic_id); |
Stefan Reinauer | 2b34db8 | 2009-02-28 20:10:20 +0000 | [diff] [blame] | 62 | current += acpi_create_srat_lapic((acpi_srat_lapic_t *)current, cpu->path.apic.node_id, cpu->path.apic.apic_id); |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 63 | cpu_index++; |
| 64 | } |
| 65 | return current; |
| 66 | } |
| 67 | |
| 68 | static unsigned long resk(uint64_t value) |
| 69 | { |
| 70 | unsigned long resultk; |
| 71 | if (value < (1ULL << 42)) { |
| 72 | resultk = value >> 10; |
| 73 | } else { |
| 74 | resultk = 0xffffffff; |
| 75 | } |
| 76 | return resultk; |
| 77 | } |
| 78 | |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 79 | struct acpi_srat_mem_state { |
| 80 | unsigned long current; |
| 81 | }; |
| 82 | |
Myles Watson | 7943fe6 | 2009-10-30 02:08:07 +0000 | [diff] [blame] | 83 | static void set_srat_mem(void *gp, struct device *dev, struct resource *res) |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 84 | { |
| 85 | struct acpi_srat_mem_state *state = gp; |
| 86 | unsigned long basek, sizek; |
| 87 | basek = resk(res->base); |
| 88 | sizek = resk(res->size); |
| 89 | |
Myles Watson | 08e0fb8 | 2010-03-22 16:33:25 +0000 | [diff] [blame] | 90 | printk(BIOS_DEBUG, "set_srat_mem: dev %s, res->index=%04lx startk=%08lx, sizek=%08lx\n", |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 91 | dev_path(dev), res->index, basek, sizek); |
| 92 | /* |
Carl-Daniel Hailfinger | 1c49bc9 | 2009-01-30 02:05:20 +0000 | [diff] [blame] | 93 | * 0-640K must be on node 0 |
| 94 | * next range is from 1M--- |
| 95 | * So will cut off before 1M in the mem range |
| 96 | */ |
Elyes HAOUAS | 5a7e72f | 2016-08-23 21:36:02 +0200 | [diff] [blame] | 97 | if ((basek+sizek)<1024) return; |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 98 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 99 | if (basek < 1024) { |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 100 | sizek -= 1024 - basek; |
| 101 | basek = 1024; |
| 102 | } |
| 103 | |
| 104 | // need to figure out NV |
Timothy Pearson | 121ef60 | 2015-08-08 02:40:58 -0500 | [diff] [blame] | 105 | if (res->index > 0xf) /* Exclude MMIO resources, e.g. as set in northbridge.c amdfam10_domain_read_resources() */ |
| 106 | state->current += acpi_create_srat_mem((acpi_srat_mem_t *)state->current, (res->index & 0xf), basek, sizek, 1); |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 107 | } |
| 108 | |
Vladimir Serbinenko | 5e59757 | 2014-10-11 23:45:40 +0200 | [diff] [blame] | 109 | static unsigned long acpi_fill_srat(unsigned long current) |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 110 | { |
| 111 | struct acpi_srat_mem_state srat_mem_state; |
| 112 | |
| 113 | /* create all subtables for processors */ |
| 114 | current = acpi_create_srat_lapics(current); |
| 115 | |
| 116 | /* create all subteble for memory range */ |
| 117 | |
| 118 | /* 0-640K must be on node 0 */ |
| 119 | current += acpi_create_srat_mem((acpi_srat_mem_t *)current, 0, 0, 640, 1);//enable |
| 120 | |
| 121 | srat_mem_state.current = current; |
| 122 | search_global_resources( |
| 123 | IORESOURCE_MEM | IORESOURCE_CACHEABLE, IORESOURCE_MEM | IORESOURCE_CACHEABLE, |
| 124 | set_srat_mem, &srat_mem_state); |
| 125 | |
| 126 | current = srat_mem_state.current; |
| 127 | return current; |
| 128 | } |
| 129 | |
Vladimir Serbinenko | 5e59757 | 2014-10-11 23:45:40 +0200 | [diff] [blame] | 130 | static unsigned long acpi_fill_slit(unsigned long current) |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 131 | { |
Martin Roth | 0cd338e | 2016-07-29 14:07:30 -0600 | [diff] [blame] | 132 | /* Implement SLIT algorithm in BKDG Rev. 3.62 Section 2.3.6.1 |
Timothy Pearson | b337c1d | 2015-03-21 15:11:58 -0500 | [diff] [blame] | 133 | * Fill the first 8 bytes with the node number, |
| 134 | * then fill the next num*num byte with the distance, |
| 135 | * Distance entries vary with topology; the local node |
| 136 | * is always 10. |
| 137 | * |
| 138 | * Fully connected: |
| 139 | * Set all non-local nodes to 16 |
| 140 | * |
| 141 | * Partially connected; with probe filter: |
| 142 | * Set all non-local nodes to 10+(num_hops*6) |
| 143 | * |
| 144 | * Partially connected; without probe filter: |
| 145 | * Set all non-local nodes to 13 |
| 146 | * |
| 147 | * FIXME |
| 148 | * The partially connected cases are not implemented; |
| 149 | * once a means is found to detect partially connected |
| 150 | * topologies, implement the remaining cases. |
| 151 | */ |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 152 | |
| 153 | u8 *p = (u8 *)current; |
| 154 | int nodes = sysconf.nodes; |
| 155 | int i,j; |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 156 | |
| 157 | memset(p, 0, 8+nodes*nodes); |
| 158 | *p = (u8) nodes; |
| 159 | p += 8; |
| 160 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 161 | for (i = 0; i < nodes; i++) { |
| 162 | for (j = 0; j < nodes; j++) { |
| 163 | if (i == j) |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 164 | p[i*nodes+j] = 10; |
Timothy Pearson | b337c1d | 2015-03-21 15:11:58 -0500 | [diff] [blame] | 165 | else |
| 166 | p[i*nodes+j] = 16; |
Marc Jones | 8ae8c88 | 2007-12-19 01:32:08 +0000 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | |
| 170 | current += 8+nodes*nodes; |
| 171 | return current; |
| 172 | } |
| 173 | |
Myles Watson | f4cc089 | 2010-04-14 16:50:16 +0000 | [diff] [blame] | 174 | void update_ssdtx(void *ssdtx, int i) |
| 175 | { |
| 176 | u8 *PCI; |
| 177 | u8 *HCIN; |
| 178 | u8 *UID; |
| 179 | |
| 180 | PCI = ssdtx + 0x32; |
| 181 | HCIN = ssdtx + 0x39; |
| 182 | UID = ssdtx + 0x40; |
| 183 | |
| 184 | if (i < 7) { |
| 185 | *PCI = (u8) ('4' + i - 1); |
| 186 | } else { |
| 187 | *PCI = (u8) ('A' + i - 1 - 6); |
| 188 | } |
| 189 | *HCIN = (u8) i; |
| 190 | *UID = (u8) (i + 3); |
| 191 | |
| 192 | /* FIXME: need to update the GSI id in the ssdtx too */ |
| 193 | |
| 194 | } |
| 195 | |
Alexander Couzens | 5eea458 | 2015-04-12 22:18:55 +0200 | [diff] [blame] | 196 | void northbridge_acpi_write_vars(device_t device) |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 197 | { |
Timothy Pearson | 367fe8c | 2015-01-23 20:18:56 -0600 | [diff] [blame] | 198 | /* |
| 199 | * If more than one physical CPU is installed, northbridge_acpi_write_vars() |
| 200 | * is called more than once and the resultant SSDT table is corrupted |
| 201 | * (duplicated entries). |
| 202 | * This prevents Linux from booting, with log messages like these: |
| 203 | * ACPI Error: [BUSN] Namespace lookup failure, AE_ALREADY_EXISTS (/dswload-353) |
| 204 | * ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (/psobject-222) |
| 205 | * followed by a slew of ACPI method failures and a hang when the invalid PCI |
| 206 | * resource entries are used. |
| 207 | * This routine prevents the SSDT table from being corrupted. |
| 208 | */ |
| 209 | static uint8_t ssdt_generated = 0; |
| 210 | if (ssdt_generated) |
| 211 | return; |
| 212 | ssdt_generated = 1; |
| 213 | |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 214 | msr_t msr; |
| 215 | char pscope[] = "\\_SB.PCI0"; |
| 216 | int i; |
| 217 | |
| 218 | get_bus_conf(); /* it will get sblk, pci1234, hcdn, and sbdn */ |
| 219 | |
| 220 | acpigen_write_scope(pscope); |
| 221 | |
| 222 | acpigen_write_name("BUSN"); |
| 223 | acpigen_write_package(HC_NUMS); |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 224 | for (i = 0; i < HC_NUMS; i++) { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 225 | acpigen_write_dword(sysconf.ht_c_conf_bus[i]); |
| 226 | } |
| 227 | // minus the opcode |
| 228 | acpigen_pop_len(); |
| 229 | |
| 230 | acpigen_write_name("MMIO"); |
| 231 | |
| 232 | acpigen_write_package(HC_NUMS * 4); |
| 233 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 234 | for (i = 0; i<(HC_NUMS*2); i++) { // FIXME: change to more chain |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 235 | acpigen_write_dword(sysconf.conf_mmio_addrx[i]); //base |
| 236 | acpigen_write_dword(sysconf.conf_mmio_addr[i]); //mask |
| 237 | } |
| 238 | // minus the opcode |
| 239 | acpigen_pop_len(); |
| 240 | |
| 241 | acpigen_write_name("PCIO"); |
| 242 | |
| 243 | acpigen_write_package(HC_NUMS * 2); |
| 244 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 245 | for (i = 0; i < HC_NUMS; i++) { // FIXME: change to more chain |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 246 | acpigen_write_dword(sysconf.conf_io_addrx[i]); |
| 247 | acpigen_write_dword(sysconf.conf_io_addr[i]); |
| 248 | } |
| 249 | |
| 250 | // minus the opcode |
| 251 | acpigen_pop_len(); |
| 252 | |
| 253 | acpigen_write_name_byte("SBLK", sysconf.sblk); |
| 254 | |
| 255 | msr = rdmsr(TOP_MEM); |
| 256 | acpigen_write_name_dword("TOM1", msr.lo); |
| 257 | |
| 258 | msr = rdmsr(TOP_MEM2); |
| 259 | /* |
| 260 | * Since XP only implements parts of ACPI 2.0, we can't use a qword |
| 261 | * here. |
| 262 | * See http://www.acpi.info/presentations/S01USMOBS169_OS%2520new.ppt |
| 263 | * slide 22ff. |
| 264 | * Shift value right by 20 bit to make it fit into 32bit, |
| 265 | * giving us 1MB granularity and a limit of almost 4Exabyte of memory. |
| 266 | */ |
| 267 | acpigen_write_name_dword("TOM2", (msr.hi << 12) | msr.lo >> 20); |
| 268 | |
| 269 | |
| 270 | acpigen_write_name_dword("SBDN", sysconf.sbdn); |
| 271 | |
| 272 | acpigen_write_name("HCLK"); |
| 273 | |
| 274 | acpigen_write_package(HC_POSSIBLE_NUM); |
| 275 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 276 | for (i = 0; i < sysconf.hc_possible_num; i++) { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 277 | acpigen_write_dword(sysconf.pci1234[i]); |
| 278 | } |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 279 | for (i = sysconf.hc_possible_num; i < HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8 |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 280 | acpigen_write_dword(0x00000000); |
| 281 | } |
| 282 | // minus the opcode |
| 283 | acpigen_pop_len(); |
| 284 | |
| 285 | acpigen_write_name("HCDN"); |
| 286 | |
| 287 | acpigen_write_package(HC_POSSIBLE_NUM); |
| 288 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 289 | for (i = 0; i < sysconf.hc_possible_num; i++) { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 290 | acpigen_write_dword(sysconf.hcdn[i]); |
| 291 | } |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 292 | for (i = sysconf.hc_possible_num; i < HC_POSSIBLE_NUM; i++) { // in case we set array size to other than 8 |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 293 | acpigen_write_dword(0x20202020); |
| 294 | } |
| 295 | // minus the opcode |
| 296 | acpigen_pop_len(); |
| 297 | |
| 298 | acpigen_write_name_byte("CBB", CONFIG_CBB); |
| 299 | |
| 300 | u8 CBST, CBB2, CBS2; |
| 301 | |
Elyes HAOUAS | 5a7e72f | 2016-08-23 21:36:02 +0200 | [diff] [blame] | 302 | if (CONFIG_CBB == 0xff) { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 303 | CBST = (u8) (0x0f); |
| 304 | } else { |
Elyes HAOUAS | 5a7e72f | 2016-08-23 21:36:02 +0200 | [diff] [blame] | 305 | if ((sysconf.pci1234[0] >> 12) & 0xff) { //sb chain on other than bus 0 |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 306 | CBST = (u8) (0x0f); |
Timothy Pearson | 2a83935 | 2015-09-05 18:56:05 -0500 | [diff] [blame] | 307 | } else { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 308 | CBST = (u8) (0x00); |
| 309 | } |
| 310 | } |
| 311 | |
| 312 | acpigen_write_name_byte("CBST", CBST); |
| 313 | |
Elyes HAOUAS | 04f8fd9 | 2016-09-19 10:24:34 -0600 | [diff] [blame] | 314 | if ((CONFIG_CBB == 0xff) && (sysconf.nodes > 32)) { |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 315 | CBS2 = 0x0f; |
| 316 | CBB2 = (u8)(CONFIG_CBB-1); |
| 317 | } else { |
| 318 | CBS2 = 0x00; |
| 319 | CBB2 = 0x00; |
| 320 | } |
| 321 | |
| 322 | acpigen_write_name_byte("CBB2", CBB2); |
| 323 | acpigen_write_name_byte("CBS2", CBS2); |
| 324 | |
| 325 | //minus opcode |
| 326 | acpigen_pop_len(); |
| 327 | } |
| 328 | |
Alexander Couzens | 83fc32f | 2015-04-12 22:28:37 +0200 | [diff] [blame] | 329 | unsigned long northbridge_write_acpi_tables(device_t device, |
| 330 | unsigned long current, |
| 331 | struct acpi_rsdp *rsdp) |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 332 | { |
| 333 | acpi_srat_t *srat; |
| 334 | acpi_slit_t *slit; |
| 335 | |
| 336 | get_bus_conf(); /* it will get sblk, pci1234, hcdn, and sbdn */ |
| 337 | |
| 338 | /* SRAT */ |
| 339 | current = ALIGN(current, 8); |
| 340 | printk(BIOS_DEBUG, "ACPI: * SRAT at %lx\n", current); |
| 341 | srat = (acpi_srat_t *) current; |
Vladimir Serbinenko | 5e59757 | 2014-10-11 23:45:40 +0200 | [diff] [blame] | 342 | acpi_create_srat(srat, acpi_fill_srat); |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 343 | current += srat->header.length; |
| 344 | acpi_add_table(rsdp, srat); |
| 345 | |
| 346 | /* SLIT */ |
| 347 | current = ALIGN(current, 8); |
| 348 | printk(BIOS_DEBUG, "ACPI: * SLIT at %lx\n", current); |
| 349 | slit = (acpi_slit_t *) current; |
Vladimir Serbinenko | 5e59757 | 2014-10-11 23:45:40 +0200 | [diff] [blame] | 350 | acpi_create_slit(slit, acpi_fill_slit); |
Vladimir Serbinenko | 2a19fb1 | 2014-10-02 20:09:19 +0200 | [diff] [blame] | 351 | current += slit->header.length; |
| 352 | acpi_add_table(rsdp, slit); |
| 353 | |
| 354 | return current; |
| 355 | } |