virt/kvm/arm/vgic/vgic-mmio.c

   1 /*
   2  * VGIC MMIO handling functions
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/bitops.h>
  15 #include <linux/bsearch.h>
  16 #include <linux/kvm.h>
  17 #include <linux/kvm_host.h>
  18 #include <kvm/iodev.h>
  19 #include <kvm/arm_vgic.h>
  20
  21 #include "vgic.h"
  22 #include "vgic-mmio.h"
  23
  24 unsigned long vgic_mmio_read_raz(struct kvm_vcpu *vcpu,
  25                                  gpa_t addr, unsigned int len)
  26 {
  27         return 0;
  28 }
  29
  30 unsigned long vgic_mmio_read_rao(struct kvm_vcpu *vcpu,
  31                                  gpa_t addr, unsigned int len)
  32 {
  33         return -1UL;
  34 }
  35
  36 void vgic_mmio_write_wi(struct kvm_vcpu *vcpu, gpa_t addr,
  37                         unsigned int len, unsigned long val)
  38 {
  39         /* Ignore */
  40 }
  41
  42 /*
  43  * Read accesses to both GICD_ICENABLER and GICD_ISENABLER return the value
  44  * of the enabled bit, so there is only one function for both here.
  45  */
  46 unsigned long vgic_mmio_read_enable(struct kvm_vcpu *vcpu,
  47                                     gpa_t addr, unsigned int len)
  48 {
  49         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  50         u32 value = 0;
  51         int i;
  52
  53         /* Loop over all IRQs affected by this read */
  54         for (i = 0; i < len * 8; i++) {
  55                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  56
  57                 if (irq->enabled)
  58                         value |= (1U << i);
  59
  60                 vgic_put_irq(vcpu->kvm, irq);
  61         }
  62
  63         return value;
  64 }
  65
  66 void vgic_mmio_write_senable(struct kvm_vcpu *vcpu,
  67                              gpa_t addr, unsigned int len,
  68                              unsigned long val)
  69 {
  70         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  71         int i;
  72
  73         for_each_set_bit(i, &val, len * 8) {
  74                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  75
  76                 spin_lock(&irq->irq_lock);
  77                 irq->enabled = true;
  78                 vgic_queue_irq_unlock(vcpu->kvm, irq);
  79
  80                 vgic_put_irq(vcpu->kvm, irq);
  81         }
  82 }
  83
  84 void vgic_mmio_write_cenable(struct kvm_vcpu *vcpu,
  85                              gpa_t addr, unsigned int len,
  86                              unsigned long val)
  87 {
  88         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
  89         int i;
  90
  91         for_each_set_bit(i, &val, len * 8) {
  92                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
  93
  94                 spin_lock(&irq->irq_lock);
  95
  96                 irq->enabled = false;
  97
  98                 spin_unlock(&irq->irq_lock);
  99                 vgic_put_irq(vcpu->kvm, irq);
 100         }
 101 }
 102
 103 unsigned long vgic_mmio_read_pending(struct kvm_vcpu *vcpu,
 104                                      gpa_t addr, unsigned int len)
 105 {
 106         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 107         u32 value = 0;
 108         int i;
 109
 110         /* Loop over all IRQs affected by this read */
 111         for (i = 0; i < len * 8; i++) {
 112                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 113
 114                 if (irq_is_pending(irq))
 115                         value |= (1U << i);
 116
 117                 vgic_put_irq(vcpu->kvm, irq);
 118         }
 119
 120         return value;
 121 }
 122
 123 void vgic_mmio_write_spending(struct kvm_vcpu *vcpu,
 124                               gpa_t addr, unsigned int len,
 125                               unsigned long val)
 126 {
 127         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 128         int i;
 129
 130         for_each_set_bit(i, &val, len * 8) {
 131                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 132
 133                 spin_lock(&irq->irq_lock);
 134                 irq->pending_latch = true;
 135
 136                 vgic_queue_irq_unlock(vcpu->kvm, irq);
 137                 vgic_put_irq(vcpu->kvm, irq);
 138         }
 139 }
 140
 141 void vgic_mmio_write_cpending(struct kvm_vcpu *vcpu,
 142                               gpa_t addr, unsigned int len,
 143                               unsigned long val)
 144 {
 145         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 146         int i;
 147
 148         for_each_set_bit(i, &val, len * 8) {
 149                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 150
 151                 spin_lock(&irq->irq_lock);
 152
 153                 irq->pending_latch = false;
 154
 155                 spin_unlock(&irq->irq_lock);
 156                 vgic_put_irq(vcpu->kvm, irq);
 157         }
 158 }
 159
 160 unsigned long vgic_mmio_read_active(struct kvm_vcpu *vcpu,
 161                                     gpa_t addr, unsigned int len)
 162 {
 163         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 164         u32 value = 0;
 165         int i;
 166
 167         /* Loop over all IRQs affected by this read */
 168         for (i = 0; i < len * 8; i++) {
 169                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 170
 171                 if (irq->active)
 172                         value |= (1U << i);
 173
 174                 vgic_put_irq(vcpu->kvm, irq);
 175         }
 176
 177         return value;
 178 }
 179
 180 static void vgic_mmio_change_active(struct kvm_vcpu *vcpu, struct vgic_irq *irq,
 181                                     bool new_active_state)
 182 {
 183         spin_lock(&irq->irq_lock);
 184         /*
 185          * If this virtual IRQ was written into a list register, we
 186          * have to make sure the CPU that runs the VCPU thread has
 187          * synced back LR state to the struct vgic_irq.  We can only
 188          * know this for sure, when either this irq is not assigned to
 189          * anyone's AP list anymore, or the VCPU thread is not
 190          * running on any CPUs.
 191          *
 192          * In the opposite case, we know the VCPU thread may be on its
 193          * way back from the guest and still has to sync back this
 194          * IRQ, so we release and re-acquire the spin_lock to let the
 195          * other thread sync back the IRQ.
 196          */
 197         while (irq->vcpu && /* IRQ may have state in an LR somewhere */
 198                irq->vcpu->cpu != -1) /* VCPU thread is running */
 199                 cond_resched_lock(&irq->irq_lock);
 200
 201         irq->active = new_active_state;
 202         if (new_active_state)
 203                 vgic_queue_irq_unlock(vcpu->kvm, irq);
 204         else
 205                 spin_unlock(&irq->irq_lock);
 206 }
 207
 208 /*
 209  * If we are fiddling with an IRQ's active state, we have to make sure the IRQ
 210  * is not queued on some running VCPU's LRs, because then the change to the
 211  * active state can be overwritten when the VCPU's state is synced coming back
 212  * from the guest.
 213  *
 214  * For shared interrupts, we have to stop all the VCPUs because interrupts can
 215  * be migrated while we don't hold the IRQ locks and we don't want to be
 216  * chasing moving targets.
 217  *
 218  * For private interrupts, we only have to make sure the single and only VCPU
 219  * that can potentially queue the IRQ is stopped.
 220  */
 221 static void vgic_change_active_prepare(struct kvm_vcpu *vcpu, u32 intid)
 222 {
 223         if (intid < VGIC_NR_PRIVATE_IRQS)
 224                 kvm_arm_halt_vcpu(vcpu);
 225         else
 226                 kvm_arm_halt_guest(vcpu->kvm);
 227 }
 228
 229 /* See vgic_change_active_prepare */
 230 static void vgic_change_active_finish(struct kvm_vcpu *vcpu, u32 intid)
 231 {
 232         if (intid < VGIC_NR_PRIVATE_IRQS)
 233                 kvm_arm_resume_vcpu(vcpu);
 234         else
 235                 kvm_arm_resume_guest(vcpu->kvm);
 236 }
 237
 238 void vgic_mmio_write_cactive(struct kvm_vcpu *vcpu,
 239                              gpa_t addr, unsigned int len,
 240                              unsigned long val)
 241 {
 242         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 243         int i;
 244
 245         vgic_change_active_prepare(vcpu, intid);
 246         for_each_set_bit(i, &val, len * 8) {
 247                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 248                 vgic_mmio_change_active(vcpu, irq, false);
 249                 vgic_put_irq(vcpu->kvm, irq);
 250         }
 251         vgic_change_active_finish(vcpu, intid);
 252 }
 253
 254 void vgic_mmio_write_sactive(struct kvm_vcpu *vcpu,
 255                              gpa_t addr, unsigned int len,
 256                              unsigned long val)
 257 {
 258         u32 intid = VGIC_ADDR_TO_INTID(addr, 1);
 259         int i;
 260
 261         vgic_change_active_prepare(vcpu, intid);
 262         for_each_set_bit(i, &val, len * 8) {
 263                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 264                 vgic_mmio_change_active(vcpu, irq, true);
 265                 vgic_put_irq(vcpu->kvm, irq);
 266         }
 267         vgic_change_active_finish(vcpu, intid);
 268 }
 269
 270 unsigned long vgic_mmio_read_priority(struct kvm_vcpu *vcpu,
 271                                       gpa_t addr, unsigned int len)
 272 {
 273         u32 intid = VGIC_ADDR_TO_INTID(addr, 8);
 274         int i;
 275         u64 val = 0;
 276
 277         for (i = 0; i < len; i++) {
 278                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 279
 280                 val |= (u64)irq->priority << (i * 8);
 281
 282                 vgic_put_irq(vcpu->kvm, irq);
 283         }
 284
 285         return val;
 286 }
 287
 288 /*
 289  * We currently don't handle changing the priority of an interrupt that
 290  * is already pending on a VCPU. If there is a need for this, we would
 291  * need to make this VCPU exit and re-evaluate the priorities, potentially
 292  * leading to this interrupt getting presented now to the guest (if it has
 293  * been masked by the priority mask before).
 294  */
 295 void vgic_mmio_write_priority(struct kvm_vcpu *vcpu,
 296                               gpa_t addr, unsigned int len,
 297                               unsigned long val)
 298 {
 299         u32 intid = VGIC_ADDR_TO_INTID(addr, 8);
 300         int i;
 301
 302         for (i = 0; i < len; i++) {
 303                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 304
 305                 spin_lock(&irq->irq_lock);
 306                 /* Narrow the priority range to what we actually support */
 307                 irq->priority = (val >> (i * 8)) & GENMASK(7, 8 - VGIC_PRI_BITS);
 308                 spin_unlock(&irq->irq_lock);
 309
 310                 vgic_put_irq(vcpu->kvm, irq);
 311         }
 312 }
 313
 314 unsigned long vgic_mmio_read_config(struct kvm_vcpu *vcpu,
 315                                     gpa_t addr, unsigned int len)
 316 {
 317         u32 intid = VGIC_ADDR_TO_INTID(addr, 2);
 318         u32 value = 0;
 319         int i;
 320
 321         for (i = 0; i < len * 4; i++) {
 322                 struct vgic_irq *irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 323
 324                 if (irq->config == VGIC_CONFIG_EDGE)
 325                         value |= (2U << (i * 2));
 326
 327                 vgic_put_irq(vcpu->kvm, irq);
 328         }
 329
 330         return value;
 331 }
 332
 333 void vgic_mmio_write_config(struct kvm_vcpu *vcpu,
 334                             gpa_t addr, unsigned int len,
 335                             unsigned long val)
 336 {
 337         u32 intid = VGIC_ADDR_TO_INTID(addr, 2);
 338         int i;
 339
 340         for (i = 0; i < len * 4; i++) {
 341                 struct vgic_irq *irq;
 342
 343                 /*
 344                  * The configuration cannot be changed for SGIs in general,
 345                  * for PPIs this is IMPLEMENTATION DEFINED. The arch timer
 346                  * code relies on PPIs being level triggered, so we also
 347                  * make them read-only here.
 348                  */
 349                 if (intid + i < VGIC_NR_PRIVATE_IRQS)
 350                         continue;
 351
 352                 irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 353                 spin_lock(&irq->irq_lock);
 354
 355                 if (test_bit(i * 2 + 1, &val))
 356                         irq->config = VGIC_CONFIG_EDGE;
 357                 else
 358                         irq->config = VGIC_CONFIG_LEVEL;
 359
 360                 spin_unlock(&irq->irq_lock);
 361                 vgic_put_irq(vcpu->kvm, irq);
 362         }
 363 }
 364
 365 u64 vgic_read_irq_line_level_info(struct kvm_vcpu *vcpu, u32 intid)
 366 {
 367         int i;
 368         u64 val = 0;
 369         int nr_irqs = vcpu->kvm->arch.vgic.nr_spis + VGIC_NR_PRIVATE_IRQS;
 370
 371         for (i = 0; i < 32; i++) {
 372                 struct vgic_irq *irq;
 373
 374                 if ((intid + i) < VGIC_NR_SGIS || (intid + i) >= nr_irqs)
 375                         continue;
 376
 377                 irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 378                 if (irq->config == VGIC_CONFIG_LEVEL && irq->line_level)
 379                         val |= (1U << i);
 380
 381                 vgic_put_irq(vcpu->kvm, irq);
 382         }
 383
 384         return val;
 385 }
 386
 387 void vgic_write_irq_line_level_info(struct kvm_vcpu *vcpu, u32 intid,
 388                                     const u64 val)
 389 {
 390         int i;
 391         int nr_irqs = vcpu->kvm->arch.vgic.nr_spis + VGIC_NR_PRIVATE_IRQS;
 392
 393         for (i = 0; i < 32; i++) {
 394                 struct vgic_irq *irq;
 395                 bool new_level;
 396
 397                 if ((intid + i) < VGIC_NR_SGIS || (intid + i) >= nr_irqs)
 398                         continue;
 399
 400                 irq = vgic_get_irq(vcpu->kvm, vcpu, intid + i);
 401
 402                 /*
 403                  * Line level is set irrespective of irq type
 404                  * (level or edge) to avoid dependency that VM should
 405                  * restore irq config before line level.
 406                  */
 407                 new_level = !!(val & (1U << i));
 408                 spin_lock(&irq->irq_lock);
 409                 irq->line_level = new_level;
 410                 if (new_level)
 411                         vgic_queue_irq_unlock(vcpu->kvm, irq);
 412                 else
 413                         spin_unlock(&irq->irq_lock);
 414
 415                 vgic_put_irq(vcpu->kvm, irq);
 416         }
 417 }
 418
 419 static int match_region(const void *key, const void *elt)
 420 {
 421         const unsigned int offset = (unsigned long)key;
 422         const struct vgic_register_region *region = elt;
 423
 424         if (offset < region->reg_offset)
 425                 return -1;
 426
 427         if (offset >= region->reg_offset + region->len)
 428                 return 1;
 429
 430         return 0;
 431 }
 432
 433 /* Find the proper register handler entry given a certain address offset. */
 434 static const struct vgic_register_region *
 435 vgic_find_mmio_region(const struct vgic_register_region *region, int nr_regions,
 436                       unsigned int offset)
 437 {
 438         return bsearch((void *)(uintptr_t)offset, region, nr_regions,
 439                        sizeof(region[0]), match_region);
 440 }
 441
 442 void vgic_set_vmcr(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcr)
 443 {
 444         if (kvm_vgic_global_state.type == VGIC_V2)
 445                 vgic_v2_set_vmcr(vcpu, vmcr);
 446         else
 447                 vgic_v3_set_vmcr(vcpu, vmcr);
 448 }
 449
 450 void vgic_get_vmcr(struct kvm_vcpu *vcpu, struct vgic_vmcr *vmcr)
 451 {
 452         if (kvm_vgic_global_state.type == VGIC_V2)
 453                 vgic_v2_get_vmcr(vcpu, vmcr);
 454         else
 455                 vgic_v3_get_vmcr(vcpu, vmcr);
 456 }
 457
 458 /*
 459  * kvm_mmio_read_buf() returns a value in a format where it can be converted
 460  * to a byte array and be directly observed as the guest wanted it to appear
 461  * in memory if it had done the store itself, which is LE for the GIC, as the
 462  * guest knows the GIC is always LE.
 463  *
 464  * We convert this value to the CPUs native format to deal with it as a data
 465  * value.
 466  */
 467 unsigned long vgic_data_mmio_bus_to_host(const void *val, unsigned int len)
 468 {
 469         unsigned long data = kvm_mmio_read_buf(val, len);
 470
 471         switch (len) {
 472         case 1:
 473                 return data;
 474         case 2:
 475                 return le16_to_cpu(data);
 476         case 4:
 477                 return le32_to_cpu(data);
 478         default:
 479                 return le64_to_cpu(data);
 480         }
 481 }
 482
 483 /*
 484  * kvm_mmio_write_buf() expects a value in a format such that if converted to
 485  * a byte array it is observed as the guest would see it if it could perform
 486  * the load directly.  Since the GIC is LE, and the guest knows this, the
 487  * guest expects a value in little endian format.
 488  *
 489  * We convert the data value from the CPUs native format to LE so that the
 490  * value is returned in the proper format.
 491  */
 492 void vgic_data_host_to_mmio_bus(void *buf, unsigned int len,
 493                                 unsigned long data)
 494 {
 495         switch (len) {
 496         case 1:
 497                 break;
 498         case 2:
 499                 data = cpu_to_le16(data);
 500                 break;
 501         case 4:
 502                 data = cpu_to_le32(data);
 503                 break;
 504         default:
 505                 data = cpu_to_le64(data);
 506         }
 507
 508         kvm_mmio_write_buf(buf, len, data);
 509 }
 510
 511 static
 512 struct vgic_io_device *kvm_to_vgic_iodev(const struct kvm_io_device *dev)
 513 {
 514         return container_of(dev, struct vgic_io_device, dev);
 515 }
 516
 517 static bool check_region(const struct kvm *kvm,
 518                          const struct vgic_register_region *region,
 519                          gpa_t addr, int len)
 520 {
 521         int flags, nr_irqs = kvm->arch.vgic.nr_spis + VGIC_NR_PRIVATE_IRQS;
 522
 523         switch (len) {
 524         case sizeof(u8):
 525                 flags = VGIC_ACCESS_8bit;
 526                 break;
 527         case sizeof(u32):
 528                 flags = VGIC_ACCESS_32bit;
 529                 break;
 530         case sizeof(u64):
 531                 flags = VGIC_ACCESS_64bit;
 532                 break;
 533         default:
 534                 return false;
 535         }
 536
 537         if ((region->access_flags & flags) && IS_ALIGNED(addr, len)) {
 538                 if (!region->bits_per_irq)
 539                         return true;
 540
 541                 /* Do we access a non-allocated IRQ? */
 542                 return VGIC_ADDR_TO_INTID(addr, region->bits_per_irq) < nr_irqs;
 543         }
 544
 545         return false;
 546 }
 547
 548 const struct vgic_register_region *
 549 vgic_get_mmio_region(struct kvm_vcpu *vcpu, struct vgic_io_device *iodev,
 550                      gpa_t addr, int len)
 551 {
 552         const struct vgic_register_region *region;
 553
 554         region = vgic_find_mmio_region(iodev->regions, iodev->nr_regions,
 555                                        addr - iodev->base_addr);
 556         if (!region || !check_region(vcpu->kvm, region, addr, len))
 557                 return NULL;
 558
 559         return region;
 560 }
 561
 562 static int vgic_uaccess_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 563                              gpa_t addr, u32 *val)
 564 {
 565         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 566         const struct vgic_register_region *region;
 567         struct kvm_vcpu *r_vcpu;
 568
 569         region = vgic_get_mmio_region(vcpu, iodev, addr, sizeof(u32));
 570         if (!region) {
 571                 *val = 0;
 572                 return 0;
 573         }
 574
 575         r_vcpu = iodev->redist_vcpu ? iodev->redist_vcpu : vcpu;
 576         if (region->uaccess_read)
 577                 *val = region->uaccess_read(r_vcpu, addr, sizeof(u32));
 578         else
 579                 *val = region->read(r_vcpu, addr, sizeof(u32));
 580
 581         return 0;
 582 }
 583
 584 static int vgic_uaccess_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 585                               gpa_t addr, const u32 *val)
 586 {
 587         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 588         const struct vgic_register_region *region;
 589         struct kvm_vcpu *r_vcpu;
 590
 591         region = vgic_get_mmio_region(vcpu, iodev, addr, sizeof(u32));
 592         if (!region)
 593                 return 0;
 594
 595         r_vcpu = iodev->redist_vcpu ? iodev->redist_vcpu : vcpu;
 596         if (region->uaccess_write)
 597                 region->uaccess_write(r_vcpu, addr, sizeof(u32), *val);
 598         else
 599                 region->write(r_vcpu, addr, sizeof(u32), *val);
 600
 601         return 0;
 602 }
 603
 604 /*
 605  * Userland access to VGIC registers.
 606  */
 607 int vgic_uaccess(struct kvm_vcpu *vcpu, struct vgic_io_device *dev,
 608                  bool is_write, int offset, u32 *val)
 609 {
 610         if (is_write)
 611                 return vgic_uaccess_write(vcpu, &dev->dev, offset, val);
 612         else
 613                 return vgic_uaccess_read(vcpu, &dev->dev, offset, val);
 614 }
 615
 616 static int dispatch_mmio_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 617                               gpa_t addr, int len, void *val)
 618 {
 619         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 620         const struct vgic_register_region *region;
 621         unsigned long data = 0;
 622
 623         region = vgic_get_mmio_region(vcpu, iodev, addr, len);
 624         if (!region) {
 625                 memset(val, 0, len);
 626                 return 0;
 627         }
 628
 629         switch (iodev->iodev_type) {
 630         case IODEV_CPUIF:
 631                 data = region->read(vcpu, addr, len);
 632                 break;
 633         case IODEV_DIST:
 634                 data = region->read(vcpu, addr, len);
 635                 break;
 636         case IODEV_REDIST:
 637                 data = region->read(iodev->redist_vcpu, addr, len);
 638                 break;
 639         case IODEV_ITS:
 640                 data = region->its_read(vcpu->kvm, iodev->its, addr, len);
 641                 break;
 642         }
 643
 644         vgic_data_host_to_mmio_bus(val, len, data);
 645         return 0;
 646 }
 647
 648 static int dispatch_mmio_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
 649                                gpa_t addr, int len, const void *val)
 650 {
 651         struct vgic_io_device *iodev = kvm_to_vgic_iodev(dev);
 652         const struct vgic_register_region *region;
 653         unsigned long data = vgic_data_mmio_bus_to_host(val, len);
 654
 655         region = vgic_get_mmio_region(vcpu, iodev, addr, len);
 656         if (!region)
 657                 return 0;
 658
 659         switch (iodev->iodev_type) {
 660         case IODEV_CPUIF:
 661                 region->write(vcpu, addr, len, data);
 662                 break;
 663         case IODEV_DIST:
 664                 region->write(vcpu, addr, len, data);
 665                 break;
 666         case IODEV_REDIST:
 667                 region->write(iodev->redist_vcpu, addr, len, data);
 668                 break;
 669         case IODEV_ITS:
 670                 region->its_write(vcpu->kvm, iodev->its, addr, len, data);
 671                 break;
 672         }
 673
 674         return 0;
 675 }
 676
 677 struct kvm_io_device_ops kvm_io_gic_ops = {
 678         .read = dispatch_mmio_read,
 679         .write = dispatch_mmio_write,
 680 };
 681
 682 int vgic_register_dist_iodev(struct kvm *kvm, gpa_t dist_base_address,
 683                              enum vgic_type type)
 684 {
 685         struct vgic_io_device *io_device = &kvm->arch.vgic.dist_iodev;
 686         int ret = 0;
 687         unsigned int len;
 688
 689         switch (type) {
 690         case VGIC_V2:
 691                 len = vgic_v2_init_dist_iodev(io_device);
 692                 break;
 693         case VGIC_V3:
 694                 len = vgic_v3_init_dist_iodev(io_device);
 695                 break;
 696         default:
 697                 BUG_ON(1);
 698         }
 699
 700         io_device->base_addr = dist_base_address;
 701         io_device->iodev_type = IODEV_DIST;
 702         io_device->redist_vcpu = NULL;
 703
 704         mutex_lock(&kvm->slots_lock);
 705         ret = kvm_io_bus_register_dev(kvm, KVM_MMIO_BUS, dist_base_address,
 706                                       len, &io_device->dev);
 707         mutex_unlock(&kvm->slots_lock);
 708
 709         return ret;
 710 }