WebSVN – HelenOS – Diff – /trunk/kernel/arch/ia32xen/src/smp/mps.c


/*
 * Copyright (c) 2001-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.
 */
 
/** @addtogroup ia32xen
 * @{
 */
/** @file
 */
 
#ifdef CONFIG_SMP
 
#include <config.h>
#include <print.h>
#include <debug.h>
#include <arch/smp/mps.h>
#include <arch/smp/apic.h>
#include <arch/smp/smp.h>
#include <func.h>
#include <arch/types.h>
 
#include <cpu.h>
#include <arch/asm.h>
#include <arch/bios/bios.h>
#include <mm/frame.h>
 
/*
 * MultiProcessor Specification detection code.
 */
 
#define FS_SIGNATURE    0x5f504d5f
#define CT_SIGNATURE    0x504d4350
 
int mps_fs_check(uint8_t *base);
int mps_ct_check(void);
 
int configure_via_ct(void);
int configure_via_default(uint8_t n);
 
int ct_processor_entry(struct __processor_entry *pr);
void ct_bus_entry(struct __bus_entry *bus);
void ct_io_apic_entry(struct __io_apic_entry *ioa);
void ct_io_intr_entry(struct __io_intr_entry *iointr);
void ct_l_intr_entry(struct __l_intr_entry *lintr);
 
void ct_extended_entries(void);
 
static struct mps_fs *fs;
static struct mps_ct *ct;
 
struct __processor_entry *processor_entries = NULL;
struct __bus_entry *bus_entries = NULL;
struct __io_apic_entry *io_apic_entries = NULL;
struct __io_intr_entry *io_intr_entries = NULL;
struct __l_intr_entry *l_intr_entries = NULL;
 
int processor_entry_cnt = 0;
int bus_entry_cnt = 0;
int io_apic_entry_cnt = 0;
int io_intr_entry_cnt = 0;
int l_intr_entry_cnt = 0;
 
waitq_t ap_completion_wq;
 
/*
 * Implementation of IA-32 SMP configuration interface.
 */
static count_t get_cpu_count(void);
static bool is_cpu_enabled(index_t i);
static bool is_bsp(index_t i);
static uint8_t get_cpu_apic_id(index_t i);
static int mps_irq_to_pin(int irq);
 
struct smp_config_operations mps_config_operations = {
    .cpu_count = get_cpu_count,
    .cpu_enabled = is_cpu_enabled,
    .cpu_bootstrap = is_bsp,
    .cpu_apic_id = get_cpu_apic_id,
    .irq_to_pin = mps_irq_to_pin
};
 
count_t get_cpu_count(void)
{
    return processor_entry_cnt;
}
 
bool is_cpu_enabled(index_t i)
{
    ASSERT(i < processor_entry_cnt);
    return processor_entries[i].cpu_flags & 0x1;
}
 
bool is_bsp(index_t i)
{
    ASSERT(i < processor_entry_cnt);
    return processor_entries[i].cpu_flags & 0x2;
}
 
uint8_t get_cpu_apic_id(index_t i)
{
    ASSERT(i < processor_entry_cnt);
    return processor_entries[i].l_apic_id;
}
 
 
/*
 * Used to check the integrity of the MP Floating Structure.
 */
int mps_fs_check(uint8_t *base)
{
    int i;
    uint8_t sum;
   
    for (i = 0, sum = 0; i < 16; i++)
        sum += base[i];
   
    return !sum;
}
 
/*
 * Used to check the integrity of the MP Configuration Table.
 */
int mps_ct_check(void)
{
    uint8_t *base = (uint8_t *) ct;
    uint8_t *ext = base + ct->base_table_length;
    uint8_t sum;
    int i; 
   
    /* count the checksum for the base table */
    for (i=0,sum=0; i < ct->base_table_length; i++)
        sum += base[i];
       
    if (sum)
        return 0;
       
    /* count the checksum for the extended table */
    for (i=0,sum=0; i < ct->ext_table_length; i++)
        sum += ext[i];
       
    return sum == ct->ext_table_checksum;
}
 
void mps_init(void)
{
    uint8_t *addr[2] = { NULL, (uint8_t *) PA2KA(0xf0000) };
    int i, j, length[2] = { 1024, 64*1024 };
   
 
    /*
     * Find MP Floating Pointer Structure
     * 1a. search first 1K of EBDA
     * 1b. if EBDA is undefined, search last 1K of base memory
     *  2. search 64K starting at 0xf0000
     */
 
    addr[0] = (uint8_t *) PA2KA(ebda ? ebda : 639 * 1024);
    for (i = 0; i < 2; i++) {
        for (j = 0; j < length[i]; j += 16) {
            if (*((uint32_t *) &addr[i][j]) == FS_SIGNATURE && mps_fs_check(&addr[i][j])) {
                fs = (struct mps_fs *) &addr[i][j];
                goto fs_found;
            }
        }
    }
 
    return;
   
fs_found:
    printf("%p: MPS Floating Pointer Structure\n", fs);
 
    if (fs->config_type == 0 && fs->configuration_table) {
        if (fs->mpfib2 >> 7) {
            printf("%s: PIC mode not supported\n", __FUNCTION__);
            return;
        }
 
        ct = (struct mps_ct *)PA2KA((uintptr_t)fs->configuration_table);
        config.cpu_count = configure_via_ct();
    }
    else
        config.cpu_count = configure_via_default(fs->config_type);
 
    return;
}
 
