apic.c 23.3 KB
Newer Older
B
bellard 已提交
1 2
/*
 *  APIC support
3
 *
B
bellard 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16
 *  Copyright (c) 2004-2005 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
B
bellard 已提交
18
 */
19
#include "qemu-thread.h"
20
#include "apic_internal.h"
21
#include "apic.h"
22
#include "ioapic.h"
23
#include "msi.h"
24
#include "host-utils.h"
25
#include "trace.h"
26
#include "pc.h"
A
Anthony PERARD 已提交
27
#include "apic-msidef.h"
B
bellard 已提交
28

B
bellard 已提交
29 30
#define MAX_APIC_WORDS 8

31 32 33 34
#define SYNC_FROM_VAPIC                 0x1
#define SYNC_TO_VAPIC                   0x2
#define SYNC_ISR_IRR_TO_VAPIC           0x4

35
static APICCommonState *local_apics[MAX_APICS + 1];
36

37 38
static void apic_set_irq(APICCommonState *s, int vector_num, int trigger_mode);
static void apic_update_irq(APICCommonState *s);
39 40
static void apic_get_delivery_bitmask(uint32_t *deliver_bitmask,
                                      uint8_t dest, uint8_t dest_mode);
41

42 43 44 45 46 47
/* Find first bit starting from msb */
static int fls_bit(uint32_t value)
{
    return 31 - clz32(value);
}

48
/* Find first bit starting from lsb */
B
bellard 已提交
49 50
static int ffs_bit(uint32_t value)
{
51
    return ctz32(value);
B
bellard 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
}

static inline void set_bit(uint32_t *tab, int index)
{
    int i, mask;
    i = index >> 5;
    mask = 1 << (index & 0x1f);
    tab[i] |= mask;
}

static inline void reset_bit(uint32_t *tab, int index)
{
    int i, mask;
    i = index >> 5;
    mask = 1 << (index & 0x1f);
    tab[i] &= ~mask;
}

