Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia32/src/smp/smp.c

    r99d6fd0 r99718a2e  
    6262void smp_init(void)
    6363{
    64         uintptr_t l_apic_address, io_apic_address;
    65 
    6664        if (acpi_madt) {
    6765                acpi_madt_parse();
    6866                ops = &madt_config_operations;
    6967        }
     68       
    7069        if (config.cpu_count == 1) {
    7170                mps_init();
    7271                ops = &mps_config_operations;
    7372        }
    74 
    75         l_apic_address = (uintptr_t) frame_alloc(ONE_FRAME,
    76             FRAME_ATOMIC | FRAME_KA);
    77         if (!l_apic_address)
    78                 panic("Cannot allocate address for l_apic.");
    79 
    80         io_apic_address = (uintptr_t) frame_alloc(ONE_FRAME,
    81             FRAME_ATOMIC | FRAME_KA);
    82         if (!io_apic_address)
    83                 panic("Cannot allocate address for io_apic.");
    84 
    85         if (config.cpu_count > 1) {             
    86                 page_mapping_insert(AS_KERNEL, l_apic_address,
    87                     (uintptr_t) l_apic, PAGE_NOT_CACHEABLE | PAGE_WRITE);
    88                 page_mapping_insert(AS_KERNEL, io_apic_address,
    89                     (uintptr_t) io_apic, PAGE_NOT_CACHEABLE | PAGE_WRITE);
    90                                  
    91                 l_apic = (uint32_t *) l_apic_address;
    92                 io_apic = (uint32_t *) io_apic_address;
     73       
     74        if (config.cpu_count > 1) {
     75                l_apic = (uint32_t *) hw_map((uintptr_t) l_apic, PAGE_SIZE);
     76                io_apic = (uint32_t *) hw_map((uintptr_t) io_apic, PAGE_SIZE);
    9377        }
    9478}
     
    10690       
    10791        ASSERT(ops != NULL);
    108 
     92       
    10993        /*
    11094         * We need to access data in frame 0.
    11195         * We boldly make use of kernel address space mapping.
    11296         */
    113 
     97       
    11498        /*
    11599         * Set the warm-reset vector to the real-mode address of 4K-aligned ap_boot()
    116100         */
    117101        *((uint16_t *) (PA2KA(0x467 + 0))) =
    118             (uint16_t) (((uintptr_t) ap_boot) >> 4);    /* segment */
    119         *((uint16_t *) (PA2KA(0x467 + 2))) = 0;         /* offset */
     102            (uint16_t) (((uintptr_t) ap_boot) >> 4);  /* segment */
     103        *((uint16_t *) (PA2KA(0x467 + 2))) = 0;       /* offset */
    120104       
    121105        /*
     
    123107         * BIOS will not do the POST after the INIT signal.
    124108         */
    125         pio_write_8((ioport8_t *)0x70, 0xf);
    126         pio_write_8((ioport8_t *)0x71, 0xa);
    127 
     109        pio_write_8((ioport8_t *) 0x70, 0xf);
     110        pio_write_8((ioport8_t *) 0x71, 0xa);
     111       
    128112        pic_disable_irqs(0xffff);
    129113        apic_init();
    130114       
    131         uint8_t apic = l_apic_id();
    132 
    133         for (i = 0; i < ops->cpu_count(); i++) {
    134                 descriptor_t *gdt_new;
    135                
     115        for (i = 0; i < config.cpu_count; i++) {
    136116                /*
    137117                 * Skip processors marked unusable.
     
    139119                if (!ops->cpu_enabled(i))
    140120                        continue;
    141 
     121               
    142122                /*
    143123                 * The bootstrap processor is already up.
     
    145125                if (ops->cpu_bootstrap(i))
    146126                        continue;
    147 
    148                 if (ops->cpu_apic_id(i) == apic) {
    149                         printf("%s: bad processor entry #%u, will not send IPI "
    150                             "to myself\n", __FUNCTION__, i);
     127               
     128                if (ops->cpu_apic_id(i) == bsp_l_apic) {
     129                        printf("kmp: bad processor entry #%u, will not send IPI "
     130                            "to myself\n", i);
    151131                        continue;
    152132                }
     
    160140                 * the memory subsystem
    161141                 */
    162                 gdt_new = (descriptor_t *) malloc(GDT_ITEMS *
    163                     sizeof(descriptor_t), FRAME_ATOMIC);
     142                descriptor_t *gdt_new =
     143                    (descriptor_t *) malloc(GDT_ITEMS * sizeof(descriptor_t),
     144                    FRAME_ATOMIC);
    164145                if (!gdt_new)
    165146                        panic("Cannot allocate memory for GDT.");
    166 
     147               
    167148                memcpy(gdt_new, gdt, GDT_ITEMS * sizeof(descriptor_t));
    168149                memsetb(&gdt_new[TSS_DES], sizeof(descriptor_t), 0);
     
    170151                protected_ap_gdtr.base = KA2PA((uintptr_t) gdt_new);
    171152                gdtr.base = (uintptr_t) gdt_new;
    172 
     153               
    173154                if (l_apic_send_init_ipi(ops->cpu_apic_id(i))) {
    174155                        /*
     
    179160                        if (waitq_sleep_timeout(&ap_completion_wq, 1000000,
    180161                            SYNCH_FLAGS_NONE) == ESYNCH_TIMEOUT) {
    181                                 unsigned int cpu = (config.cpu_active > i) ?
    182                                     config.cpu_active : i;
    183162                                printf("%s: waiting for cpu%u (APIC ID = %d) "
    184                                     "timed out\n", __FUNCTION__, cpu,
     163                                    "timed out\n", __FUNCTION__, i,
    185164                                    ops->cpu_apic_id(i));
    186165                        }
Note: See TracChangeset for help on using the changeset viewer.