| /tags/0.1.0/SPARTAN/genarch/include/firmware/ofw/ofw.h |
|---|
| 0,0 → 1,62 |
| /* |
| * Copyright (C) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __OFW_H__ |
| #define __OFW_H__ |
| #include <arch/types.h> |
| #define MAX_OFW_ARGS 10 |
| typedef __native ofw_arg_t; |
| typedef int ihandle; |
| typedef int phandle; |
| /** OpenFirmware command structure |
| * |
| */ |
| typedef struct { |
| const char *service; /**< Command name */ |
| __native nargs; /**< Number of in arguments */ |
| __native nret; /**< Number of out arguments */ |
| ofw_arg_t args[MAX_OFW_ARGS]; /**< List of arguments */ |
| } ofw_args_t; |
| typedef void (*ofw_entry)(ofw_args_t *); |
| extern ofw_entry ofw; |
| extern void ofw_init(void); |
| extern void ofw_done(void); |
| extern __native ofw_call(const char *service, const int nargs, const int nret, ...); |
| extern void ofw_putchar(const char ch); |
| extern phandle ofw_find_device(const char *name); |
| extern int ofw_get_property(const phandle device, const char *name, void *buf, const int buflen); |
| extern void *ofw_claim(const void *addr, const int size, const int align); |
| #endif |
| /tags/0.1.0/SPARTAN/genarch/include/acpi/acpi.h |
|---|
| 0,0 → 1,85 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __ACPI_H__ |
| #define __ACPI_H__ |
| #include <arch/types.h> |
| /* Root System Description Pointer */ |
| struct acpi_rsdp { |
| __u8 signature[8]; |
| __u8 checksum; |
| __u8 oemid[6]; |
| __u8 revision; |
| __u32 rsdt_address; |
| __u32 length; |
| __u64 xsdt_address; |
| __u32 ext_checksum; |
| __u8 reserved[3]; |
| } __attribute__ ((packed)); |
| /* System Description Table Header */ |
| struct acpi_sdt_header { |
| __u8 signature[4]; |
| __u32 length; |
| __u8 revision; |
| __u8 checksum; |
| __u8 oemid[6]; |
| __u8 oem_table_id[8]; |
| __u32 oem_revision; |
| __u32 creator_id; |
| __u32 creator_revision; |
| } __attribute__ ((packed));; |
| struct acpi_signature_map { |
| __u8 *signature; |
| struct acpi_sdt_header **sdt_ptr; |
| char *description; |
| }; |
| /* Root System Description Table */ |
| struct acpi_rsdt { |
| struct acpi_sdt_header header; |
| __u32 entry[]; |
| } __attribute__ ((packed));; |
| /* Extended System Description Table */ |
| struct acpi_xsdt { |
| struct acpi_sdt_header header; |
| __u64 entry[]; |
| } __attribute__ ((packed));; |
| extern struct acpi_rsdp *acpi_rsdp; |
| extern struct acpi_rsdt *acpi_rsdt; |
| extern struct acpi_xsdt *acpi_xsdt; |
| extern void acpi_init(void); |
| extern int acpi_sdt_check(__u8 *sdt); |
| #endif /* __ACPI_H__ */ |
| /tags/0.1.0/SPARTAN/genarch/include/acpi/madt.h |
|---|
| 0,0 → 1,140 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #ifndef __MADT_H__ |
| #define __MADT_H__ |
| #include <genarch/acpi/acpi.h> |
| #include <arch/smp/apic.h> |
| #include <arch/smp/smp.h> |
| #define MADT_L_APIC 0 |
| #define MADT_IO_APIC 1 |
| #define MADT_INTR_SRC_OVRD 2 |
| #define MADT_NMI_SRC 3 |
| #define MADT_L_APIC_NMI 4 |
| #define MADT_L_APIC_ADDR_OVRD 5 |
| #define MADT_IO_SAPIC 6 |
| #define MADT_L_SAPIC 7 |
| #define MADT_PLATFORM_INTR_SRC 8 |
| #define MADT_RESERVED_SKIP_BEGIN 9 |
| #define MADT_RESERVED_SKIP_END 127 |
| #define MADT_RESERVED_OEM_BEGIN 128 |
| struct madt_apic_header { |
| __u8 type; |
| __u8 length; |
| } __attribute__ ((packed)); |
| /* Multiple APIC Description Table */ |
| struct acpi_madt { |
| struct acpi_sdt_header header; |
| __u32 l_apic_address; |
| __u32 flags; |
| struct madt_apic_header apic_header[]; |
| } __attribute__ ((packed)); |
| struct madt_l_apic { |
| struct madt_apic_header header; |
| __u8 acpi_id; |
| __u8 apic_id; |
| __u32 flags; |
| } __attribute__ ((packed)); |
| struct madt_io_apic { |
| struct madt_apic_header header; |
| __u8 io_apic_id; |
| __u8 reserved; |
| __u32 io_apic_address; |
| __u32 global_intr_base; |
| } __attribute__ ((packed)); |
| struct madt_intr_src_ovrd { |
| struct madt_apic_header header; |
| __u8 bus; |
| __u8 source; |
| __u32 global_intr; |
| __u16 flags; |
| } __attribute__ ((packed)); |
| struct madt_nmi_src { |
| struct madt_apic_header header; |
| __u16 flags; |
| __u32 global_intr; |
| } __attribute__ ((packed)); |
| struct madt_l_apic_nmi { |
| struct madt_apic_header header; |
| __u8 acpi_id; |
| __u16 flags; |
| __u8 l_apic_lint; |
| } __attribute__ ((packed)); |
| struct madt_l_apic_addr_ovrd { |
| struct madt_apic_header header; |
| __u16 reserved; |
| __u64 l_apic_address; |
| } __attribute__ ((packed)); |
| struct madt_io_sapic { |
| struct madt_apic_header header; |
| __u8 io_apic_id; |
| __u8 reserved; |
| __u32 global_intr_base; |
| __u64 io_apic_address; |
| } __attribute__ ((packed)); |
| struct madt_l_sapic { |
| struct madt_apic_header header; |
| __u8 acpi_id; |
| __u8 sapic_id; |
| __u8 sapic_eid; |
| __u8 reserved[3]; |
| __u32 flags; |
| __u32 acpi_processor_uid_value; |
| __u8 acpi_processor_uid_str[1]; |
| } __attribute__ ((packed)); |
| struct madt_platform_intr_src { |
| struct madt_apic_header header; |
| __u16 flags; |
| __u8 intr_type; |
| __u8 processor_id; |
| __u8 processor_eid; |
| __u8 io_sapic_vector; |
| __u32 global_intr; |
| __u32 platform_intr_src_flags; |
| } __attribute__ ((packed)); |
| extern struct acpi_madt *acpi_madt; |
| extern struct smp_config_operations madt_config_operations; |
| extern void acpi_madt_parse(void); |
| #endif /* __MADT_H__ */ |
| /tags/0.1.0/SPARTAN/genarch/Makefile.inc |
|---|
| 0,0 → 1,39 |
| # Copyright (C) 2005 Martin Decky |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # - Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # - Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # - The name of the author may not be used to endorse or promote products |
| # derived from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| ## Accepted configuration directives |
| # |
| ifeq ($(CONFIG_OFW),y) |
| GENARCH_SOURCES += \ |
| genarch/src/firmware/ofw/ofw.c |
| endif |
| ifeq ($(CONFIG_ACPI),y) |
| GENARCH_SOURCES += \ |
| genarch/src/acpi/acpi.c \ |
| genarch/src/acpi/matd.c |
| endif |
| /tags/0.1.0/SPARTAN/genarch/src/firmware/ofw/ofw.c |
|---|
| 0,0 → 1,100 |
| /* |
| * Copyright (C) 2005 Martin Decky |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <genarch/firmware/ofw/ofw.h> |
| #include <arch/asm.h> |
| #include <stdarg.h> |
| #include <cpu.h> |
| #include <arch/types.h> |
| ofw_entry ofw; |
| phandle ofw_chosen; |
| ihandle ofw_stdout; |
| void ofw_init(void) |
| { |
| ofw_chosen = ofw_find_device("/chosen"); |
| if (ofw_chosen == -1) |
| ofw_done(); |
| if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout, sizeof(ofw_stdout)) <= 0) |
| ofw_stdout = 0; |
| } |
| void ofw_done(void) |
| { |
| (void) ofw_call("exit", 0, 0); |
| cpu_halt(); |
| } |
| __native ofw_call(const char *service, const int nargs, const int nret, ...) |
| { |
| va_list list; |
| ofw_args_t args; |
| int i; |
| args.service = service; |
| args.nargs = nargs; |
| args.nret = nret; |
| va_start(list, nret); |
| for (i = 0; i < nargs; i++) |
| args.args[i] = va_arg(list, ofw_arg_t); |
| va_end(list); |
| for (i = 0; i < nret; i++) |
| args.args[i + nargs] = 0; |
| ofw(&args); |
| return args.args[nargs]; |
| } |
| void ofw_putchar(const char ch) |
| { |
| if (ofw_stdout == 0) |
| return; |
| (void) ofw_call("write", 3, 1, ofw_stdout, &ch, 1); |
| } |
| phandle ofw_find_device(const char *name) |
| { |
| return (phandle) ofw_call("finddevice", 1, 1, name); |
| } |
| int ofw_get_property(const phandle device, const char *name, void *buf, const int buflen) |
| { |
| return (int) ofw_call("getprop", 4, 1, device, name, buf, buflen); |
| } |
| void *ofw_claim(const void *addr, const int size, const int align) |
| { |
| return (void *) ofw_call("claim", 3, 1, addr, size, align); |
| } |
| /tags/0.1.0/SPARTAN/genarch/src/acpi/matd.c |
|---|
| 0,0 → 1,213 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <arch/types.h> |
| #include <typedefs.h> |
| #include <genarch/acpi/acpi.h> |
| #include <genarch/acpi/madt.h> |
| #include <arch/smp/apic.h> |
| #include <arch/smp/smp.h> |
| #include <panic.h> |
| #include <debug.h> |
| #include <config.h> |
| #include <print.h> |
| #include <mm/heap.h> |
| #include <memstr.h> |
| #include <sort.h> |
| struct acpi_madt *acpi_madt = NULL; |
| #ifdef __SMP__ |
| static void madt_l_apic_entry(struct madt_l_apic *la, __u32 index); |
| static void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index); |
| static int madt_cmp(void * a, void * b); |
| struct madt_l_apic *madt_l_apic_entries = NULL; |
| struct madt_io_apic *madt_io_apic_entries = NULL; |
| index_t madt_l_apic_entry_index = 0; |
| index_t madt_io_apic_entry_index = 0; |
| count_t madt_l_apic_entry_cnt = 0; |
| count_t madt_io_apic_entry_cnt = 0; |
| count_t cpu_count = 0; |
| struct madt_apic_header * * madt_entries_index = NULL; |
| int madt_entries_index_cnt = 0; |
| char *entry[] = { |
| "L_APIC", |
| "IO_APIC", |
| "INTR_SRC_OVRD", |
| "NMI_SRC", |
| "L_APIC_NMI", |
| "L_APIC_ADDR_OVRD", |
| "IO_SAPIC", |
| "L_SAPIC", |
| "PLATFORM_INTR_SRC" |
| }; |
| /* |
| * ACPI MADT Implementation of SMP configuration interface. |
| */ |
| static count_t madt_cpu_count(void); |
| static bool madt_cpu_enabled(index_t i); |
| static bool madt_cpu_bootstrap(index_t i); |
| static __u8 madt_cpu_apic_id(index_t i); |
| struct smp_config_operations madt_config_operations = { |
| .cpu_count = madt_cpu_count, |
| .cpu_enabled = madt_cpu_enabled, |
| .cpu_bootstrap = madt_cpu_bootstrap, |
| .cpu_apic_id = madt_cpu_apic_id |
| }; |
| static count_t madt_cpu_count(void) |
| { |
| return madt_l_apic_entry_cnt; |
| } |
| static bool madt_cpu_enabled(index_t i) |
| { |
| ASSERT(i < madt_l_apic_entry_cnt); |
| return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->flags & 0x1; |
| } |
| static bool madt_cpu_bootstrap(index_t i) |
| { |
| ASSERT(i < madt_l_apic_entry_cnt); |
| return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id == l_apic_id(); |
| } |
| static __u8 madt_cpu_apic_id(index_t i) |
| { |
| ASSERT(i < madt_l_apic_entry_cnt); |
| return ((struct madt_l_apic *) madt_entries_index[madt_l_apic_entry_index + i])->apic_id; |
| } |
| int madt_cmp(void * a, void * b) |
| { |
| return |
| (((struct madt_apic_header *) a)->type > ((struct madt_apic_header *) b)->type) ? |
| 1 : |
| ((((struct madt_apic_header *) a)->type < ((struct madt_apic_header *) b)->type) ? -1 : 0); |
| } |
| void acpi_madt_parse(void) |
| { |
| struct madt_apic_header *end = (struct madt_apic_header *) (((__u8 *) acpi_madt) + acpi_madt->header.length); |
| struct madt_apic_header *h; |
| l_apic = (__u32 *) (__native) acpi_madt->l_apic_address; |
| /* calculate madt entries */ |
| for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) { |
| madt_entries_index_cnt++; |
| } |
| /* create madt apic entries index array */ |
| madt_entries_index = (struct madt_apic_header * *) malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header * *)); |
| __u32 index = 0; |
| for (h = &acpi_madt->apic_header[0]; h < end; h = (struct madt_apic_header *) (((__u8 *) h) + h->length)) { |
| madt_entries_index[index++] = h; |
| } |
| /* Quicksort MADT index structure */ |
| qsort(madt_entries_index, madt_entries_index_cnt, sizeof(__address), &madt_cmp); |
| /* Parse MADT entries */ |
| for (index = 0; index < madt_entries_index_cnt - 1; index++) { |
| h = madt_entries_index[index]; |
| switch (h->type) { |
| case MADT_L_APIC: |
| madt_l_apic_entry((struct madt_l_apic *) h, index); |
| break; |
| case MADT_IO_APIC: |
| madt_io_apic_entry((struct madt_io_apic *) h, index); |
| break; |
| case MADT_INTR_SRC_OVRD: |
| case MADT_NMI_SRC: |
| case MADT_L_APIC_NMI: |
| case MADT_L_APIC_ADDR_OVRD: |
| case MADT_IO_SAPIC: |
| case MADT_L_SAPIC: |
| case MADT_PLATFORM_INTR_SRC: |
| printf("MADT: skipping %s entry (type=%d)\n", entry[h->type], h->type); |
| break; |
| default: |
| if (h->type >= MADT_RESERVED_SKIP_BEGIN && h->type <= MADT_RESERVED_SKIP_END) { |
| printf("MADT: skipping reserved entry (type=%d)\n", h->type); |
| } |
| if (h->type >= MADT_RESERVED_OEM_BEGIN) { |
| printf("MADT: skipping OEM entry (type=%d)\n", h->type); |
| } |
| break; |
| } |
| } |
| if (cpu_count) |
| config.cpu_count = cpu_count; |
| } |
| void madt_l_apic_entry(struct madt_l_apic *la, __u32 index) |
| { |
| if (!madt_l_apic_entry_cnt++) { |
| madt_l_apic_entry_index = index; |
| } |
| if (!(la->flags & 0x1)) { |
| /* Processor is unusable, skip it. */ |
| return; |
| } |
| cpu_count++; |
| apic_id_mask |= 1<<la->apic_id; |
| } |
| void madt_io_apic_entry(struct madt_io_apic *ioa, __u32 index) |
| { |
| if (!madt_io_apic_entry_cnt++) { |
| /* remember index of the first io apic entry */ |
| madt_io_apic_entry_index = index; |
| io_apic = (__u32 *) (__native) ioa->io_apic_address; |
| } else { |
| /* currently not supported */ |
| return; |
| } |
| } |
| #endif /* __SMP__ */ |
| /tags/0.1.0/SPARTAN/genarch/src/acpi/acpi.c |
|---|
| 0,0 → 1,175 |
| /* |
| * Copyright (C) 2005 Jakub Jermar |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <genarch/acpi/acpi.h> |
| #include <genarch/acpi/madt.h> |
| #include <arch/bios/bios.h> |
| #include <mm/page.h> |
| #include <print.h> |
| #define RSDP_SIGNATURE "RSD PTR " |
| #define RSDP_REVISION_OFFS 15 |
| struct acpi_rsdp *acpi_rsdp = NULL; |
| struct acpi_rsdt *acpi_rsdt = NULL; |
| struct acpi_xsdt *acpi_xsdt = NULL; |
| struct acpi_signature_map signature_map[] = { |
| { (__u8 *)"APIC", (struct acpi_sdt_header **) &acpi_madt, "Multiple APIC Description Table" } |
| }; |
| static int rsdp_check(__u8 *rsdp) { |
| struct acpi_rsdp *r = (struct acpi_rsdp *) rsdp; |
| __u8 sum = 0; |
| int i; |
| for (i=0; i<20; i++) |
| sum += rsdp[i]; |
| if (sum) |
| return 0; /* bad checksum */ |
| if (r->revision == 0) |
| return 1; /* ACPI 1.0 */ |
| for (; i<r->length; i++) |
| sum += rsdp[i]; |
| return !sum; |
| } |
| int acpi_sdt_check(__u8 *sdt) |
| { |
| struct acpi_sdt_header *h = (struct acpi_sdt_header *) sdt; |
| __u8 sum = 0; |
| int i; |
| for (i=0; i<h->length; i++) |
| sum += sdt[i]; |
| return !sum; |
| } |
| static void map_sdt(struct acpi_sdt_header *sdt) |
| { |
| map_page_to_frame((__address) sdt, (__address) sdt, PAGE_NOT_CACHEABLE, 0); |
| map_structure((__address) sdt, sdt->length); |
| } |
| static void configure_via_rsdt(void) |
| { |
| int i, j, cnt = (acpi_rsdt->header.length - sizeof(struct acpi_sdt_header))/sizeof(__u32); |
| for (i=0; i<cnt; i++) { |
| for (j=0; j<sizeof(signature_map)/sizeof(struct acpi_signature_map); j++) { |
| struct acpi_sdt_header *h = (struct acpi_sdt_header *) (__native) acpi_rsdt->entry[i]; |
| map_sdt(h); |
| if (*((__u32 *) &h->signature[0])==*((__u32 *) &signature_map[j].signature[0])) { |
| if (!acpi_sdt_check((__u8 *) h)) |
| goto next; |
| *signature_map[j].sdt_ptr = h; |
| printf("%P: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description); |
| } |
| } |
| next: |
| ; |
| } |
| } |
| static void configure_via_xsdt(void) |
| { |
| int i, j, cnt = (acpi_xsdt->header.length - sizeof(struct acpi_sdt_header))/sizeof(__u64); |
| for (i=0; i<cnt; i++) { |
| for (j=0; j<sizeof(signature_map)/sizeof(struct acpi_signature_map); j++) { |
| struct acpi_sdt_header *h = (struct acpi_sdt_header *) ((__address) acpi_rsdt->entry[i]); |
| map_sdt(h); |
| if (*((__u32 *) &h->signature[0])==*((__u32 *) &signature_map[j].signature[0])) { |
| if (!acpi_sdt_check((__u8 *) h)) |
| goto next; |
| *signature_map[j].sdt_ptr = h; |
| printf("%P: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description); |
| } |
| } |
| next: |
| ; |
| } |
| } |
| void acpi_init(void) |
| { |
| __u8 *addr[2] = { NULL, (__u8 *) PA2KA(0xe0000) }; |
| int i, j, length[2] = { 1024, 128*1024 }; |
| __u64 *sig = (__u64 *) RSDP_SIGNATURE; |
| /* |
| * Find Root System Description Pointer |
| * 1. search first 1K of EBDA |
| * 2. search 128K starting at 0xe0000 |
| */ |
| addr[0] = (__u8 *) PA2KA(ebda); |
| for (i = (ebda ? 0 : 1); i < 2; i++) { |
| for (j = 0; j < length[i]; j += 16) { |
| if (*((__u64 *) &addr[i][j]) == *sig && rsdp_check(&addr[i][j])) { |
| acpi_rsdp = (struct acpi_rsdp *) &addr[i][j]; |
| goto rsdp_found; |
| } |
| } |
| } |
| return; |
| rsdp_found: |
| printf("%P: ACPI Root System Description Pointer\n", acpi_rsdp); |
| acpi_rsdt = (struct acpi_rsdt *) (__native) acpi_rsdp->rsdt_address; |
| if (acpi_rsdp->revision) acpi_xsdt = (struct acpi_xsdt *) ((__address) acpi_rsdp->xsdt_address); |
| if (acpi_rsdt) map_sdt((struct acpi_sdt_header *) acpi_rsdt); |
| if (acpi_xsdt) map_sdt((struct acpi_sdt_header *) acpi_xsdt); |
| if (acpi_rsdt && !acpi_sdt_check((__u8 *) acpi_rsdt)) { |
| printf("RSDT: %s\n", "bad checksum"); |
| return; |
| } |
| if (acpi_xsdt && !acpi_sdt_check((__u8 *) acpi_xsdt)) { |
| printf("XSDT: %s\n", "bad checksum"); |
| return; |
| } |
| if (acpi_xsdt) configure_via_xsdt(); |
| else if (acpi_rsdt) configure_via_rsdt(); |
| } |