Subversion Repositories HelenOS

/*

 * Copyright (c) 2008 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 ia32   

 * @{

 */

/** @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

static int mps_fs_check(uint8_t *base);

static int mps_ct_check(void);

static int configure_via_ct(void);

static int configure_via_default(uint8_t n);

static int ct_processor_entry(struct __processor_entry *pr);

static void ct_bus_entry(struct __bus_entry *bus);

static void ct_io_apic_entry(struct __io_apic_entry *ioa);

static void ct_io_intr_entry(struct __io_intr_entry *iointr);

static void ct_l_intr_entry(struct __l_intr_entry *lintr);

static 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;

unsigned int processor_entry_cnt = 0;

unsigned int bus_entry_cnt = 0;

unsigned int io_apic_entry_cnt = 0;

unsigned int io_intr_entry_cnt = 0;

unsigned int l_intr_entry_cnt = 0;

/*

 * 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(unsigned 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 (bool) ((processor_entries[i].cpu_flags & 0x01) == 0x01);

}

bool is_bsp(index_t i)

{

    ASSERT(i < processor_entry_cnt);

    return (bool) ((processor_entries[i].cpu_flags & 0x02) == 0x02);

}

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)

{

    unsigned int i;

    uint8_t sum;

    for (i = 0, sum = 0; i < 16; i++)

        sum = (uint8_t) (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 = (uint8_t) (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 = (uint8_t) (sum + ext[i]);

    return sum == ct->ext_table_checksum;

}

void mps_init(void)

{

    uint8_t *addr[2] = { NULL, (uint8_t *) PA2KA(0xf0000) };

    unsigned 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", __func__);

            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;

    unsigned int i, cnt;

    if (ct->signature != CT_SIGNATURE) {

        printf("%s: bad ct->signature\n", __func__);

        return 1;

    }

    if (!mps_ct_check()) {

        printf("%s: bad ct checksum\n", __func__);

        return 1;

    }

    if (ct->oem_table) {

        printf("%s: ct->oem_table not supported\n", __func__);

        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", __func__);

            return 1;

        }

    }

    /*

     * Process extended entries.

     */

    ct_extended_entries();

    return cnt;

}

int configure_via_default(uint8_t n __attribute__((unused)))

{

    /*

     * Not yet implemented.

     */

    printf("%s: not supported\n", __func__);

    return 1;

}

int ct_processor_entry(struct __processor_entry *pr __attribute__((unused)))

{

    /*

     * 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 __attribute__((unused)))

{

#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 unsigned 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 __attribute__((unused)))

{

#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 __attribute__((unused)))

{

#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(unsigned int irq)

{

    unsigned 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 */

/** @}

 */