arch/all-pc/kernel/apic_acpi.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/asmcall.h>
   7 #include <proto/acpica.h>
   8 #include <proto/exec.h>
   9
  10 #include <utility/hooks.h>
  11
  12 #include <inttypes.h>
  13 #include <string.h>
  14
  15 #include "kernel_base.h"
  16 #include "kernel_debug.h"
  17
  18 #include "apic.h"
  19 #include "apic_ia32.h"
  20
  21 #define D(x)
  22
  23 /************************************************************************************************
  24                                     ACPI RELATED FUNCTIONS
  25  ************************************************************************************************/
  26
  27 /* Process the 'Local APIC Address Overide' MADT Table */
  28 AROS_UFH3(static IPTR, ACPI_hook_Table_LAPIC_Addr_Ovr_Parse,
  29           AROS_UFHA(struct Hook *, table_hook, A0),
  30           AROS_UFHA(ACPI_MADT_LOCAL_APIC_OVERRIDE *, lapic_addr_ovr, A2),
  31           AROS_UFHA(struct APICData *, data, A2))
  32 {
  33     AROS_USERFUNC_INIT
  34
  35     data->lapicBase = lapic_addr_ovr->Address;
  36     D(bug("[APIC-ACPI] (HOOK) ACPI_hook_Table_LAPIC_Addr_Ovr_Parse: Local APIC address Override to 0x%p\n", data->lapicBase));
  37
  38     return TRUE;
  39
  40     AROS_USERFUNC_EXIT
  41 }
  42
  43 /*
  44  * Process the 'Local APIC' MADT Table.
  45  * This function collects APIC IDs into already allocated CPUData array.
  46  */
  47 AROS_UFH3(static IPTR, ACPI_hook_Table_LAPIC_Parse,
  48           AROS_UFHA(struct Hook *, table_hook, A0),
  49           AROS_UFHA(ACPI_MADT_LOCAL_APIC *, processor, A2),
  50           AROS_UFHA(struct APICData *, data, A1))
  51 {
  52     AROS_USERFUNC_INIT
  53
  54     if (processor->LapicFlags & ACPI_MADT_ENABLED)
  55     {
  56         if (data->cores[0].lapicID == processor->Id)
  57         {
  58             /* This is the BSP, slot 0 is always reserved for it. */
  59             bug("[APIC-ACPI] Registering APIC [ID=0x%02X] for BSP\n", processor->Id);
  60
  61             data->cores[0].sysID = processor->ProcessorId;
  62         }
  63         else
  64         {
  65             /* Add one more AP */
  66             bug("[APIC-ACPI] Registering APIC [ID=0x%02X:0x%02X]\n", processor->Id, processor->ProcessorId);
  67
  68             data->cores[data->count].lapicID = processor->Id;
  69             data->cores[data->count].sysID   = processor->ProcessorId;
  70
  71             data->count++;
  72         }
  73
  74
  75         return TRUE;
  76     }
  77
  78     return FALSE;
  79
  80     AROS_USERFUNC_EXIT
  81 }
  82
  83 /* Process the 'Local APIC Non-Maskable Interrupt' MADT Table */
  84 AROS_UFH3(IPTR, ACPI_hook_Table_LAPIC_NMI_Parse,
  85           AROS_UFHA(struct Hook *, table_hook, A0),
  86           AROS_UFHA(ACPI_MADT_LOCAL_APIC_NMI *, lapic_nmi, A2),
  87           AROS_UFHA(struct APICData *, data, A1))
  88 {
  89     AROS_USERFUNC_INIT
  90
  91     IPTR cpu_num = (IPTR)table_hook->h_Data;
  92
  93     if ((lapic_nmi->ProcessorId == data->cores[cpu_num].sysID) || (lapic_nmi->ProcessorId == 0xff))
  94     {
  95         UWORD reg;
  96         ULONG val = LVT_MT_NMI; /* This is the default (edge-triggered, active low) */
  97
  98         D(bug("[APIC-ACPI.%u] NMI LINT%u\n", cpu_num, lapic_nmi->Lint));
  99
 100         switch (lapic_nmi->Lint)
 101         {
 102         case 0:
 103             reg = APIC_LINT0_VEC;
 104             break;
 105
 106         case 1:
 107             reg = APIC_LINT1_VEC;
 108             break;
 109
 110         default:
 111             /* Invalid LINT# value */
 112             return FALSE;
 113         }
 114
 115         if ((lapic_nmi->IntiFlags & ACPI_MADT_POLARITY_MASK) == ACPI_MADT_POLARITY_ACTIVE_LOW)
 116         {
 117             D(bug("[APIC-ACPI.%u] NMI active low\n", cpu_num));
 118             val |= LVT_ACTIVE_LOW;
 119         }
 120
 121         if ((lapic_nmi->IntiFlags & ACPI_MADT_TRIGGER_MASK) == ACPI_MADT_TRIGGER_LEVEL)
 122         {
 123             D(bug("[APIC-ACPI.%u] NMI level-triggered\n", cpu_num));
 124             val |= LVT_TGM_LEVEL;
 125         }
 126
 127         APIC_REG(data->lapicBase, reg) = val;
 128         return TRUE;
 129     }
 130
 131     return FALSE;
 132
 133     AROS_USERFUNC_EXIT
 134 }
 135
 136 /* Process the 'IO-APIC' MADT Table */
 137 AROS_UFH3(IPTR, ACPI_hook_Table_IOAPIC_Parse,
 138           AROS_UFHA(struct Hook *, table_hook, A0),
 139           AROS_UFHA(ACPI_MADT_IO_APIC *, ioapic, A2),
 140           AROS_UFHA(struct APICData *, data, A1))
 141 {
 142     AROS_USERFUNC_INIT
 143
 144     D(bug("[APIC-ACPI] (HOOK) ACPI_hook_Table_IOAPIC_Parse: IOAPIC %d @ %p [irq base = %d]\n", ioapic->Id, ioapic->Address, ioapic->GlobalIrqBase));
 145
 146     data->ioapicBase = ioapic->Address;
 147     return TRUE;
 148
 149     AROS_USERFUNC_EXIT
 150 }
 151
 152 /* Process the 'Interrupt Source Overide' MADT Table */
 153 AROS_UFH2(IPTR, ACPI_hook_Table_Int_Src_Ovr_Parse,
 154           AROS_UFHA(struct Hook *, table_hook, A0),
 155           AROS_UFHA(ACPI_MADT_INTERRUPT_OVERRIDE *, intsrc, A2))
 156 {
 157     AROS_USERFUNC_INIT
 158
 159     D(bug("[APIC-ACPI] (HOOK) ACPI_hook_Table_Int_Src_Ovr_Parse: Bus %d, Source IRQ %d, Global IRQ %d, Flags 0x%x\n", intsrc->Bus, intsrc->SourceIrq,
 160                 intsrc->GlobalIrq, intsrc->IntiFlags));
 161
 162     return TRUE;
 163
 164     AROS_USERFUNC_EXIT
 165 }
 166
 167 /* Process the 'Non-Maskable Interrupt Source' MADT Table */
 168 AROS_UFH2(IPTR, ACPI_hook_Table_NMI_Src_Parse,
 169           AROS_UFHA(struct Hook *, table_hook, A0),
 170           AROS_UFHA(ACPI_MADT_NMI_SOURCE *, nmi_src, A2))
 171 {
 172     AROS_USERFUNC_INIT
 173
 174     D(bug("[APIC-ACPI] (HOOK) ACPI_hook_Table_NMI_Src_Parse()\n"));
 175
 176     /* FIXME: Uh... shouldn't we do something with this? */
 177
 178     return TRUE;
 179
 180     AROS_USERFUNC_EXIT
 181 }
 182
 183 static const struct Hook ACPI_TableParse_LAPIC_Addr_Ovr_hook =
 184 {
 185     .h_Entry = (APTR)ACPI_hook_Table_LAPIC_Addr_Ovr_Parse
 186 };
 187
 188 static const struct Hook ACPI_TableParse_LAPIC_hook =
 189 {
 190     .h_Entry = (APTR)ACPI_hook_Table_LAPIC_Parse
 191 };
 192
 193 static const struct Hook ACPI_TableParse_IOAPIC_hook =
 194 {
 195     .h_Entry = (APTR)ACPI_hook_Table_IOAPIC_Parse
 196 };
 197
 198 static const struct Hook ACPI_TableParse_Int_Src_Ovr_hook =
 199 {
 200     .h_Entry = (APTR)ACPI_hook_Table_Int_Src_Ovr_Parse
 201 };
 202
 203 static const struct Hook ACPI_TableParse_NMI_Src_hook =
 204 {
 205     .h_Entry = (APTR)ACPI_hook_Table_NMI_Src_Parse
 206 };
 207
 208 /************************************************************************************************/
 209 /************************************************************************************************
 210                 APIC Functions used by kernel.resource from outside this file ..
 211  ************************************************************************************************/
 212 /************************************************************************************************/
 213
 214 static int MADT_ScanEntries(CONST ACPI_TABLE_MADT *madt, enum AcpiMadtType type, const struct Hook *hook, APTR userdata)
 215 {
 216     UINT8 *madt_entry = (UINT8 *)&madt[1];
 217     UINT8 *madt_end  = (UINT8 *)madt + madt->Header.Length;
 218     int count;
 219
 220     for (count = 0; madt_entry < madt_end; madt_entry += ((ACPI_SUBTABLE_HEADER *)madt_entry)->Length) {
 221         ACPI_SUBTABLE_HEADER *sh = (ACPI_SUBTABLE_HEADER *)madt_entry;
 222         if (sh->Type == (UINT8)type) {
 223             BOOL res;
 224             if (hook == NULL)
 225                 res = TRUE;
 226             else
 227                 res = CALLHOOKPKT((struct Hook *)hook, (APTR)sh, userdata);
 228             if (res)
 229                 count++;
 230         }
 231     }
 232
 233     return count;
 234 }
 235
 236
 237 /*
 238  * Initialize APIC on a CPU core with specified number.
 239  * This routine is ran by all cores.
 240  */
 241 void acpi_APIC_InitCPU(struct APICData *data, IPTR cpuNum)
 242 {
 243     /* Initialize APIC to the default configuration */
 244     core_APIC_Init(data, cpuNum);
 245
 246     if (data->acpi_madt)
 247     {
 248         struct Hook hook;
 249
 250         /* Set up NMI for ourselves */
 251         hook.h_Entry = (APTR)ACPI_hook_Table_LAPIC_NMI_Parse;
 252         hook.h_Data  = (APTR)cpuNum;
 253         MADT_ScanEntries(data->acpi_madt, ACPI_MADT_TYPE_LOCAL_APIC_NMI, &hook, data);
 254     }
 255 }
 256
 257 /* Initialize APIC from ACPI data */
 258 struct APICData *acpi_APIC_Init(void)
 259 {
 260     ULONG result;
 261     ACPI_STATUS err;
 262     const ACPI_TABLE_MADT *madt;
 263     struct APICData *data;
 264
 265     /*
 266      * MADT : If it exists, parse the Multiple APIC Description Table "MADT",
 267      * This table provides platform SMP configuration information [the successor to MPS tables]
 268      */
 269     err = AcpiGetTable("MADT", 1, (ACPI_TABLE_HEADER **)&madt);
 270     if (err != AE_OK) {
 271         D(bug("[APCI-ACPI] No MADT table found, err = %d\n", err));
 272         return NULL;
 273     }
 274
 275     if (madt)
 276     {
 277         /*
 278          * We have MADT from ACPI.
 279          * The first thing to do now is to count APICs and allocate struct APICData.
 280          */
 281         result = MADT_ScanEntries(madt, ACPI_MADT_TYPE_LOCAL_APIC, NULL, NULL);
 282         D(bug("[APIC-ACPI] Found %u enabled APICs\n", result));
 283
 284         data = AllocMem(sizeof(struct APICData) + result * sizeof(struct CPUData), MEMF_CLEAR);
 285         if (!data)
 286             return NULL;
 287
 288         data->lapicBase = madt->Address;
 289         data->acpi_madt = madt; /* Cache ACPI data for secondary cores */
 290         data->count     = 1;            /* Only one CPU is running right now */
 291         data->flags     = ((madt->Flags & ACPI_MADT_PCAT_COMPAT) == ACPI_MADT_MULTIPLE_APIC) ? APF_8259 : 0;
 292
 293         bug("[APIC-ACPI] Local APIC address 0x%08x; Flags 0x%04X\n", data->lapicBase, data->flags);
 294
 295         /*
 296          * The local APIC base address is obtained from the MADT (32-bit value) and
 297          * (optionally) overriden by a LAPIC_ADDR_OVR entry (64-bit value).
 298          */
 299         MADT_ScanEntries(madt, ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE, &ACPI_TableParse_LAPIC_Addr_Ovr_hook, data);
 300
 301         /* Remember ID of the bootstrap APIC, this is CPU #0 */
 302         data->cores[0].lapicID = core_APIC_GetID(data->lapicBase);
 303         D(bug("[APIC-ACPI] BSP ID: 0x%02X\n", data->cores[0].lapicID));
 304
 305         /* Now fill in IDs (both HW and ACPI) of the rest APICs */
 306         MADT_ScanEntries(madt, ACPI_MADT_TYPE_LOCAL_APIC, &ACPI_TableParse_LAPIC_hook, data);
 307         bug("[APIC-ACPI] System Total APICs: %d\n", data->count);
 308
 309         /* Initialize LAPIC for ourselves (CPU #0) */
 310         acpi_APIC_InitCPU(data, 0);
 311
 312         /* TODO: The following is actually not implemented yet. IOAPIC should be configured here. */
 313
 314         result = MADT_ScanEntries(madt, ACPI_MADT_TYPE_IO_APIC, &ACPI_TableParse_IOAPIC_hook, data);
 315         D(bug("[APIC-ACPI] ACPI_ScanEntries(ACPI_MADT_IOAPIC) returned %p\n", result));
 316
 317         MADT_ScanEntries(madt, ACPI_MADT_TYPE_INTERRUPT_OVERRIDE, &ACPI_TableParse_Int_Src_Ovr_hook, data);
 318
 319         result = MADT_ScanEntries(madt, ACPI_MADT_TYPE_NMI_SOURCE, &ACPI_TableParse_NMI_Src_hook, data);
 320         D(bug("[APIC-ACPI] ACPI_ScanEntries(ACPI_MADT_NMI_SRC) returned %p\n", result));
 321
 322         /* Build a default routing table for legacy (ISA) interrupts. */
 323         /* TODO: implement legacy irq config.. */
 324         D(bug("[APIC-ACPI] Configuring Legacy IRQs .. Skipped (UNIMPLEMENTED) ..\n"));
 325
 326         /* TODO: implement check for clustered apic's..
 327             core_APICClusteredCheck();
 328         */
 329         return data;
 330     }
 331
 332     return NULL;
 333 }