int configure_via_ct(void)
{
    uint8_t *cur;
    int i, cnt;
       
    if (ct->signature != CT_SIGNATURE) {
        printf("%s: bad ct->signature\n", __FUNCTION__);
        return 1;
    }
    if (!mps_ct_check()) {
        printf("%s: bad ct checksum\n", __FUNCTION__);
        return 1;
    }
    if (ct->oem_table) {
        printf("%s: ct->oem_table not supported\n", __FUNCTION__);
        return 1;
    }
   
    l_apic = (uint32_t *)(uintptr_t)ct->l_apic;
 
    cnt = 0;
    cur = &ct->base_table[0];
    for (i=0; i < ct->entry_count; i++) {
        switch (*cur) {
            /* Processor entry */
            case 0:
                processor_entries = processor_entries ? processor_entries : (struct __processor_entry *) cur;
                processor_entry_cnt++;
                cnt += ct_processor_entry((struct __processor_entry *) cur);
                cur += 20;
                break;
 
            /* Bus entry */
            case 1:
                bus_entries = bus_entries ? bus_entries : (struct __bus_entry *) cur;
                bus_entry_cnt++;
                ct_bus_entry((struct __bus_entry *) cur);
                cur += 8;
                break;
               
            /* I/O Apic */
            case 2:
                io_apic_entries = io_apic_entries ? io_apic_entries : (struct __io_apic_entry *) cur;
                io_apic_entry_cnt++;
                ct_io_apic_entry((struct __io_apic_entry *) cur);
                cur += 8;
                break;
               
            /* I/O Interrupt Assignment */
            case 3:
                io_intr_entries = io_intr_entries ? io_intr_entries : (struct __io_intr_entry *) cur;
                io_intr_entry_cnt++;
                ct_io_intr_entry((struct __io_intr_entry *) cur);
                cur += 8;
                break;
 
            /* Local Interrupt Assignment */
            case 4:
                l_intr_entries = l_intr_entries ? l_intr_entries : (struct __l_intr_entry *) cur;
                l_intr_entry_cnt++;
                ct_l_intr_entry((struct __l_intr_entry *) cur);
                cur += 8;
                break;
 
            default:
                /*
                 * Something is wrong. Fallback to UP mode.
                 */
                 
                printf("%s: ct badness\n", __FUNCTION__);
                return 1;
        }
    }
   
    /*
     * Process extended entries.
     */
    ct_extended_entries();
    return cnt;
}
 
int configure_via_default(uint8_t n)
{
    /*
     * Not yet implemented.
     */
    printf("%s: not supported\n", __FUNCTION__);
    return 1;
}
 
 
int ct_processor_entry(struct __processor_entry *pr)
{
    /*
     * Ignore processors which are not marked enabled.
     */
    if ((pr->cpu_flags & (1<<0)) == 0)
        return 0;
   
    apic_id_mask |= (1<<pr->l_apic_id);
    return 1;
}
 
void ct_bus_entry(struct __bus_entry *bus)
{
#ifdef MPSCT_VERBOSE
    char buf[7];
    memcpy((void *) buf, (void *) bus->bus_type, 6);
    buf[6] = 0;
    printf("bus%d: %s\n", bus->bus_id, buf);
#endif
}
 
void ct_io_apic_entry(struct __io_apic_entry *ioa)
{
    static int io_apic_count = 0;
 
    /* this ioapic is marked unusable */
    if ((ioa->io_apic_flags & 1) == 0)
        return;
   
    if (io_apic_count++ > 0) {
        /*
         * Multiple IO APIC's are currently not supported.
         */
        return;
    }
   
    io_apic = (uint32_t *)(uintptr_t)ioa->io_apic;
}
 
//#define MPSCT_VERBOSE
void ct_io_intr_entry(struct __io_intr_entry *iointr)
{
#ifdef MPSCT_VERBOSE
    switch (iointr->intr_type) {
        case 0: printf("INT"); break;
        case 1: printf("NMI"); break;
        case 2: printf("SMI"); break;
        case 3: printf("ExtINT"); break;
    }
    putchar(',');
    switch (iointr->poel&3) {
        case 0: printf("bus-like"); break;
        case 1: printf("active high"); break;
        case 2: printf("reserved"); break;
        case 3: printf("active low"); break;
    }
    putchar(',');
    switch ((iointr->poel>>2)&3) {
        case 0: printf("bus-like"); break;
        case 1: printf("edge-triggered"); break;
        case 2: printf("reserved"); break;
        case 3: printf("level-triggered"); break;
    }
    putchar(',');
    printf("bus%d,irq%d", iointr->src_bus_id, iointr->src_bus_irq);
    putchar(',');
    printf("io_apic%d,pin%d", iointr->dst_io_apic_id, iointr->dst_io_apic_pin);
    putchar('\n'); 
#endif
}
 