70 71 72 73 74 75 76 77
static inline int get_bit(uint32_t *tab, int index)
{
    int i, mask;
    i = index >> 5;
    mask = 1 << (index & 0x1f);
    return !!(tab[i] & mask);
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
/* return -1 if no bit is set */
static int get_highest_priority_int(uint32_t *tab)
{
    int i;
    for (i = 7; i >= 0; i--) {
        if (tab[i] != 0) {
            return i * 32 + fls_bit(tab[i]);
        }
    }
    return -1;
}

static void apic_sync_vapic(APICCommonState *s, int sync_type)
{
    VAPICState vapic_state;
    size_t length;
    off_t start;
    int vector;

    if (!s->vapic_paddr) {
        return;
    }
    if (sync_type & SYNC_FROM_VAPIC) {
        cpu_physical_memory_rw(s->vapic_paddr, (void *)&vapic_state,
                               sizeof(vapic_state), 0);
        s->tpr = vapic_state.tpr;
    }
    if (sync_type & (SYNC_TO_VAPIC | SYNC_ISR_IRR_TO_VAPIC)) {
        start = offsetof(VAPICState, isr);
        length = offsetof(VAPICState, enabled) - offsetof(VAPICState, isr);

        if (sync_type & SYNC_TO_VAPIC) {
            assert(qemu_cpu_is_self(s->cpu_env));

            vapic_state.tpr = s->tpr;
            vapic_state.enabled = 1;
            start = 0;
            length = sizeof(VAPICState);
        }

        vector = get_highest_priority_int(s->isr);
        if (vector < 0) {
            vector = 0;
        }
        vapic_state.isr = vector & 0xf0;

        vapic_state.zero = 0;

        vector = get_highest_priority_int(s->irr);
        if (vector < 0) {
            vector = 0;
        }
        vapic_state.irr = vector & 0xff;

        cpu_physical_memory_write_rom(s->vapic_paddr + start,
                                      ((void *)&vapic_state) + start, length);
    }
}

static void apic_vapic_base_update(APICCommonState *s)
{
    apic_sync_vapic(s, SYNC_TO_VAPIC);
}

142
static void apic_local_deliver(APICCommonState *s, int vector)
143 144 145 146
{
    uint32_t lvt = s->lvt[vector];
    int trigger_mode;

147 148
    trace_apic_local_deliver(vector, (lvt >> 8) & 7);

149 150 151 152 153
    if (lvt & APIC_LVT_MASKED)
        return;

    switch ((lvt >> 8) & 7) {
    case APIC_DM_SMI:
154
        cpu_interrupt(s->cpu_env, CPU_INTERRUPT_SMI);
155 156 157
        break;

    case APIC_DM_NMI:
158
        cpu_interrupt(s->cpu_env, CPU_INTERRUPT_NMI);
159 160 161
        break;

    case APIC_DM_EXTINT:
162
        cpu_interrupt(s->cpu_env, CPU_INTERRUPT_HARD);
163 164 165 166 167 168 169 170 171 172 173
        break;

    case APIC_DM_FIXED:
        trigger_mode = APIC_TRIGGER_EDGE;
        if ((vector == APIC_LVT_LINT0 || vector == APIC_LVT_LINT1) &&
            (lvt & APIC_LVT_LEVEL_TRIGGER))
            trigger_mode = APIC_TRIGGER_LEVEL;
        apic_set_irq(s, lvt & 0xff, trigger_mode);
    }
}

B
Blue Swirl 已提交
174
void apic_deliver_pic_intr(DeviceState *d, int level)
175
{
176
    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
Blue Swirl 已提交
177

178 179 180
    if (level) {
        apic_local_deliver(s, APIC_LVT_LINT0);
    } else {
181 182 183 184 185 186 187 188 189
        uint32_t lvt = s->lvt[APIC_LVT_LINT0];

        switch ((lvt >> 8) & 7) {
        case APIC_DM_FIXED:
            if (!(lvt & APIC_LVT_LEVEL_TRIGGER))
                break;
            reset_bit(s->irr, lvt & 0xff);
            /* fall through */
        case APIC_DM_EXTINT:
190
            cpu_reset_interrupt(s->cpu_env, CPU_INTERRUPT_HARD);
191 192 193 194 195
            break;
        }
    }
}

196
static void apic_external_nmi(APICCommonState *s)
197 198 199 200
{
    apic_local_deliver(s, APIC_LVT_LINT1);
}

B
bellard 已提交
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
#define foreach_apic(apic, deliver_bitmask, code) \
{\
    int __i, __j, __mask;\
    for(__i = 0; __i < MAX_APIC_WORDS; __i++) {\
        __mask = deliver_bitmask[__i];\
        if (__mask) {\
            for(__j = 0; __j < 32; __j++) {\
                if (__mask & (1 << __j)) {\
                    apic = local_apics[__i * 32 + __j];\
                    if (apic) {\
                        code;\
                    }\
                }\
            }\
        }\
    }\
}

219
static void apic_bus_deliver(const uint32_t *deliver_bitmask,
220
                             uint8_t delivery_mode, uint8_t vector_num,
221 222
                             uint8_t trigger_mode)
{
223
    APICCommonState *apic_iter;
224 225 226

    switch (delivery_mode) {
        case APIC_DM_LOWPRI:
B
bellard 已提交
227
            /* XXX: search for focus processor, arbitration */
B
bellard 已提交
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
            {
                int i, d;
                d = -1;
                for(i = 0; i < MAX_APIC_WORDS; i++) {
                    if (deliver_bitmask[i]) {
                        d = i * 32 + ffs_bit(deliver_bitmask[i]);
                        break;
                    }
                }
                if (d >= 0) {
                    apic_iter = local_apics[d];
                    if (apic_iter) {
                        apic_set_irq(apic_iter, vector_num, trigger_mode);
                    }
                }
B
bellard 已提交
243
            }
B
bellard 已提交
244
            return;
B
bellard 已提交
245

246 247 248 249
        case APIC_DM_FIXED:
            break;

        case APIC_DM_SMI:
A
aurel32 已提交
250 251 252 253
            foreach_apic(apic_iter, deliver_bitmask,
                cpu_interrupt(apic_iter->cpu_env, CPU_INTERRUPT_SMI) );
            return;

254
        case APIC_DM_NMI:
A
aurel32 已提交
255 256 257
            foreach_apic(apic_iter, deliver_bitmask,
                cpu_interrupt(apic_iter->cpu_env, CPU_INTERRUPT_NMI) );
            return;
258 259 260

        case APIC_DM_INIT:
            /* normal INIT IPI sent to processors */
261
            foreach_apic(apic_iter, deliver_bitmask,
262
                         cpu_interrupt(apic_iter->cpu_env, CPU_INTERRUPT_INIT) );
263
            return;
264

265
        case APIC_DM_EXTINT:
266
            /* handled in I/O APIC code */
267 268 269 270 271 272
            break;

        default:
            return;
    }

273
    foreach_apic(apic_iter, deliver_bitmask,
B
bellard 已提交
274
                 apic_set_irq(apic_iter, vector_num, trigger_mode) );
275
}
B
bellard 已提交
276

277 278
void apic_deliver_irq(uint8_t dest, uint8_t dest_mode, uint8_t delivery_mode,
                      uint8_t vector_num, uint8_t trigger_mode)
279 280 281
{
    uint32_t deliver_bitmask[MAX_APIC_WORDS];

282
    trace_apic_deliver_irq(dest, dest_mode, delivery_mode, vector_num,
283
                           trigger_mode);
284

285
    apic_get_delivery_bitmask(deliver_bitmask, dest, dest_mode);
286
    apic_bus_deliver(deliver_bitmask, delivery_mode, vector_num, trigger_mode);
287 288
}

289
static void apic_set_base(APICCommonState *s, uint64_t val)
B
bellard 已提交
290
{
291
    s->apicbase = (val & 0xfffff000) |
B
bellard 已提交
292 293 294 295
        (s->apicbase & (MSR_IA32_APICBASE_BSP | MSR_IA32_APICBASE_ENABLE));
    /* if disabled, cannot be enabled again */
    if (!(val & MSR_IA32_APICBASE_ENABLE)) {
        s->apicbase &= ~MSR_IA32_APICBASE_ENABLE;
296
        cpu_clear_apic_feature(s->cpu_env);
B
bellard 已提交
297 298 299 300
        s->spurious_vec &= ~APIC_SV_ENABLE;
    }
}

301
static void apic_set_tpr(APICCommonState *s, uint8_t val)
B
bellard 已提交
302
{
303 304 305 306 307
    /* Updates from cr8 are ignored while the VAPIC is active */
    if (!s->vapic_paddr) {
        s->tpr = val << 4;
        apic_update_irq(s);
    }
B
bellard 已提交
308 309
}

310
static uint8_t apic_get_tpr(APICCommonState *s)
311
{
312 313
    apic_sync_vapic(s, SYNC_FROM_VAPIC);
    return s->tpr >> 4;
314 315
}

316
static int apic_get_ppr(APICCommonState *s)
B
bellard 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
{
    int tpr, isrv, ppr;

    tpr = (s->tpr >> 4);
    isrv = get_highest_priority_int(s->isr);
    if (isrv < 0)
        isrv = 0;
    isrv >>= 4;
    if (tpr >= isrv)
        ppr = s->tpr;
    else
        ppr = isrv << 4;
    return ppr;
}

332
static int apic_get_arb_pri(APICCommonState *s)
333 334 335 336 337
{
    /* XXX: arbitration */
    return 0;
}

338 339 340 341 342 343

/*
 * <0 - low prio interrupt,
 * 0  - no interrupt,
 * >0 - interrupt number
 */
344
static int apic_irq_pending(APICCommonState *s)
B
bellard 已提交
345
{
346
    int irrv, ppr;
B
bellard 已提交
347
    irrv = get_highest_priority_int(s->irr);
348 349 350
    if (irrv < 0) {
        return 0;
    }
351
    ppr = apic_get_ppr(s);
352 353 354 355 356 357 358 359
    if (ppr && (irrv & 0xf0) <= (ppr & 0xf0)) {
        return -1;
    }

    return irrv;
}

/* signal the CPU if an irq is pending */
360
static void apic_update_irq(APICCommonState *s)
361 362
{
    if (!(s->spurious_vec & APIC_SV_ENABLE)) {
B
bellard 已提交
363
        return;
364
    }
365 366 367
    if (!qemu_cpu_is_self(s->cpu_env)) {
        cpu_interrupt(s->cpu_env, CPU_INTERRUPT_POLL);
    } else if (apic_irq_pending(s) > 0) {
368 369
        cpu_interrupt(s->cpu_env, CPU_INTERRUPT_HARD);
    }
B
bellard 已提交
370 371
}

372 373 374 375 376 377 378 379
void apic_poll_irq(DeviceState *d)
{
    APICCommonState *s = APIC_COMMON(d);

    apic_sync_vapic(s, SYNC_FROM_VAPIC);
    apic_update_irq(s);
}

380
static void apic_set_irq(APICCommonState *s, int vector_num, int trigger_mode)
B
bellard 已提交
381
{
382
    apic_report_irq_delivered(!get_bit(s->irr, vector_num));
383

B
bellard 已提交
384 385 386 387 388
    set_bit(s->irr, vector_num);
    if (trigger_mode)
        set_bit(s->tmr, vector_num);
    else
        reset_bit(s->tmr, vector_num);
389 390 391 392 393 394 395 396 397 398
    if (s->vapic_paddr) {
        apic_sync_vapic(s, SYNC_ISR_IRR_TO_VAPIC);
        /*
         * The vcpu thread needs to see the new IRR before we pull its current
         * TPR value. That way, if we miss a lowering of the TRP, the guest
         * has the chance to notice the new IRR and poll for IRQs on its own.
         */
        smp_wmb();
        apic_sync_vapic(s, SYNC_FROM_VAPIC);
    }
B
bellard 已提交
399 400 401
    apic_update_irq(s);
}

402
static void apic_eoi(APICCommonState *s)
B
bellard 已提交
403 404 405 406 407 408
{
    int isrv;
    isrv = get_highest_priority_int(s->isr);
    if (isrv < 0)
        return;
    reset_bit(s->isr, isrv);
409 410 411
    if (!(s->spurious_vec & APIC_SV_DIRECTED_IO) && get_bit(s->tmr, isrv)) {
        ioapic_eoi_broadcast(isrv);
    }
412
    apic_sync_vapic(s, SYNC_FROM_VAPIC | SYNC_TO_VAPIC);
B
bellard 已提交
413 414 415
    apic_update_irq(s);
}

G
Gleb Natapov 已提交
416 417
static int apic_find_dest(uint8_t dest)
{
418
    APICCommonState *apic = local_apics[dest];
G
Gleb Natapov 已提交
419 420 421 422 423 424 425 426 427
    int i;

    if (apic && apic->id == dest)
        return dest;  /* shortcut in case apic->id == apic->idx */

    for (i = 0; i < MAX_APICS; i++) {
        apic = local_apics[i];
	if (apic && apic->id == dest)
            return i;
428 429
        if (!apic)
            break;
G
Gleb Natapov 已提交
430 431 432 433 434
    }

    return -1;
}

B
bellard 已提交
435 436
static void apic_get_delivery_bitmask(uint32_t *deliver_bitmask,
                                      uint8_t dest, uint8_t dest_mode)
437
{
438
    APICCommonState *apic_iter;
B
bellard 已提交
439
    int i;
440 441

    if (dest_mode == 0) {
B
bellard 已提交
442 443 444
        if (dest == 0xff) {
            memset(deliver_bitmask, 0xff, MAX_APIC_WORDS * sizeof(uint32_t));
        } else {
G
Gleb Natapov 已提交
445
            int idx = apic_find_dest(dest);
B
bellard 已提交
446
            memset(deliver_bitmask, 0x00, MAX_APIC_WORDS * sizeof(uint32_t));
G
Gleb Natapov 已提交
447 448
            if (idx >= 0)
                set_bit(deliver_bitmask, idx);
B
bellard 已提交
449
        }
450 451
    } else {
        /* XXX: cluster mode */
B
bellard 已提交
452 453 454 455 456 457 458 459 460 461 462 463 464
        memset(deliver_bitmask, 0x00, MAX_APIC_WORDS * sizeof(uint32_t));
        for(i = 0; i < MAX_APICS; i++) {
            apic_iter = local_apics[i];
            if (apic_iter) {
                if (apic_iter->dest_mode == 0xf) {
                    if (dest & apic_iter->log_dest)
                        set_bit(deliver_bitmask, i);
                } else if (apic_iter->dest_mode == 0x0) {
                    if ((dest & 0xf0) == (apic_iter->log_dest & 0xf0) &&
                        (dest & apic_iter->log_dest & 0x0f)) {
                        set_bit(deliver_bitmask, i);
                    }
                }
465 466
            } else {
                break;
B
bellard 已提交
467
            }
468 469 470 471
        }
    }
}

472
static void apic_startup(APICCommonState *s, int vector_num)
B
bellard 已提交
473
{
474 475 476 477
    s->sipi_vector = vector_num;
    cpu_interrupt(s->cpu_env, CPU_INTERRUPT_SIPI);
}

B
Blue Swirl 已提交
478
void apic_sipi(DeviceState *d)
479
{
480
    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
Blue Swirl 已提交
481

482
    cpu_reset_interrupt(s->cpu_env, CPU_INTERRUPT_SIPI);
483 484

    if (!s->wait_for_sipi)
B
bellard 已提交
485
        return;
486
    cpu_x86_load_seg_cache_sipi(s->cpu_env, s->sipi_vector);
487
    s->wait_for_sipi = 0;
B
bellard 已提交
488 489
}

B
Blue Swirl 已提交
490
static void apic_deliver(DeviceState *d, uint8_t dest, uint8_t dest_mode,
491
                         uint8_t delivery_mode, uint8_t vector_num,
492
                         uint8_t trigger_mode)
493
{
494
    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
bellard 已提交
495
    uint32_t deliver_bitmask[MAX_APIC_WORDS];
496
    int dest_shorthand = (s->icr[0] >> 18) & 3;
497
    APICCommonState *apic_iter;
498

B
bellard 已提交
499
    switch (dest_shorthand) {
B
bellard 已提交
500 501 502 503 504
    case 0:
        apic_get_delivery_bitmask(deliver_bitmask, dest, dest_mode);
        break;
    case 1:
        memset(deliver_bitmask, 0x00, sizeof(deliver_bitmask));
G
Gleb Natapov 已提交
505
        set_bit(deliver_bitmask, s->idx);
B
bellard 已提交
506 507 508 509 510 511
        break;
    case 2:
        memset(deliver_bitmask, 0xff, sizeof(deliver_bitmask));
        break;
    case 3:
        memset(deliver_bitmask, 0xff, sizeof(deliver_bitmask));
G
Gleb Natapov 已提交
512
        reset_bit(deliver_bitmask, s->idx);
B
bellard 已提交
513
        break;
B
bellard 已提交
514 515
    }

516 517 518 519 520 521
    switch (delivery_mode) {
        case APIC_DM_INIT:
            {
                int trig_mode = (s->icr[0] >> 15) & 1;
                int level = (s->icr[0] >> 14) & 1;
                if (level == 0 && trig_mode == 1) {
522
                    foreach_apic(apic_iter, deliver_bitmask,
B
bellard 已提交
523
                                 apic_iter->arb_id = apic_iter->id );
524 525 526 527 528 529
                    return;
                }
            }
            break;

        case APIC_DM_SIPI:
530
            foreach_apic(apic_iter, deliver_bitmask,
B
bellard 已提交
531
                         apic_startup(apic_iter, vector_num) );
532 533 534
            return;
    }

535
    apic_bus_deliver(deliver_bitmask, delivery_mode, vector_num, trigger_mode);
536 537
}

538 539 540 541 542 543 544 545 546
static bool apic_check_pic(APICCommonState *s)
{
    if (!apic_accept_pic_intr(&s->busdev.qdev) || !pic_get_output(isa_pic)) {
        return false;
    }
    apic_deliver_pic_intr(&s->busdev.qdev, 1);
    return true;
}

B
Blue Swirl 已提交
547
int apic_get_interrupt(DeviceState *d)
B
bellard 已提交
548
{
549
    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
bellard 已提交
550 551 552 553 554 555 556 557
    int intno;

    /* if the APIC is installed or enabled, we let the 8259 handle the
       IRQs */
    if (!s)
        return -1;
    if (!(s->spurious_vec & APIC_SV_ENABLE))
        return -1;
558

559
    apic_sync_vapic(s, SYNC_FROM_VAPIC);
560 561 562
    intno = apic_irq_pending(s);

    if (intno == 0) {
563
        apic_sync_vapic(s, SYNC_TO_VAPIC);
B
bellard 已提交
564
        return -1;
565
    } else if (intno < 0) {
566
        apic_sync_vapic(s, SYNC_TO_VAPIC);
567
        return s->spurious_vec & 0xff;
568
    }
569
    reset_bit(s->irr, intno);
B
bellard 已提交
570
    set_bit(s->isr, intno);
571
    apic_sync_vapic(s, SYNC_TO_VAPIC);
572 573

    /* re-inject if there is still a pending PIC interrupt */
574
    apic_check_pic(s);
575

B
bellard 已提交
576
    apic_update_irq(s);
577

B
bellard 已提交
578 579 580
    return intno;
}

B
Blue Swirl 已提交
581
int apic_accept_pic_intr(DeviceState *d)
582
{
583
    APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
584 585 586 587 588 589 590
    uint32_t lvt0;

    if (!s)
        return -1;

    lvt0 = s->lvt[APIC_LVT_LINT0];

591 592
    if ((s->apicbase & MSR_IA32_APICBASE_ENABLE) == 0 ||
        (lvt0 & APIC_LVT_MASKED) == 0)
593 594 595 596 597
        return 1;

    return 0;
}

598
static uint32_t apic_get_current_count(APICCommonState *s)
B
bellard 已提交
599 600 601
{
    int64_t d;
    uint32_t val;
602
    d = (qemu_get_clock_ns(vm_clock) - s->initial_count_load_time) >>
B
bellard 已提交
603 604 605
        s->count_shift;
    if (s->lvt[APIC_LVT_TIMER] & APIC_LVT_TIMER_PERIODIC) {
        /* periodic */
606
        val = s->initial_count - (d % ((uint64_t)s->initial_count + 1));
B
bellard 已提交
607 608 609 610 611 612 613 614 615
    } else {
        if (d >= s->initial_count)
            val = 0;
        else
            val = s->initial_count - d;
    }
    return val;
}

616
static void apic_timer_update(APICCommonState *s, int64_t current_time)
B
bellard 已提交
617
{
J
Jan Kiszka 已提交
618 619
    if (apic_next_timer(s, current_time)) {
        qemu_mod_timer(s->timer, s->next_time);
B
bellard 已提交
620 621 622 623 624 625 626
    } else {
        qemu_del_timer(s->timer);
    }
}

static void apic_timer(void *opaque)
{
627
    APICCommonState *s = opaque;
B
bellard 已提交
628

629
    apic_local_deliver(s, APIC_LVT_TIMER);
B
bellard 已提交
630 631 632
    apic_timer_update(s, s->next_time);
}

A
Anthony Liguori 已提交
633
static uint32_t apic_mem_readb(void *opaque, target_phys_addr_t addr)
B
bellard 已提交
634 635 636 637
{
    return 0;
}

A
Anthony Liguori 已提交
638
static uint32_t apic_mem_readw(void *opaque, target_phys_addr_t addr)
B
bellard 已提交
639 640 641 642
{
    return 0;
}

A
Anthony Liguori 已提交
643
static void apic_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
B
bellard 已提交
644 645 646
{
}

A
Anthony Liguori 已提交
647
static void apic_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
B
bellard 已提交
648 649 650
{
}

A
Anthony Liguori 已提交
651
static uint32_t apic_mem_readl(void *opaque, target_phys_addr_t addr)
B
bellard 已提交
652
{
B
Blue Swirl 已提交
653
    DeviceState *d;
654
    APICCommonState *s;
B
bellard 已提交
655 656 657
    uint32_t val;
    int index;

B
Blue Swirl 已提交
658 659
    d = cpu_get_current_apic();
    if (!d) {
B
bellard 已提交
660
        return 0;
661
    }
662
    s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
bellard 已提交
663 664 665 666 667 668 669 670 671 672

    index = (addr >> 4) & 0xff;
    switch(index) {
    case 0x02: /* id */
        val = s->id << 24;
        break;
    case 0x03: /* version */
        val = 0x11 | ((APIC_LVT_NB - 1) << 16); /* version 0x11 */
        break;
    case 0x08:
673 674 675 676
        apic_sync_vapic(s, SYNC_FROM_VAPIC);
        if (apic_report_tpr_access) {
            cpu_report_tpr_access(s->cpu_env, TPR_ACCESS_READ);
        }
B
bellard 已提交
677 678
        val = s->tpr;
        break;
679 680 681
    case 0x09:
        val = apic_get_arb_pri(s);
        break;
B
bellard 已提交
682 683 684 685
    case 0x0a:
        /* ppr */
        val = apic_get_ppr(s);
        break;
A
aurel32 已提交
686 687 688
    case 0x0b:
        val = 0;
        break;
689 690 691 692 693 694
    case 0x0d:
        val = s->log_dest << 24;
        break;
    case 0x0e:
        val = s->dest_mode << 28;
        break;
B
bellard 已提交
695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
    case 0x0f:
        val = s->spurious_vec;
        break;
    case 0x10 ... 0x17:
        val = s->isr[index & 7];
        break;
    case 0x18 ... 0x1f:
        val = s->tmr[index & 7];
        break;
    case 0x20 ... 0x27:
        val = s->irr[index & 7];
        break;
    case 0x28:
        val = s->esr;
        break;
    case 0x30:
    case 0x31:
        val = s->icr[index & 1];
        break;
B
bellard 已提交
714 715 716
    case 0x32 ... 0x37:
        val = s->lvt[index - 0x32];
        break;
B
bellard 已提交
717 718 719 720 721 722 723 724 725 726 727 728 729 730
    case 0x38:
        val = s->initial_count;
        break;
    case 0x39:
        val = apic_get_current_count(s);
        break;
    case 0x3e:
        val = s->divide_conf;
        break;
    default:
        s->esr |= ESR_ILLEGAL_ADDRESS;
        val = 0;
        break;
    }
731
    trace_apic_mem_readl(addr, val);
B
bellard 已提交
732 733 734
    return val;
}

735
static void apic_send_msi(target_phys_addr_t addr, uint32_t data)
736 737 738 739 740 741 742
{
    uint8_t dest = (addr & MSI_ADDR_DEST_ID_MASK) >> MSI_ADDR_DEST_ID_SHIFT;
    uint8_t vector = (data & MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT;
    uint8_t dest_mode = (addr >> MSI_ADDR_DEST_MODE_SHIFT) & 0x1;
    uint8_t trigger_mode = (data >> MSI_DATA_TRIGGER_SHIFT) & 0x1;
    uint8_t delivery = (data >> MSI_DATA_DELIVERY_MODE_SHIFT) & 0x7;
    /* XXX: Ignore redirection hint. */
743
    apic_deliver_irq(dest, dest_mode, delivery, vector, trigger_mode);
744 745
}

A
Anthony Liguori 已提交
746
static void apic_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
B
bellard 已提交
747
{
B
Blue Swirl 已提交
748
    DeviceState *d;
749
    APICCommonState *s;
750 751 752 753 754 755 756 757 758 759
    int index = (addr >> 4) & 0xff;
    if (addr > 0xfff || !index) {
        /* MSI and MMIO APIC are at the same memory location,
         * but actually not on the global bus: MSI is on PCI bus
         * APIC is connected directly to the CPU.
         * Mapping them on the global bus happens to work because
         * MSI registers are reserved in APIC MMIO and vice versa. */
        apic_send_msi(addr, val);
        return;
    }
B
bellard 已提交
760

B
Blue Swirl 已提交
761 762
    d = cpu_get_current_apic();
    if (!d) {
B
bellard 已提交
763
        return;
764
    }
765
    s = DO_UPCAST(APICCommonState, busdev.qdev, d);
B
bellard 已提交
766

767
    trace_apic_mem_writel(addr, val);
B
bellard 已提交
768 769 770 771 772

    switch(index) {
    case 0x02:
        s->id = (val >> 24);
        break;
B
bellard 已提交
773 774
    case 0x03:
        break;
B
bellard 已提交
775
    case 0x08:
776 777 778
        if (apic_report_tpr_access) {
            cpu_report_tpr_access(s->cpu_env, TPR_ACCESS_WRITE);
        }
B
bellard 已提交
779
        s->tpr = val;
780
        apic_sync_vapic(s, SYNC_TO_VAPIC);
781
        apic_update_irq(s);
B
bellard 已提交
782
        break;
B
bellard 已提交
783 784 785
    case 0x09:
    case 0x0a:
        break;
B
bellard 已提交
786 787 788
    case 0x0b: /* EOI */
        apic_eoi(s);
        break;
789 790 791 792 793 794
    case 0x0d:
        s->log_dest = val >> 24;
        break;
    case 0x0e:
        s->dest_mode = val >> 28;
        break;
B
bellard 已提交
795 796
    case 0x0f:
        s->spurious_vec = val & 0x1ff;
797
        apic_update_irq(s);
B
bellard 已提交
798
        break;
B
bellard 已提交
799 800 801 802 803
    case 0x10 ... 0x17:
    case 0x18 ... 0x1f:
    case 0x20 ... 0x27:
    case 0x28:
        break;
B
bellard 已提交
804
    case 0x30:
805
        s->icr[0] = val;
B
Blue Swirl 已提交
806
        apic_deliver(d, (s->icr[1] >> 24) & 0xff, (s->icr[0] >> 11) & 1,
807
                     (s->icr[0] >> 8) & 7, (s->icr[0] & 0xff),
808
                     (s->icr[0] >> 15) & 1);
809
        break;
B
bellard 已提交
810
    case 0x31:
811
        s->icr[1] = val;
B
bellard 已提交
812 813 814 815 816
        break;
    case 0x32 ... 0x37:
        {
            int n = index - 0x32;
            s->lvt[n] = val;
817
            if (n == APIC_LVT_TIMER) {
818
                apic_timer_update(s, qemu_get_clock_ns(vm_clock));
819 820 821
            } else if (n == APIC_LVT_LINT0 && apic_check_pic(s)) {
                apic_update_irq(s);
            }
B
bellard 已提交
822 823 824 825
        }
        break;
    case 0x38:
        s->initial_count = val;
826
        s->initial_count_load_time = qemu_get_clock_ns(vm_clock);
B
bellard 已提交
827 828
        apic_timer_update(s, s->initial_count_load_time);
        break;
B
bellard 已提交
829 830
    case 0x39:
        break;
B
bellard 已提交
831 832 833 834 835 836 837 838 839 840 841 842 843 844
    case 0x3e:
        {
            int v;
            s->divide_conf = val & 0xb;
            v = (s->divide_conf & 3) | ((s->divide_conf >> 1) & 4);
            s->count_shift = (v + 1) & 7;
        }
        break;
    default:
        s->esr |= ESR_ILLEGAL_ADDRESS;
        break;
    }
}

845 846 847 848 849
static void apic_pre_save(APICCommonState *s)
{
    apic_sync_vapic(s, SYNC_FROM_VAPIC);
}

J
Jan Kiszka 已提交
850 851 852 853 854 855 856 857 858
static void apic_post_load(APICCommonState *s)
{
    if (s->timer_expiry != -1) {
        qemu_mod_timer(s->timer, s->timer_expiry);
    } else {
        qemu_del_timer(s->timer);
    }
}

A
Avi Kivity 已提交
859 860 861 862 863 864
static const MemoryRegionOps apic_io_ops = {
    .old_mmio = {
        .read = { apic_mem_readb, apic_mem_readw, apic_mem_readl, },
        .write = { apic_mem_writeb, apic_mem_writew, apic_mem_writel, },
    },
    .endianness = DEVICE_NATIVE_ENDIAN,
B
bellard 已提交
865 866
};

867
static void apic_init(APICCommonState *s)
B
Blue Swirl 已提交
868
{
869 870
    memory_region_init_io(&s->io_memory, &apic_io_ops, s, "apic-msi",
                          MSI_SPACE_SIZE);
B
Blue Swirl 已提交
871

872
    s->timer = qemu_new_timer_ns(vm_clock, apic_timer, s);
B
Blue Swirl 已提交
873
    local_apics[s->idx] = s;
874 875

    msi_supported = true;
B
Blue Swirl 已提交
876 877
}

878 879 880 881 882 883 884
static void apic_class_init(ObjectClass *klass, void *data)
{
    APICCommonClass *k = APIC_COMMON_CLASS(klass);

    k->init = apic_init;
    k->set_base = apic_set_base;
    k->set_tpr = apic_set_tpr;
885 886
    k->get_tpr = apic_get_tpr;
    k->vapic_base_update = apic_vapic_base_update;
887
    k->external_nmi = apic_external_nmi;
888
    k->pre_save = apic_pre_save;
889 890 891
    k->post_load = apic_post_load;
}

892 893 894 895 896
static TypeInfo apic_info = {
    .name          = "apic",
    .instance_size = sizeof(APICCommonState),
    .parent        = TYPE_APIC_COMMON,
    .class_init    = apic_class_init,
B
Blue Swirl 已提交
897 898
};

A
Andreas Färber 已提交
899
static void apic_register_types(void)
B
Blue Swirl 已提交
900
{
901
    type_register_static(&apic_info);
B
Blue Swirl 已提交
902 903
}

A
Andreas Färber 已提交
904
type_init(apic_register_types)