palacios/src/devices/piix3.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2009, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2009, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20
  21 #include <palacios/vmm.h>
  22 #include <palacios/vmm_dev_mgr.h>
  23 #include <palacios/vmm_intr.h>
  24
  25 #include <devices/pci.h>
  26 #include <devices/southbridge.h>
  27
  28
  29 struct iort_reg {
  30     union {
  31         uint8_t value;
  32         struct {
  33             uint8_t times_16bit   : 2;
  34             uint8_t enable_16bit  : 1;
  35             uint8_t times_8bit    : 3;
  36             uint8_t enable_8bit   : 1;
  37             uint8_t dmaac         : 1;
  38         } __attribute__((packed));
  39     } __attribute__((packed));
  40 } __attribute__((packed));
  41
  42 struct xbcs_reg {
  43     union {
  44         uint16_t value;
  45         struct {
  46             uint8_t rtc_addr_en        : 1;
  47             uint8_t kb_ctrl_en         : 1;
  48             uint8_t bioscs_wprot_en    : 1;
  49             uint8_t rsvd1              : 1;
  50             uint8_t irq12_mouse_fn_en  : 1;
  51             uint8_t coproc_err_fn_en   : 1;
  52             uint8_t lower_bios_en      : 1;
  53             uint8_t ext_bios_en        : 1;
  54             uint8_t apic_chip_sel      : 1;
  55             uint8_t piix_rsvd          : 7;
  56         } __attribute__((packed));
  57     } __attribute__((packed));
  58 } __attribute__((packed));
  59
  60
  61 struct pirq_route_ctrl_req {
  62     union {
  63         uint8_t value;
  64         struct {
  65             uint8_t irq_routing        : 4;
  66             uint8_t rsvd               : 3;
  67             uint8_t irq_route_en       : 1;
  68         } __attribute__((packed));
  69     } __attribute__((packed));
  70 } __attribute__((packed));
  71
  72 struct top_of_mem_reg {
  73     union {
  74         uint8_t value;
  75         struct {
  76             uint8_t rsvd1                    : 1;
  77     uint8_t isadma_reg_fwd_en        : 1;
  78             uint8_t piix_rsvd                : 1;
  79             uint8_t isadma_lo_bios_fwd_en    : 1;
  80             uint8_t top_of_mem               : 4;
  81         } __attribute__((packed));
  82     } __attribute__((packed));
  83 } __attribute__((packed));
  84
  85 // Miscellaneous Status register
  86 struct misc_stat_reg {
  87     union {
  88         uint16_t value;
  89         struct {
  90             uint8_t isa_clk_div              : 1;
  91             uint8_t piix_rsvd1               : 1;
  92             uint8_t pci_hdr_type_en          : 1;
  93             uint8_t rsvd1                    : 1;
  94             uint8_t usb_en                   : 1;
  95             uint8_t rsvd2                    : 1;
  96             uint8_t ext_sm_mode_en           : 1;
  97             uint8_t nb_retry_en              : 1;
  98             uint8_t rsvd3                    : 7;
  99             uint8_t serr_gen_delayed_tranx   : 1;
 100         } __attribute__((packed));
 101     } __attribute__((packed));
 102 } __attribute__((packed));
 103
 104
 105
 106 // Motherboard Device IRQ route control register
 107 struct mb_irq_ctrl_reg {
 108     union {
 109         uint8_t value;
 110         struct {
 111             uint8_t irq_routing              : 4;
 112             uint8_t rsvd                     : 1;
 113             uint8_t irq0_en                  : 1;
 114             uint8_t irq_sharing_en           : 1;
 115             uint8_t irq_routing_en           : 1;
 116         } __attribute__((packed));
 117     } __attribute__((packed));
 118 } __attribute__((packed));
 119
 120 // Motherboard Device DMA control register
 121 struct mb_dma_ctrl_reg {
 122     union {
 123         uint8_t value;
 124         struct {
 125             uint8_t type_f_dma_routing       : 3;
 126             uint8_t piix_rsvd                : 1;
 127             uint8_t rsvd                     : 3;
 128             uint8_t type_f_dma_buf_en        : 1;
 129         } __attribute__((packed));
 130     } __attribute__((packed));
 131 } __attribute__((packed));
 132
 133
 134 // Programmable Chip Select Control Register
 135 struct prg_chip_sel_ctrl_reg {
 136     union {
 137         uint16_t value;
 138         struct {
 139             uint8_t pcs_addr_mask            : 2;
 140             uint16_t pcs_addr                : 14;
 141         } __attribute__((packed));
 142     } __attribute__((packed));
 143 } __attribute__((packed));
 144
 145
 146 // APIC base address relocation register
 147 struct apic_base_addr_reg {
 148     union {
 149         uint8_t value;
 150         struct {
 151             uint8_t y_base_addr             : 2;
 152             uint8_t x_base_addr             : 4;
 153             uint8_t a12_mask                : 1;
 154             uint8_t rsvd                    : 1;
 155         } __attribute__((packed));
 156     } __attribute__((packed));
 157 } __attribute__((packed));
 158
 159
 160 // Deterministic Latency control register
 161 struct deter_lat_ctrl_reg {
 162     union {
 163         uint8_t value;
 164         struct {
 165             uint8_t delayed_trans_en        : 1;
 166             uint8_t pass_release_en         : 1;
 167             uint8_t usb_pass_release_en     : 1;
 168             uint8_t serr_gen_trans_tmout_en : 1;
 169             uint8_t rsvd                    : 4;
 170         } __attribute__((packed));
 171     } __attribute__((packed));
 172 } __attribute__((packed));
 173
 174 // SMI Control Register
 175 struct smi_ctrl_reg {
 176     union {
 177         uint8_t value;
 178         struct {
 179             uint8_t smi_gate               : 1;
 180             uint8_t stpclk_sig_en          : 1;
 181             uint8_t stpclk_scaling_en      : 1;
 182             uint8_t fast_off_tmr_freeze    : 2;
 183             uint8_t rsvd                   : 3;
 184         } __attribute__((packed));
 185     } __attribute__((packed));
 186 } __attribute__((packed));
 187
 188 // SMI Enable register
 189 struct smi_enable_reg {
 190     union {
 191         uint16_t value;
 192         struct {
 193             uint8_t irq1_smi_en            : 1; // (keyboard irq)
 194             uint8_t irq3_smi_en            : 1; // (COM1/COM3/Mouse irq)
 195             uint8_t irq4_smi_en            : 1; // (COM2/COM4/Mouse irq)
 196             uint8_t irq8_smi_en            : 1; // (RTC irq)
 197             uint8_t irq12_smi_en           : 1; // (PS/2 mouse irq)
 198             uint8_t fast_off_tmr_en        : 1;
 199             uint8_t ext_smi_en             : 1;
 200             uint8_t apic_wr_smi_en         : 1;
 201             uint8_t legacy_usb_smi_en      : 1;
 202             uint8_t rsvd                   : 7;
 203         } __attribute__((packed));
 204     } __attribute__((packed));
 205 } __attribute__((packed));
 206
 207
 208 // System Event Enable register
 209 struct sys_evt_en_reg {
 210     union {
 211         uint32_t value;
 212         struct {
 213             uint8_t firq0_en               : 1;
 214             uint8_t firq1_en               : 1;
 215             uint8_t rsvd1                  : 1;
 216             uint8_t firq3_en               : 1;
 217             uint8_t firq4_en               : 1;
 218             uint8_t firq5_en               : 1;
 219             uint8_t firq6_en               : 1;
 220             uint8_t firq7_en               : 1;
 221             uint8_t firq8_en               : 1;
 222             uint8_t firq9_en               : 1;
 223             uint8_t firq10_en              : 1;
 224             uint8_t firq11_en              : 1;
 225             uint8_t firq12_en              : 1;
 226             uint8_t firq13_en              : 1;
 227             uint8_t firq14_en              : 1;
 228             uint8_t firq15_en              : 1;
 229             uint16_t rsvd2                 : 12;
 230             uint8_t fast_off_apic_en       : 1;
 231             uint8_t fast_off_nmi_en        : 1;
 232             uint8_t intr_en                : 1;
 233             uint8_t fast_off_smi_en        : 1;
 234         } __attribute__((packed));
 235     } __attribute__((packed));
 236 } __attribute__((packed));
 237
 238
 239 // SMI Request Register
 240 struct smi_req_reg {
 241     union {
 242         uint16_t value;
 243         struct {
 244             uint8_t irq1_req_smi_stat      : 1;
 245             uint8_t irq3_req_smi_stat      : 1;
 246             uint8_t irq4_req_smi_stat      : 1;
 247             uint8_t irq8_req_smi_stat      : 1;
 248             uint8_t irq12_req_smi_stat     : 1;
 249             uint8_t fast_off_tmr_exp_stat  : 1;
 250             uint8_t extsmi_stat            : 1;
 251             uint8_t apm_smi_stat           : 1;
 252             uint8_t legacy_usb_smi_stat    : 1;
 253             uint8_t rsvd                   : 7;
 254         } __attribute__((packed));
 255     } __attribute__((packed));
 256 } __attribute__((packed));
 257
 258
 259 struct piix3_config_space {
 260     uint8_t rsvd1[12];            // 0x40 - 0x4b
 261
 262     // ISA I/O Recovery timer register
 263     uint8_t iort;                 // 0x4c        (default 0x4d)
 264     uint8_t rsvd2;                // 0x4d
 265
 266     // X-Bus Chip select register
 267     uint16_t xbcs;                // 0x4e - 0x4f (default: 0x03)
 268     uint8_t rsvd3[16];            // 0x50 - 0x5f
 269
 270     // pirq route control register (IRQs A-D)
 271     uint8_t pirq_rc[4];           // 0x60 - 0x63 (default: 0x80)
 272     uint8_t rsvd4[5];             // 0x64 - 0x68
 273
 274     // top of memory register
 275     uint8_t top_of_mem;           // 0x69        (default: 0x02)
 276
 277     // Miscellaneous status register
 278     uint16_t mstat;               // 0x6A - 0x6B (default: undefined)
 279     uint8_t rsvd5[4];             // 0x6c - 0x6f
 280
 281     // Motherboard device IRQ route control register
 282     uint8_t mbirq0;                // 0x70        (default: 0x80)
 283     uint8_t rsvd6;                 // 0x71 (piix only)
 284     uint8_t rsvd7[4];              // 0x72 - 0x75
 285
 286     // Motherboard Device DMA Control registers
 287     uint8_t mbdma0;                // 0x76        (default: 0x0c)
 288     uint8_t mbdma1;                // 0x77        (default: 0x0c)
 289
 290     // Programmable Chip Select Control Register
 291     uint16_t pcsc;                 // 0x78 - 0x79 (default: 0x0002)
 292     uint8_t rsvd8[6];              // 0x7A - 0x7F
 293
 294     // APIC base address relocation register
 295     uint8_t apicbase;              // 0x80        (default: 0x00)
 296     uint8_t rsvd9;                 // 0x81
 297
 298
 299     // Deterministic Latency control register
 300     uint8_t dlc;                   // 0x82        (default: 0x00)
 301     uint8_t rsvd10[29];            // 0x83 - 0x9f
 302
 303
 304     // SMI Control Register
 305     uint8_t smicntl;               // 0xa0        (default: 0x08)
 306     uint8_t rsvd11;                // 0xa1
 307
 308     // SMI Enable register
 309     uint16_t smien;                // 0xa2 - 0xa3 (default: 0x0000)
 310
 311     // System Event Enable register
 312     uint32_t see;                  // 0xa4 - 0xa7 (default: 0x00000000)
 313
 314     // Fast off timer register
 315     uint8_t ftmr;                  // 0xa8        (default: 0x0f)
 316     uint8_t rsvd12;                // 0xa9
 317
 318     // SMI Request Register
 319     uint16_t smireq;               // 0xaa - 0xab (default: 0x0000)
 320
 321     // Clock Scale stpclk low timer
 322     uint8_t ctltmr;                // 0xac        (default: 0x00)
 323     uint8_t rsvd13;                // 0xad
 324
 325     // Slock Scale STPCLK high timer
 326     uint8_t cthtmr;                // 0xae        (default: 0x00)
 327
 328 } __attribute__((packed));
 329
 330
 331
 332 static int reset_piix3(struct v3_southbridge * piix3) {
 333     struct pci_device * pci_dev = piix3->southbridge_pci;
 334     struct piix3_config_space * piix3_cfg = (struct piix3_config_space *)(pci_dev->config_data);
 335
 336     pci_dev->config_header.command = 0x0007; // master, memory and I/O
 337     pci_dev->config_header.status = 0x0200;
 338
 339     piix3_cfg->iort = 0x4d;
 340     piix3_cfg->xbcs = 0x0003;
 341     piix3_cfg->pirq_rc[0] = 0x80;
 342     piix3_cfg->pirq_rc[1] = 0x80;
 343     piix3_cfg->pirq_rc[2] = 0x80;
 344     piix3_cfg->pirq_rc[3] = 0x80;
 345     piix3_cfg->top_of_mem = 0x02;
 346     piix3_cfg->mbirq0 = 0x80;
 347     piix3_cfg->mbdma0 = 0x0c;
 348     piix3_cfg->mbdma1 = 0x0c;
 349     piix3_cfg->pcsc = 0x0002;
 350     piix3_cfg->apicbase = 0x00;
 351     piix3_cfg->dlc = 0x00;
 352     piix3_cfg->smicntl = 0x08;
 353     piix3_cfg->smien = 0x0000;
 354     piix3_cfg->see = 0x00000000;
 355     piix3_cfg->ftmr = 0x0f;
 356     piix3_cfg->smireq = 0x0000;
 357     piix3_cfg->ctltmr = 0x00;
 358     piix3_cfg->cthtmr = 0x00;
 359
 360     return 0;
 361 }
 362
 363
 364 //irq is pirq_rc[intr_pin + pci_dev_num - 1] & 0xf
 365 /*
 366 struct pirq_rc_reg {
 367        uint8_t irq         : 4;
 368        uint8_t rsvd        : 3;
 369        uint8_t disabled    : 1; // (1=disabled, 0=enabled)
 370 }
 371 */
 372
 373
 374 static int raise_pci_irq(struct pci_device * pci_dev, void * dev_data, struct v3_irq * vec) {
 375     struct v3_southbridge * piix3 = dev_data;
 376     struct pci_device * piix3_pci = piix3->southbridge_pci;
 377     struct piix3_config_space * piix3_cfg = (struct piix3_config_space *)(piix3_pci->config_data);
 378     int intr_pin = pci_dev->config_header.intr_pin - 1;
 379     int irq_index = (intr_pin + pci_dev->dev_num - 1) & 0x3;
 380     struct v3_irq irq; // Make a copy of the irq state because we will switch the irq number
 381
 382     irq.ack = vec->ack;
 383     irq.private_data = vec->private_data;
 384
 385     /*
 386     PrintError(info->vm_info, info, "Raising PCI dev %d intr %d via IOAPIC as IRQ %d and via PIRQ as IRQ %d on VM %p\n",
 387                pci_dev->dev_num, pci_dev->config_header.intr_pin,
 388                16+irq_index,
 389                piix3_cfg->pirq_rc[irq_index], piix3->vm);
 390     */
 391
 392     // deliver first by PIRQ, if it exists
 393     //
 394     if (piix3_cfg->pirq_rc[irq_index] < 16) {
 395         irq.irq = piix3_cfg->pirq_rc[irq_index] & 0xf;
 396
 397         //      V3_Print(info->vm_info, info, "Raising PIIX IRQ %d\n", irq.irq);
 398         v3_raise_acked_irq(piix3->vm, irq);
 399     } else {
 400       // not an error
 401     }
 402
 403     // deliver next via the PCI0 to ioapic mapping defined in the
 404     // mptable (ioapic, pins 16->19 are used for PCI0)
 405     // ideally this would check to verify that an ioapic is actually available
 406     irq.irq = (irq_index + 1) + 16;
 407     //    V3_Print(info->vm_info, info, "Raising PIIX IRQ (#2) %d\n", irq.irq);
 408     v3_raise_acked_irq(piix3->vm, irq);
 409
 410
 411     return 0;
 412 }
 413
 414
 415
 416 static int lower_pci_irq(struct pci_device * pci_dev, void * dev_data, struct v3_irq * vec) {
 417     struct v3_southbridge * piix3 = dev_data;
 418     struct pci_device * piix3_pci = piix3->southbridge_pci;
 419     struct piix3_config_space * piix3_cfg = (struct piix3_config_space *)(piix3_pci->config_data);
 420     int intr_pin = pci_dev->config_header.intr_pin - 1;
 421     int irq_index = (intr_pin + pci_dev->dev_num - 1) & 0x3;
 422     struct v3_irq irq; // Make a copy of the irq state because we will switch the irq number
 423
 424     irq.ack = vec->ack;
 425     irq.private_data = vec->private_data;
 426     //    PrintError(info->vm_info, info, "Lowering PCI IRQ %d\n", piix3_cfg->pirq_rc[irq_index]);
 427
 428     // First, lower the pin on the ioapic
 429     irq.irq = (irq_index + 1) + 16;
 430     v3_lower_acked_irq(piix3->vm, irq);
 431
 432     // Next, lower whatever we asserted by the PIRQs
 433     if (piix3_cfg->pirq_rc[irq_index] < 16) {
 434         irq.irq = piix3_cfg->pirq_rc[irq_index] & 0xf;
 435         v3_lower_acked_irq(piix3->vm, irq);
 436     } else {
 437       // not an error
 438     }
 439
 440     return 0;
 441 }
 442
 443
 444
 445 static int piix_free(struct v3_southbridge * piix3) {
 446
 447     // unregister pci
 448
 449     V3_Free(piix3);
 450     return 0;
 451 }
 452
 453
 454 static struct v3_device_ops dev_ops = {
 455     .free = (int (*)(void *))piix_free,
 456 };
 457
 458
 459
 460
 461 static int setup_pci(struct v3_southbridge * piix3) {
 462     struct pci_device * pci_dev = NULL;
 463     struct v3_pci_bar bars[6];
 464     int i;
 465     int bus_num = 0;
 466
 467     for (i = 0; i < 6; i++) {
 468         bars[i].type = PCI_BAR_NONE;
 469     }
 470
 471     pci_dev = v3_pci_register_device(piix3->pci_bus, PCI_MULTIFUNCTION,
 472                                      bus_num, -1, 0,
 473                                      "PIIX3", bars,
 474                                      NULL, NULL, NULL, NULL, piix3);
 475     if (pci_dev == NULL) {
 476         PrintError(VM_NONE, VCORE_NONE, "Could not register PCI Device for PIIX3\n");
 477         return -1;
 478     }
 479
 480     pci_dev->config_header.vendor_id = 0x8086;
 481     pci_dev->config_header.device_id = 0x7000; // PIIX4 is 0x7001
 482     pci_dev->config_header.class = PCI_CLASS_BRIDGE;
 483     pci_dev->config_header.subclass = PCI_BRIDGE_SUBCLASS_PCI_ISA;
 484
 485     piix3->southbridge_pci = pci_dev;
 486
 487     v3_pci_set_irq_bridge(piix3->pci_bus, bus_num, raise_pci_irq, lower_pci_irq, piix3);
 488
 489     reset_piix3(piix3);
 490
 491     return 0;
 492 }
 493
 494 static int piix3_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
 495     struct v3_southbridge * piix3 = (struct v3_southbridge *)V3_Malloc(sizeof(struct v3_southbridge));
 496     struct vm_device * dev = NULL;
 497     struct vm_device * pci = v3_find_dev(vm, v3_cfg_val(cfg, "bus"));
 498     char * dev_id = v3_cfg_val(cfg, "ID");
 499
 500     if (!piix3) {
 501         PrintError(vm, VCORE_NONE, "Cannot allocate in init\n");
 502         return -1;
 503     }
 504
 505     if (!pci) {
 506         PrintError(vm, VCORE_NONE, "Could not find PCI device\n");
 507         return -1;
 508     }
 509
 510     piix3->pci_bus = pci;
 511     piix3->type = V3_SB_PIIX3;
 512     piix3->vm = vm;
 513
 514     dev = v3_add_device(vm, dev_id, &dev_ops, piix3);
 515
 516     if (dev == NULL) {
 517         PrintError(vm, VCORE_NONE, "Could not attach device %s\n", dev_id);
 518         V3_Free(piix3);
 519         return -1;
 520     }
 521
 522     PrintDebug(vm, VCORE_NONE, "Created PIIX3\n");
 523
 524     if (setup_pci(piix3) == -1) {
 525         v3_remove_device(dev);
 526         return -1;
 527     }
 528
 529     return 0;
 530 }
 531
 532
 533 device_register("PIIX3", piix3_init)