Subversion Repositories HelenOS

Rev

Rev 2927 | Details | Compare with Previous | Last modification | View Log | RSS feed

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