void ct_l_intr_entry(struct __l_intr_entry *lintr)
{
#ifdef MPSCT_VERBOSE
    switch (lintr->intr_type) {
        case 0: printf("INT"); break;
        case 1: printf("NMI"); break;
        case 2: printf("SMI"); break;
        case 3: printf("ExtINT"); break;
    }
    putchar(',');
    switch (lintr->poel&3) {
        case 0: printf("bus-like"); break;
        case 1: printf("active high"); break;
        case 2: printf("reserved"); break;
        case 3: printf("active low"); break;
    }
    putchar(',');
    switch ((lintr->poel>>2)&3) {
        case 0: printf("bus-like"); break;
        case 1: printf("edge-triggered"); break;
        case 2: printf("reserved"); break;
        case 3: printf("level-triggered"); break;
    }
    putchar(',');
    printf("bus%d,irq%d", lintr->src_bus_id, lintr->src_bus_irq);
    putchar(',');
    printf("l_apic%d,pin%d", lintr->dst_l_apic_id, lintr->dst_l_apic_pin);
    putchar('\n');
#endif
}
 
void ct_extended_entries(void)
{
    uint8_t *ext = (uint8_t *) ct + ct->base_table_length;
    uint8_t *cur;
 
    for (cur = ext; cur < ext + ct->ext_table_length; cur += cur[CT_EXT_ENTRY_LEN]) {
        switch (cur[CT_EXT_ENTRY_TYPE]) {
            default:
                printf("%p: skipping MP Configuration Table extended entry type %d\n", cur, cur[CT_EXT_ENTRY_TYPE]);
                break;
        }
    }
}
 
int mps_irq_to_pin(int irq)
{
    int i;
   
    for(i=0;i<io_intr_entry_cnt;i++) {
        if (io_intr_entries[i].src_bus_irq == irq && io_intr_entries[i].intr_type == 0)
            return io_intr_entries[i].dst_io_apic_pin;
    }
   
    return -1;
}
 
#endif /* CONFIG_SMP */
 
/** @}
 */
 

