user/vmm/ioapic.c

   1 /*
   2  * IOAPIC emulation
   3  *
   4  * Copyright 2015 Google Inc.
   5  *
   6  * See LICENSE for details.
   7  */
   8
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <pthread.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <parlib/arch/arch.h>
  15 #include <parlib/ros_debug.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/uio.h>
  21 #include <stdint.h>
  22 #include <err.h>
  23 #include <sys/mman.h>
  24 #include <vmm/vmm.h>
  25 #include <vmm/virtio.h>
  26 #include <vmm/virtio_mmio.h>
  27 #include <vmm/virtio_ids.h>
  28 #include <vmm/virtio_config.h>
  29 #include <vmm/sched.h>
  30
  31 #define IOAPIC_CONFIG 0x100
  32 #define IOAPIC_NUM_PINS 24
  33
  34 int debug_ioapic = 1;
  35 int apic_id_mask = 0xf0;
  36
  37 #define DPRINTF(fmt, ...) \
  38         if (debug_ioapic) { fprintf(stderr, "ioapic: " fmt , ## __VA_ARGS__); }
  39
  40
  41 struct ioapic {
  42         int id;
  43         int reg;
  44         uint32_t arbid;
  45         uint32_t value[256];
  46 };
  47
  48 static struct ioapic ioapic[1];
  49
  50 static uint32_t ioapic_read(struct guest_thread *vm_thread, int ix,
  51                             uint64_t offset)
  52 {
  53         uint32_t ret = (uint32_t)-1;
  54         uint32_t reg = ioapic[ix].reg;
  55
  56         if (offset == 0) {
  57                 DPRINTF("ioapic_read ix %x return 0x%x\n", ix, reg);
  58                 return reg;
  59         }
  60
  61         DPRINTF("ioapic_read %x 0x%x\n", ix, (int)reg);
  62         switch (reg) {
  63         case 0:
  64                 return ioapic[ix].id;
  65                 break;
  66         case 1:
  67                 return 0x170011;
  68                 break;
  69         case 2:
  70                 return ioapic[ix].arbid;
  71                 break;
  72         default:
  73                 if (reg >= 0 && reg < (IOAPIC_NUM_PINS*2 + 0x10)) {
  74                         //bx_io_redirect_entry_t *entry = ioredtbl + index;
  75                         //data = (ioregsel&1) ? entry->get_hi_part() : entry->get_lo_part();
  76                         ret = ioapic[ix].value[reg];
  77                         DPRINTF("IOAPIC_READ %x: %x return %08x\n", ix, reg, ret);
  78                         return ret;
  79                 } else {
  80                         DPRINTF("IOAPIC READ: %x BAD INDEX 0x%x\n", ix, reg);
  81                 }
  82                 return ret;
  83                 break;
  84         }
  85         return 0;
  86 }
  87
  88 static void ioapic_write(struct guest_thread *vm_thread, int ix,
  89                          uint64_t offset, uint32_t value)
  90 {
  91         uint32_t ret;
  92         uint32_t reg = ioapic[ix].reg;
  93         struct virtual_machine *vm = gth_to_vm(vm_thread);
  94         uint32_t irqreg;
  95
  96         if (offset == 0) {
  97                 DPRINTF("ioapic_write ix %x set reg 0x%x\n", ix, value);
  98                 ioapic[ix].reg = value;
  99                 return;
 100         }
 101
 102         for (int i = 0; i < VIRTIO_MMIO_MAX_NUM_DEV; i++) {
 103                 if (vm->virtio_mmio_devices[i] == NULL)
 104                         continue;
 105
 106                 /* The first IRQ register starts at 0x10, and there are two 32-bit
 107                  * registers for each IRQ. The first 8 bits of the value assigned to
 108                  * 'reg' is the interrupt vector. */
 109                 irqreg = (vm->virtio_mmio_devices[i]->irq) * 2 + 0x10;
 110                 if (reg == irqreg && (value & 0xff) != 0) {
 111                         vm->virtio_mmio_devices[i]->vec = value & 0xff;
 112                         DPRINTF("irq vector for irq number %d is: %lx\n",
 113                                  vm->virtio_mmio_devices[i]->irq, value & 0xff);
 114                 }
 115         }
 116
 117         switch (reg) {
 118         case 0:
 119                 DPRINTF("IOAPIC_WRITE: Set %d ID to %d\n", ix, value);
 120                 ioapic[ix].id = value;
 121                 break;
 122         case 1:
 123         case 2:
 124                 DPRINTF("IOAPIC_WRITE: Can't write %d\n", reg);
 125         default:
 126                 if (reg >= 0 && reg < (IOAPIC_NUM_PINS*2 + 0x10)) {
 127                         ioapic[ix].value[reg] = value;
 128                         DPRINTF("IOAPIC %x: set %08x to %016x\n", ix, reg, value);
 129                 } else {
 130                         DPRINTF("IOAPIC WRITE: %x BAD INDEX 0x%x\n", ix, reg);
 131                 }
 132                 break;
 133         }
 134
 135 }
 136
 137 int do_ioapic(struct guest_thread *vm_thread, uint64_t gpa, int destreg,
 138               uint64_t *regp, int store)
 139 {
 140         /* TODO(ganshun): compute an index for the ioapic array. */
 141         int ix = 0;
 142         uint32_t offset = gpa & 0xfffff;
 143         /* basic sanity tests. */
 144         DPRINTF("%s: %p 0x%x %p %s\n", __func__, (void *)gpa, destreg, regp, store ? "write" : "read");
 145
 146         if ((offset != 0) && (offset != 0x10)) {
 147                 DPRINTF("Bad register offset: 0x%x and has to be 0x0 or 0x10\n", offset);
 148                 return -1;
 149         }
 150
 151         if (store) {
 152                 ioapic_write(vm_thread, ix, offset, *regp);
 153         } else {
 154                 *regp = ioapic_read(vm_thread, ix, offset);
 155         }
 156
 157 }