Rev 2071	Rev 2089
1	/*	1	/*
2	* Copyright (c) 2001-2005 Jakub Jermar	2	* Copyright (c) 2001-2005 Jakub Jermar
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup ia32xen	29	/** @addtogroup ia32xen
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#ifdef CONFIG_SMP	35	#ifdef CONFIG_SMP
36		36
37	#include <config.h>	37	#include <config.h>
38	#include <print.h>	38	#include <print.h>
39	#include <debug.h>	39	#include <debug.h>
40	#include <arch/smp/mps.h>	40	#include <arch/smp/mps.h>
41	#include <arch/smp/apic.h>	41	#include <arch/smp/apic.h>
42	#include <arch/smp/smp.h>	42	#include <arch/smp/smp.h>
43	#include <func.h>	43	#include <func.h>
44	#include <arch/types.h>	44	#include <arch/types.h>
45	#include <typedefs.h>	-
46	#include <cpu.h>	45	#include <cpu.h>
47	#include <arch/asm.h>	46	#include <arch/asm.h>
48	#include <arch/bios/bios.h>	47	#include <arch/bios/bios.h>
49	#include <mm/frame.h>	48	#include <mm/frame.h>
50		49
51	/*	50	/*
52	* MultiProcessor Specification detection code.	51	* MultiProcessor Specification detection code.
53	*/	52	*/
54		53
55	#define FS_SIGNATURE 0x5f504d5f	54	#define FS_SIGNATURE 0x5f504d5f
56	#define CT_SIGNATURE 0x504d4350	55	#define CT_SIGNATURE 0x504d4350
57		56
58	int mps_fs_check(uint8_t *base);	57	int mps_fs_check(uint8_t *base);
59	int mps_ct_check(void);	58	int mps_ct_check(void);
60		59
61	int configure_via_ct(void);	60	int configure_via_ct(void);
62	int configure_via_default(uint8_t n);	61	int configure_via_default(uint8_t n);
63		62
64	int ct_processor_entry(struct __processor_entry *pr);	63	int ct_processor_entry(struct __processor_entry *pr);
65	void ct_bus_entry(struct __bus_entry *bus);	64	void ct_bus_entry(struct __bus_entry *bus);
66	void ct_io_apic_entry(struct __io_apic_entry *ioa);	65	void ct_io_apic_entry(struct __io_apic_entry *ioa);
67	void ct_io_intr_entry(struct __io_intr_entry *iointr);	66	void ct_io_intr_entry(struct __io_intr_entry *iointr);
68	void ct_l_intr_entry(struct __l_intr_entry *lintr);	67	void ct_l_intr_entry(struct __l_intr_entry *lintr);
69		68
70	void ct_extended_entries(void);	69	void ct_extended_entries(void);
71		70
72	static struct mps_fs *fs;	71	static struct mps_fs *fs;
73	static struct mps_ct *ct;	72	static struct mps_ct *ct;
74		73
75	struct __processor_entry *processor_entries = NULL;	74	struct __processor_entry *processor_entries = NULL;
76	struct __bus_entry *bus_entries = NULL;	75	struct __bus_entry *bus_entries = NULL;
77	struct __io_apic_entry *io_apic_entries = NULL;	76	struct __io_apic_entry *io_apic_entries = NULL;
78	struct __io_intr_entry *io_intr_entries = NULL;	77	struct __io_intr_entry *io_intr_entries = NULL;
79	struct __l_intr_entry *l_intr_entries = NULL;	78	struct __l_intr_entry *l_intr_entries = NULL;
80		79
81	int processor_entry_cnt = 0;	80	int processor_entry_cnt = 0;
82	int bus_entry_cnt = 0;	81	int bus_entry_cnt = 0;
83	int io_apic_entry_cnt = 0;	82	int io_apic_entry_cnt = 0;
84	int io_intr_entry_cnt = 0;	83	int io_intr_entry_cnt = 0;
85	int l_intr_entry_cnt = 0;	84	int l_intr_entry_cnt = 0;
86		85
87	waitq_t ap_completion_wq;	86	waitq_t ap_completion_wq;
88		87
89	/*	88	/*
90	* Implementation of IA-32 SMP configuration interface.	89	* Implementation of IA-32 SMP configuration interface.
91	*/	90	*/
92	static count_t get_cpu_count(void);	91	static count_t get_cpu_count(void);
93	static bool is_cpu_enabled(index_t i);	92	static bool is_cpu_enabled(index_t i);
94	static bool is_bsp(index_t i);	93	static bool is_bsp(index_t i);
95	static uint8_t get_cpu_apic_id(index_t i);	94	static uint8_t get_cpu_apic_id(index_t i);
96	static int mps_irq_to_pin(int irq);	95	static int mps_irq_to_pin(int irq);
97		96
98	struct smp_config_operations mps_config_operations = {	97	struct smp_config_operations mps_config_operations = {
99	.cpu_count = get_cpu_count,	98	.cpu_count = get_cpu_count,
100	.cpu_enabled = is_cpu_enabled,	99	.cpu_enabled = is_cpu_enabled,
101	.cpu_bootstrap = is_bsp,	100	.cpu_bootstrap = is_bsp,
102	.cpu_apic_id = get_cpu_apic_id,	101	.cpu_apic_id = get_cpu_apic_id,
103	.irq_to_pin = mps_irq_to_pin	102	.irq_to_pin = mps_irq_to_pin
104	};	103	};
105		104
106	count_t get_cpu_count(void)	105	count_t get_cpu_count(void)
107	{	106	{
108	return processor_entry_cnt;	107	return processor_entry_cnt;
109	}	108	}
110		109
111	bool is_cpu_enabled(index_t i)	110	bool is_cpu_enabled(index_t i)
112	{	111	{
113	ASSERT(i < processor_entry_cnt);	112	ASSERT(i < processor_entry_cnt);
114	return processor_entries[i].cpu_flags & 0x1;	113	return processor_entries[i].cpu_flags & 0x1;
115	}	114	}
116		115
117	bool is_bsp(index_t i)	116	bool is_bsp(index_t i)
118	{	117	{
119	ASSERT(i < processor_entry_cnt);	118	ASSERT(i < processor_entry_cnt);
120	return processor_entries[i].cpu_flags & 0x2;	119	return processor_entries[i].cpu_flags & 0x2;
121	}	120	}
122		121
123	uint8_t get_cpu_apic_id(index_t i)	122	uint8_t get_cpu_apic_id(index_t i)
124	{	123	{
125	ASSERT(i < processor_entry_cnt);	124	ASSERT(i < processor_entry_cnt);
126	return processor_entries[i].l_apic_id;	125	return processor_entries[i].l_apic_id;
127	}	126	}
128		127
129		128
130	/*	129	/*
131	* Used to check the integrity of the MP Floating Structure.	130	* Used to check the integrity of the MP Floating Structure.
132	*/	131	*/
133	int mps_fs_check(uint8_t *base)	132	int mps_fs_check(uint8_t *base)
134	{	133	{
135	int i;	134	int i;
136	uint8_t sum;	135	uint8_t sum;
137		136
138	for (i = 0, sum = 0; i < 16; i++)	137	for (i = 0, sum = 0; i < 16; i++)
139	sum += base[i];	138	sum += base[i];
140		139
141	return !sum;	140	return !sum;
142	}	141	}
143		142
144	/*	143	/*
145	* Used to check the integrity of the MP Configuration Table.	144	* Used to check the integrity of the MP Configuration Table.
146	*/	145	*/
147	int mps_ct_check(void)	146	int mps_ct_check(void)
148	{	147	{
149	uint8_t base = (uint8_t ) ct;	148	uint8_t base = (uint8_t ) ct;
150	uint8_t *ext = base + ct->base_table_length;	149	uint8_t *ext = base + ct->base_table_length;
151	uint8_t sum;	150	uint8_t sum;
152	int i;	151	int i;
153		152
154	/* count the checksum for the base table */	153	/* count the checksum for the base table */
155	for (i=0,sum=0; i < ct->base_table_length; i++)	154	for (i=0,sum=0; i < ct->base_table_length; i++)
156	sum += base[i];	155	sum += base[i];
157		156
158	if (sum)	157	if (sum)
159	return 0;	158	return 0;
160		159
161	/* count the checksum for the extended table */	160	/* count the checksum for the extended table */
162	for (i=0,sum=0; i < ct->ext_table_length; i++)	161	for (i=0,sum=0; i < ct->ext_table_length; i++)
163	sum += ext[i];	162	sum += ext[i];
164		163
165	return sum == ct->ext_table_checksum;	164	return sum == ct->ext_table_checksum;
166	}	165	}
167		166
168	void mps_init(void)	167	void mps_init(void)
169	{	168	{
170	uint8_t addr[2] = { NULL, (uint8_t ) PA2KA(0xf0000) };	169	uint8_t addr[2] = { NULL, (uint8_t ) PA2KA(0xf0000) };
171	int i, j, length[2] = { 1024, 64*1024 };	170	int i, j, length[2] = { 1024, 64*1024 };
172		171
173		172
174	/*	173	/*
175	* Find MP Floating Pointer Structure	174	* Find MP Floating Pointer Structure
176	* 1a. search first 1K of EBDA	175	* 1a. search first 1K of EBDA
177	* 1b. if EBDA is undefined, search last 1K of base memory	176	* 1b. if EBDA is undefined, search last 1K of base memory
178	* 2. search 64K starting at 0xf0000	177	* 2. search 64K starting at 0xf0000
179	*/	178	*/
180		179
181	addr[0] = (uint8_t ) PA2KA(ebda ? ebda : 639 1024);	180	addr[0] = (uint8_t ) PA2KA(ebda ? ebda : 639 1024);
182	for (i = 0; i < 2; i++) {	181	for (i = 0; i < 2; i++) {
183	for (j = 0; j < length[i]; j += 16) {	182	for (j = 0; j < length[i]; j += 16) {
184	if (((uint32_t ) &addr[i][j]) == FS_SIGNATURE && mps_fs_check(&addr[i][j])) {	183	if (((uint32_t ) &addr[i][j]) == FS_SIGNATURE && mps_fs_check(&addr[i][j])) {
185	fs = (struct mps_fs *) &addr[i][j];	184	fs = (struct mps_fs *) &addr[i][j];
186	goto fs_found;	185	goto fs_found;
187	}	186	}
188	}	187	}
189	}	188	}
190		189
191	return;	190	return;
192		191
193	fs_found:	192	fs_found:
194	printf("%p: MPS Floating Pointer Structure\n", fs);	193	printf("%p: MPS Floating Pointer Structure\n", fs);
195		194
196	if (fs->config_type == 0 && fs->configuration_table) {	195	if (fs->config_type == 0 && fs->configuration_table) {
197	if (fs->mpfib2 >> 7) {	196	if (fs->mpfib2 >> 7) {
198	printf("%s: PIC mode not supported\n", __FUNCTION__);	197	printf("%s: PIC mode not supported\n", __FUNCTION__);
199	return;	198	return;
200	}	199	}
201		200
202	ct = (struct mps_ct *)PA2KA((uintptr_t)fs->configuration_table);	201	ct = (struct mps_ct *)PA2KA((uintptr_t)fs->configuration_table);
203	config.cpu_count = configure_via_ct();	202	config.cpu_count = configure_via_ct();
204	}	203	}
205	else	204	else
206	config.cpu_count = configure_via_default(fs->config_type);	205	config.cpu_count = configure_via_default(fs->config_type);
207		206
208	return;	207	return;
209	}	208	}
210		209
211	int configure_via_ct(void)	210	int configure_via_ct(void)
212	{	211	{
213	uint8_t *cur;	212	uint8_t *cur;
214	int i, cnt;	213	int i, cnt;
215		214
216	if (ct->signature != CT_SIGNATURE) {	215	if (ct->signature != CT_SIGNATURE) {
217	printf("%s: bad ct->signature\n", __FUNCTION__);	216	printf("%s: bad ct->signature\n", __FUNCTION__);
218	return 1;	217	return 1;
219	}	218	}
220	if (!mps_ct_check()) {	219	if (!mps_ct_check()) {
221	printf("%s: bad ct checksum\n", __FUNCTION__);	220	printf("%s: bad ct checksum\n", __FUNCTION__);
222	return 1;	221	return 1;
223	}	222	}
224	if (ct->oem_table) {	223	if (ct->oem_table) {
225	printf("%s: ct->oem_table not supported\n", __FUNCTION__);	224	printf("%s: ct->oem_table not supported\n", __FUNCTION__);
226	return 1;	225	return 1;
227	}	226	}
228		227
229	l_apic = (uint32_t *)(uintptr_t)ct->l_apic;	228	l_apic = (uint32_t *)(uintptr_t)ct->l_apic;
230		229
231	cnt = 0;	230	cnt = 0;
232	cur = &ct->base_table[0];	231	cur = &ct->base_table[0];
233	for (i=0; i < ct->entry_count; i++) {	232	for (i=0; i < ct->entry_count; i++) {
234	switch (*cur) {	233	switch (*cur) {
235	/* Processor entry */	234	/* Processor entry */
236	case 0:	235	case 0:
237	processor_entries = processor_entries ? processor_entries : (struct __processor_entry *) cur;	236	processor_entries = processor_entries ? processor_entries : (struct __processor_entry *) cur;
238	processor_entry_cnt++;	237	processor_entry_cnt++;
239	cnt += ct_processor_entry((struct __processor_entry *) cur);	238	cnt += ct_processor_entry((struct __processor_entry *) cur);
240	cur += 20;	239	cur += 20;
241	break;	240	break;
242		241
243	/* Bus entry */	242	/* Bus entry */
244	case 1:	243	case 1:
245	bus_entries = bus_entries ? bus_entries : (struct __bus_entry *) cur;	244	bus_entries = bus_entries ? bus_entries : (struct __bus_entry *) cur;
246	bus_entry_cnt++;	245	bus_entry_cnt++;
247	ct_bus_entry((struct __bus_entry *) cur);	246	ct_bus_entry((struct __bus_entry *) cur);
248	cur += 8;	247	cur += 8;
249	break;	248	break;
250		249
251	/* I/O Apic */	250	/* I/O Apic */
252	case 2:	251	case 2:
253	io_apic_entries = io_apic_entries ? io_apic_entries : (struct __io_apic_entry *) cur;	252	io_apic_entries = io_apic_entries ? io_apic_entries : (struct __io_apic_entry *) cur;
254	io_apic_entry_cnt++;	253	io_apic_entry_cnt++;
255	ct_io_apic_entry((struct __io_apic_entry *) cur);	254	ct_io_apic_entry((struct __io_apic_entry *) cur);
256	cur += 8;	255	cur += 8;
257	break;	256	break;
258		257
259	/* I/O Interrupt Assignment */	258	/* I/O Interrupt Assignment */
260	case 3:	259	case 3:
261	io_intr_entries = io_intr_entries ? io_intr_entries : (struct __io_intr_entry *) cur;	260	io_intr_entries = io_intr_entries ? io_intr_entries : (struct __io_intr_entry *) cur;
262	io_intr_entry_cnt++;	261	io_intr_entry_cnt++;
263	ct_io_intr_entry((struct __io_intr_entry *) cur);	262	ct_io_intr_entry((struct __io_intr_entry *) cur);
264	cur += 8;	263	cur += 8;
265	break;	264	break;
266		265
267	/* Local Interrupt Assignment */	266	/* Local Interrupt Assignment */
268	case 4:	267	case 4:
269	l_intr_entries = l_intr_entries ? l_intr_entries : (struct __l_intr_entry *) cur;	268	l_intr_entries = l_intr_entries ? l_intr_entries : (struct __l_intr_entry *) cur;
270	l_intr_entry_cnt++;	269	l_intr_entry_cnt++;
271	ct_l_intr_entry((struct __l_intr_entry *) cur);	270	ct_l_intr_entry((struct __l_intr_entry *) cur);
272	cur += 8;	271	cur += 8;
273	break;	272	break;
274		273
275	default:	274	default:
276	/*	275	/*
277	* Something is wrong. Fallback to UP mode.	276	* Something is wrong. Fallback to UP mode.
278	*/	277	*/
279		278
280	printf("%s: ct badness\n", __FUNCTION__);	279	printf("%s: ct badness\n", __FUNCTION__);
281	return 1;	280	return 1;
282	}	281	}
283	}	282	}
284		283
285	/*	284	/*
286	* Process extended entries.	285	* Process extended entries.
287	*/	286	*/
288	ct_extended_entries();	287	ct_extended_entries();
289	return cnt;	288	return cnt;
290	}	289	}
291		290
292	int configure_via_default(uint8_t n)	291	int configure_via_default(uint8_t n)
293	{	292	{
294	/*	293	/*
295	* Not yet implemented.	294	* Not yet implemented.
296	*/	295	*/
297	printf("%s: not supported\n", __FUNCTION__);	296	printf("%s: not supported\n", __FUNCTION__);
298	return 1;	297	return 1;
299	}	298	}
300		299
301		300
302	int ct_processor_entry(struct __processor_entry *pr)	301	int ct_processor_entry(struct __processor_entry *pr)
303	{	302	{
304	/*	303	/*
305	* Ignore processors which are not marked enabled.	304	* Ignore processors which are not marked enabled.
306	*/	305	*/
307	if ((pr->cpu_flags & (1<<0)) == 0)	306	if ((pr->cpu_flags & (1<<0)) == 0)
308	return 0;	307	return 0;
309		308
310	apic_id_mask \|= (1<<pr->l_apic_id);	309	apic_id_mask \|= (1<<pr->l_apic_id);
311	return 1;	310	return 1;
312	}	311	}
313		312
314	void ct_bus_entry(struct __bus_entry *bus)	313	void ct_bus_entry(struct __bus_entry *bus)
315	{	314	{
316	#ifdef MPSCT_VERBOSE	315	#ifdef MPSCT_VERBOSE
317	char buf[7];	316	char buf[7];
318	memcpy((void ) buf, (void ) bus->bus_type, 6);	317	memcpy((void ) buf, (void ) bus->bus_type, 6);
319	buf[6] = 0;	318	buf[6] = 0;
320	printf("bus%d: %s\n", bus->bus_id, buf);	319	printf("bus%d: %s\n", bus->bus_id, buf);
321	#endif	320	#endif
322	}	321	}
323		322
324	void ct_io_apic_entry(struct __io_apic_entry *ioa)	323	void ct_io_apic_entry(struct __io_apic_entry *ioa)
325	{	324	{
326	static int io_apic_count = 0;	325	static int io_apic_count = 0;
327		326
328	/* this ioapic is marked unusable */	327	/* this ioapic is marked unusable */
329	if ((ioa->io_apic_flags & 1) == 0)	328	if ((ioa->io_apic_flags & 1) == 0)
330	return;	329	return;
331		330
332	if (io_apic_count++ > 0) {	331	if (io_apic_count++ > 0) {
333	/*	332	/*
334	* Multiple IO APIC's are currently not supported.	333	* Multiple IO APIC's are currently not supported.
335	*/	334	*/
336	return;	335	return;
337	}	336	}
338		337
339	io_apic = (uint32_t *)(uintptr_t)ioa->io_apic;	338	io_apic = (uint32_t *)(uintptr_t)ioa->io_apic;
340	}	339	}
341		340
342	//#define MPSCT_VERBOSE	341	//#define MPSCT_VERBOSE
343	void ct_io_intr_entry(struct __io_intr_entry *iointr)	342	void ct_io_intr_entry(struct __io_intr_entry *iointr)
344	{	343	{
345	#ifdef MPSCT_VERBOSE	344	#ifdef MPSCT_VERBOSE
346	switch (iointr->intr_type) {	345	switch (iointr->intr_type) {
347	case 0: printf("INT"); break;	346	case 0: printf("INT"); break;
348	case 1: printf("NMI"); break;	347	case 1: printf("NMI"); break;
349	case 2: printf("SMI"); break;	348	case 2: printf("SMI"); break;
350	case 3: printf("ExtINT"); break;	349	case 3: printf("ExtINT"); break;
351	}	350	}
352	putchar(',');	351	putchar(',');
353	switch (iointr->poel&3) {	352	switch (iointr->poel&3) {
354	case 0: printf("bus-like"); break;	353	case 0: printf("bus-like"); break;
355	case 1: printf("active high"); break;	354	case 1: printf("active high"); break;
356	case 2: printf("reserved"); break;	355	case 2: printf("reserved"); break;
357	case 3: printf("active low"); break;	356	case 3: printf("active low"); break;
358	}	357	}
359	putchar(',');	358	putchar(',');
360	switch ((iointr->poel>>2)&3) {	359	switch ((iointr->poel>>2)&3) {
361	case 0: printf("bus-like"); break;	360	case 0: printf("bus-like"); break;
362	case 1: printf("edge-triggered"); break;	361	case 1: printf("edge-triggered"); break;
363	case 2: printf("reserved"); break;	362	case 2: printf("reserved"); break;
364	case 3: printf("level-triggered"); break;	363	case 3: printf("level-triggered"); break;
365	}	364	}
366	putchar(',');	365	putchar(',');
367	printf("bus%d,irq%d", iointr->src_bus_id, iointr->src_bus_irq);	366	printf("bus%d,irq%d", iointr->src_bus_id, iointr->src_bus_irq);
368	putchar(',');	367	putchar(',');
369	printf("io_apic%d,pin%d", iointr->dst_io_apic_id, iointr->dst_io_apic_pin);	368	printf("io_apic%d,pin%d", iointr->dst_io_apic_id, iointr->dst_io_apic_pin);
370	putchar('\n');	369	putchar('\n');
371	#endif	370	#endif
372	}	371	}
373		372
374	void ct_l_intr_entry(struct __l_intr_entry *lintr)	373	void ct_l_intr_entry(struct __l_intr_entry *lintr)
375	{	374	{
376	#ifdef MPSCT_VERBOSE	375	#ifdef MPSCT_VERBOSE
377	switch (lintr->intr_type) {	376	switch (lintr->intr_type) {
378	case 0: printf("INT"); break;	377	case 0: printf("INT"); break;
379	case 1: printf("NMI"); break;	378	case 1: printf("NMI"); break;
380	case 2: printf("SMI"); break;	379	case 2: printf("SMI"); break;
381	case 3: printf("ExtINT"); break;	380	case 3: printf("ExtINT"); break;
382	}	381	}
383	putchar(',');	382	putchar(',');
384	switch (lintr->poel&3) {	383	switch (lintr->poel&3) {
385	case 0: printf("bus-like"); break;	384	case 0: printf("bus-like"); break;
386	case 1: printf("active high"); break;	385	case 1: printf("active high"); break;
387	case 2: printf("reserved"); break;	386	case 2: printf("reserved"); break;
388	case 3: printf("active low"); break;	387	case 3: printf("active low"); break;
389	}	388	}
390	putchar(',');	389	putchar(',');
391	switch ((lintr->poel>>2)&3) {	390	switch ((lintr->poel>>2)&3) {
392	case 0: printf("bus-like"); break;	391	case 0: printf("bus-like"); break;
393	case 1: printf("edge-triggered"); break;	392	case 1: printf("edge-triggered"); break;
394	case 2: printf("reserved"); break;	393	case 2: printf("reserved"); break;
395	case 3: printf("level-triggered"); break;	394	case 3: printf("level-triggered"); break;
396	}	395	}
397	putchar(',');	396	putchar(',');
398	printf("bus%d,irq%d", lintr->src_bus_id, lintr->src_bus_irq);	397	printf("bus%d,irq%d", lintr->src_bus_id, lintr->src_bus_irq);
399	putchar(',');	398	putchar(',');
400	printf("l_apic%d,pin%d", lintr->dst_l_apic_id, lintr->dst_l_apic_pin);	399	printf("l_apic%d,pin%d", lintr->dst_l_apic_id, lintr->dst_l_apic_pin);
401	putchar('\n');	400	putchar('\n');
402	#endif	401	#endif
403	}	402	}
404		403
405	void ct_extended_entries(void)	404	void ct_extended_entries(void)
406	{	405	{
407	uint8_t ext = (uint8_t ) ct + ct->base_table_length;	406	uint8_t ext = (uint8_t ) ct + ct->base_table_length;
408	uint8_t *cur;	407	uint8_t *cur;
409		408
410	for (cur = ext; cur < ext + ct->ext_table_length; cur += cur[CT_EXT_ENTRY_LEN]) {	409	for (cur = ext; cur < ext + ct->ext_table_length; cur += cur[CT_EXT_ENTRY_LEN]) {
411	switch (cur[CT_EXT_ENTRY_TYPE]) {	410	switch (cur[CT_EXT_ENTRY_TYPE]) {
412	default:	411	default:
413	printf("%p: skipping MP Configuration Table extended entry type %d\n", cur, cur[CT_EXT_ENTRY_TYPE]);	412	printf("%p: skipping MP Configuration Table extended entry type %d\n", cur, cur[CT_EXT_ENTRY_TYPE]);
414	break;	413	break;
415	}	414	}
416	}	415	}
417	}	416	}
418		417
419	int mps_irq_to_pin(int irq)	418	int mps_irq_to_pin(int irq)
420	{	419	{
421	int i;	420	int i;
422		421
423	for(i=0;i<io_intr_entry_cnt;i++) {	422	for(i=0;i<io_intr_entry_cnt;i++) {
424	if (io_intr_entries[i].src_bus_irq == irq && io_intr_entries[i].intr_type == 0)	423	if (io_intr_entries[i].src_bus_irq == irq && io_intr_entries[i].intr_type == 0)
425	return io_intr_entries[i].dst_io_apic_pin;	424	return io_intr_entries[i].dst_io_apic_pin;
426	}	425	}
427		426
428	return -1;	427	return -1;
429	}	428	}
430		429
431	#endif /* CONFIG_SMP */	430	#endif /* CONFIG_SMP */
432		431
433	/** @}	432	/** @}
434	*/	433	*/
435		434

Subversion Repositories HelenOS

(root)/trunk/kernel/arch/ia32xen/src/smp/mps.c – Rev 2071 → 2089