2 * Copyright (c) 2007, Neocleus Corporation.
3 * Copyright (c) 2007, Intel Corporation.
5 * This work is licensed under the terms of the GNU GPL, version 2. See
6 * the COPYING file in the top-level directory.
8 * Alex Novik <alex@neocleus.com>
9 * Allen Kay <allen.m.kay@intel.com>
10 * Guy Zana <guy@neocleus.com>
12 * This file implements direct PCI assignment to a HVM guest
16 * Interrupt Disable policy:
19 * Initialize(register_real_device)
20 * Map INTx(xc_physdev_map_pirq):
22 * - Set real Interrupt Disable bit to '1'.
23 * - Set machine_irq and assigned_device->machine_irq to '0'.
26 * Bind INTx(xc_domain_bind_pt_pci_irq):
28 * - Set real Interrupt Disable bit to '1'.
30 * - Decrement xen_pt_mapped_machine_irq[machine_irq]
31 * - Set assigned_device->machine_irq to '0'.
33 * Write to Interrupt Disable bit by guest software(xen_pt_cmd_reg_write)
35 * - Set real bit to '0' if assigned_device->machine_irq isn't '0'.
38 * - Set real bit to '1'.
41 * Initialize MSI register(xen_pt_msi_setup, xen_pt_msi_update)
42 * Bind MSI(xc_domain_update_msi_irq)
45 * - Set dev->msi->pirq to '-1'.
48 * Initialize MSI-X register(xen_pt_msix_update_one)
49 * Bind MSI-X(xc_domain_update_msi_irq)
52 * - Set entry->pirq to '-1'.
55 #include <sys/ioctl.h>
57 #include "hw/pci/pci.h"
58 #include "hw/xen/xen.h"
59 #include "hw/xen/xen_backend.h"
61 #include "qemu/range.h"
62 #include "exec/address-spaces.h"
64 #define XEN_PT_NR_IRQS (256)
65 static uint8_t xen_pt_mapped_machine_irq
[XEN_PT_NR_IRQS
] = {0};
67 void xen_pt_log(const PCIDevice
*d
, const char *f
, ...)
73 fprintf(stderr
, "[%02x:%02x.%d] ", pci_bus_num(d
->bus
),
74 PCI_SLOT(d
->devfn
), PCI_FUNC(d
->devfn
));
76 vfprintf(stderr
, f
, ap
);
82 static int xen_pt_pci_config_access_check(PCIDevice
*d
, uint32_t addr
, int len
)
84 /* check offset range */
86 XEN_PT_ERR(d
, "Failed to access register with offset exceeding 0xFF. "
87 "(addr: 0x%02x, len: %d)\n", addr
, len
);
92 if ((len
!= 1) && (len
!= 2) && (len
!= 4)) {
93 XEN_PT_ERR(d
, "Failed to access register with invalid access length. "
94 "(addr: 0x%02x, len: %d)\n", addr
, len
);
98 /* check offset alignment */
99 if (addr
& (len
- 1)) {
100 XEN_PT_ERR(d
, "Failed to access register with invalid access size "
101 "alignment. (addr: 0x%02x, len: %d)\n", addr
, len
);
108 int xen_pt_bar_offset_to_index(uint32_t offset
)
112 /* check Exp ROM BAR */
113 if (offset
== PCI_ROM_ADDRESS
) {
117 /* calculate BAR index */
118 index
= (offset
- PCI_BASE_ADDRESS_0
) >> 2;
119 if (index
>= PCI_NUM_REGIONS
) {
126 static uint32_t xen_pt_pci_read_config(PCIDevice
*d
, uint32_t addr
, int len
)
128 XenPCIPassthroughState
*s
= XEN_PT_DEVICE(d
);
130 XenPTRegGroup
*reg_grp_entry
= NULL
;
131 XenPTReg
*reg_entry
= NULL
;
134 uint32_t find_addr
= addr
;
136 if (xen_pt_pci_config_access_check(d
, addr
, len
)) {
140 /* find register group entry */
141 reg_grp_entry
= xen_pt_find_reg_grp(s
, addr
);
143 /* check 0-Hardwired register group */
144 if (reg_grp_entry
->reg_grp
->grp_type
== XEN_PT_GRP_TYPE_HARDWIRED
) {
145 /* no need to emulate, just return 0 */
151 /* read I/O device register value */
152 rc
= xen_host_pci_get_block(&s
->real_device
, addr
, (uint8_t *)&val
, len
);
154 XEN_PT_ERR(d
, "pci_read_block failed. return value: %d.\n", rc
);
155 memset(&val
, 0xff, len
);
158 /* just return the I/O device register value for
159 * passthrough type register group */
160 if (reg_grp_entry
== NULL
) {
164 /* adjust the read value to appropriate CFC-CFF window */
165 val
<<= (addr
& 3) << 3;
168 /* loop around the guest requested size */
169 while (emul_len
> 0) {
170 /* find register entry to be emulated */
171 reg_entry
= xen_pt_find_reg(reg_grp_entry
, find_addr
);
173 XenPTRegInfo
*reg
= reg_entry
->reg
;
174 uint32_t real_offset
= reg_grp_entry
->base_offset
+ reg
->offset
;
175 uint32_t valid_mask
= 0xFFFFFFFF >> ((4 - emul_len
) << 3);
176 uint8_t *ptr_val
= NULL
;
178 valid_mask
<<= (find_addr
- real_offset
) << 3;
179 ptr_val
= (uint8_t *)&val
+ (real_offset
& 3);
181 /* do emulation based on register size */
185 rc
= reg
->u
.b
.read(s
, reg_entry
, ptr_val
, valid_mask
);
190 rc
= reg
->u
.w
.read(s
, reg_entry
,
191 (uint16_t *)ptr_val
, valid_mask
);
195 if (reg
->u
.dw
.read
) {
196 rc
= reg
->u
.dw
.read(s
, reg_entry
,
197 (uint32_t *)ptr_val
, valid_mask
);
203 xen_shutdown_fatal_error("Internal error: Invalid read "
204 "emulation. (%s, rc: %d)\n",
209 /* calculate next address to find */
210 emul_len
-= reg
->size
;
212 find_addr
= real_offset
+ reg
->size
;
215 /* nothing to do with passthrough type register,
216 * continue to find next byte */
222 /* need to shift back before returning them to pci bus emulator */
223 val
>>= ((addr
& 3) << 3);
226 XEN_PT_LOG_CONFIG(d
, addr
, val
, len
);
230 static void xen_pt_pci_write_config(PCIDevice
*d
, uint32_t addr
,
231 uint32_t val
, int len
)
233 XenPCIPassthroughState
*s
= XEN_PT_DEVICE(d
);
235 XenPTRegGroup
*reg_grp_entry
= NULL
;
237 uint32_t read_val
= 0, wb_mask
;
239 XenPTReg
*reg_entry
= NULL
;
240 uint32_t find_addr
= addr
;
241 XenPTRegInfo
*reg
= NULL
;
242 bool wp_flag
= false;
244 if (xen_pt_pci_config_access_check(d
, addr
, len
)) {
248 XEN_PT_LOG_CONFIG(d
, addr
, val
, len
);
250 /* check unused BAR register */
251 index
= xen_pt_bar_offset_to_index(addr
);
252 if ((index
>= 0) && (val
!= 0)) {
255 if (index
== PCI_ROM_SLOT
)
256 chk
|= (uint32_t)~PCI_ROM_ADDRESS_MASK
;
258 if ((chk
!= XEN_PT_BAR_ALLF
) &&
259 (s
->bases
[index
].bar_flag
== XEN_PT_BAR_FLAG_UNUSED
)) {
260 XEN_PT_WARN(d
, "Guest attempt to set address to unused "
261 "Base Address Register. (addr: 0x%02x, len: %d)\n",
266 /* find register group entry */
267 reg_grp_entry
= xen_pt_find_reg_grp(s
, addr
);
269 /* check 0-Hardwired register group */
270 if (reg_grp_entry
->reg_grp
->grp_type
== XEN_PT_GRP_TYPE_HARDWIRED
) {
271 /* ignore silently */
272 XEN_PT_WARN(d
, "Access to 0-Hardwired register. "
273 "(addr: 0x%02x, len: %d)\n", addr
, len
);
278 rc
= xen_host_pci_get_block(&s
->real_device
, addr
,
279 (uint8_t *)&read_val
, len
);
281 XEN_PT_ERR(d
, "pci_read_block failed. return value: %d.\n", rc
);
282 memset(&read_val
, 0xff, len
);
285 wb_mask
= 0xFFFFFFFF >> ((4 - len
) << 3);
288 /* pass directly to the real device for passthrough type register group */
289 if (reg_grp_entry
== NULL
) {
290 if (!s
->permissive
) {
297 memory_region_transaction_begin();
298 pci_default_write_config(d
, addr
, val
, len
);
300 /* adjust the read and write value to appropriate CFC-CFF window */
301 read_val
<<= (addr
& 3) << 3;
302 val
<<= (addr
& 3) << 3;
305 /* loop around the guest requested size */
306 while (emul_len
> 0) {
307 /* find register entry to be emulated */
308 reg_entry
= xen_pt_find_reg(reg_grp_entry
, find_addr
);
310 reg
= reg_entry
->reg
;
311 uint32_t real_offset
= reg_grp_entry
->base_offset
+ reg
->offset
;
312 uint32_t valid_mask
= 0xFFFFFFFF >> ((4 - emul_len
) << 3);
313 uint8_t *ptr_val
= NULL
;
314 uint32_t wp_mask
= reg
->emu_mask
| reg
->ro_mask
;
316 valid_mask
<<= (find_addr
- real_offset
) << 3;
317 ptr_val
= (uint8_t *)&val
+ (real_offset
& 3);
318 if (!s
->permissive
) {
319 wp_mask
|= reg
->res_mask
;
321 if (wp_mask
== (0xFFFFFFFF >> ((4 - reg
->size
) << 3))) {
322 wb_mask
&= ~((wp_mask
>> ((find_addr
- real_offset
) << 3))
323 << ((len
- emul_len
) << 3));
326 /* do emulation based on register size */
329 if (reg
->u
.b
.write
) {
330 rc
= reg
->u
.b
.write(s
, reg_entry
, ptr_val
,
331 read_val
>> ((real_offset
& 3) << 3),
336 if (reg
->u
.w
.write
) {
337 rc
= reg
->u
.w
.write(s
, reg_entry
, (uint16_t *)ptr_val
,
338 (read_val
>> ((real_offset
& 3) << 3)),
343 if (reg
->u
.dw
.write
) {
344 rc
= reg
->u
.dw
.write(s
, reg_entry
, (uint32_t *)ptr_val
,
345 (read_val
>> ((real_offset
& 3) << 3)),
352 xen_shutdown_fatal_error("Internal error: Invalid write"
353 " emulation. (%s, rc: %d)\n",
358 /* calculate next address to find */
359 emul_len
-= reg
->size
;
361 find_addr
= real_offset
+ reg
->size
;
364 /* nothing to do with passthrough type register,
365 * continue to find next byte */
366 if (!s
->permissive
) {
367 wb_mask
&= ~(0xff << ((len
- emul_len
) << 3));
368 /* Unused BARs will make it here, but we don't want to issue
369 * warnings for writes to them (bogus writes get dealt with
381 /* need to shift back before passing them to xen_host_pci_device */
382 val
>>= (addr
& 3) << 3;
384 memory_region_transaction_commit();
387 if (wp_flag
&& !s
->permissive_warned
) {
388 s
->permissive_warned
= true;
389 xen_pt_log(d
, "Write-back to unknown field 0x%02x (partially) inhibited (0x%0*x)\n",
390 addr
, len
* 2, wb_mask
);
391 xen_pt_log(d
, "If the device doesn't work, try enabling permissive mode\n");
392 xen_pt_log(d
, "(unsafe) and if it helps report the problem to xen-devel\n");
394 for (index
= 0; wb_mask
; index
+= len
) {
395 /* unknown regs are passed through */
396 while (!(wb_mask
& 0xff)) {
404 } while (wb_mask
& 0xff);
405 rc
= xen_host_pci_set_block(&s
->real_device
, addr
+ index
,
406 (uint8_t *)&val
+ index
, len
);
409 XEN_PT_ERR(d
, "pci_write_block failed. return value: %d.\n", rc
);
414 /* register regions */
416 static uint64_t xen_pt_bar_read(void *o
, hwaddr addr
,
420 /* if this function is called, that probably means that there is a
421 * misconfiguration of the IOMMU. */
422 XEN_PT_ERR(d
, "Should not read BAR through QEMU. @0x"TARGET_FMT_plx
"\n",
426 static void xen_pt_bar_write(void *o
, hwaddr addr
, uint64_t val
,
430 /* Same comment as xen_pt_bar_read function */
431 XEN_PT_ERR(d
, "Should not write BAR through QEMU. @0x"TARGET_FMT_plx
"\n",
435 static const MemoryRegionOps ops
= {
436 .endianness
= DEVICE_NATIVE_ENDIAN
,
437 .read
= xen_pt_bar_read
,
438 .write
= xen_pt_bar_write
,
441 static int xen_pt_register_regions(XenPCIPassthroughState
*s
, uint16_t *cmd
)
444 XenHostPCIDevice
*d
= &s
->real_device
;
446 /* Register PIO/MMIO BARs */
447 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
448 XenHostPCIIORegion
*r
= &d
->io_regions
[i
];
451 if (r
->base_addr
== 0 || r
->size
== 0) {
455 s
->bases
[i
].access
.u
= r
->base_addr
;
457 if (r
->type
& XEN_HOST_PCI_REGION_TYPE_IO
) {
458 type
= PCI_BASE_ADDRESS_SPACE_IO
;
459 *cmd
|= PCI_COMMAND_IO
;
461 type
= PCI_BASE_ADDRESS_SPACE_MEMORY
;
462 if (r
->type
& XEN_HOST_PCI_REGION_TYPE_PREFETCH
) {
463 type
|= PCI_BASE_ADDRESS_MEM_PREFETCH
;
465 if (r
->type
& XEN_HOST_PCI_REGION_TYPE_MEM_64
) {
466 type
|= PCI_BASE_ADDRESS_MEM_TYPE_64
;
468 *cmd
|= PCI_COMMAND_MEMORY
;
471 memory_region_init_io(&s
->bar
[i
], OBJECT(s
), &ops
, &s
->dev
,
472 "xen-pci-pt-bar", r
->size
);
473 pci_register_bar(&s
->dev
, i
, type
, &s
->bar
[i
]);
475 XEN_PT_LOG(&s
->dev
, "IO region %i registered (size=0x%08"PRIx64
476 " base_addr=0x%08"PRIx64
" type: %#x)\n",
477 i
, r
->size
, r
->base_addr
, type
);
480 /* Register expansion ROM address */
481 if (d
->rom
.base_addr
&& d
->rom
.size
) {
482 uint32_t bar_data
= 0;
484 /* Re-set BAR reported by OS, otherwise ROM can't be read. */
485 if (xen_host_pci_get_long(d
, PCI_ROM_ADDRESS
, &bar_data
)) {
488 if ((bar_data
& PCI_ROM_ADDRESS_MASK
) == 0) {
489 bar_data
|= d
->rom
.base_addr
& PCI_ROM_ADDRESS_MASK
;
490 xen_host_pci_set_long(d
, PCI_ROM_ADDRESS
, bar_data
);
493 s
->bases
[PCI_ROM_SLOT
].access
.maddr
= d
->rom
.base_addr
;
495 memory_region_init_io(&s
->rom
, OBJECT(s
), &ops
, &s
->dev
,
496 "xen-pci-pt-rom", d
->rom
.size
);
497 pci_register_bar(&s
->dev
, PCI_ROM_SLOT
, PCI_BASE_ADDRESS_MEM_PREFETCH
,
500 XEN_PT_LOG(&s
->dev
, "Expansion ROM registered (size=0x%08"PRIx64
501 " base_addr=0x%08"PRIx64
")\n",
502 d
->rom
.size
, d
->rom
.base_addr
);
505 xen_pt_register_vga_regions(d
);
511 static int xen_pt_bar_from_region(XenPCIPassthroughState
*s
, MemoryRegion
*mr
)
515 for (i
= 0; i
< PCI_NUM_REGIONS
- 1; i
++) {
516 if (mr
== &s
->bar
[i
]) {
527 * This function checks if an io_region overlaps an io_region from another
528 * device. The io_region to check is provided with (addr, size and type)
529 * A callback can be provided and will be called for every region that is
531 * The return value indicates if the region is overlappsed */
532 struct CheckBarArgs
{
533 XenPCIPassthroughState
*s
;
539 static void xen_pt_check_bar_overlap(PCIBus
*bus
, PCIDevice
*d
, void *opaque
)
541 struct CheckBarArgs
*arg
= opaque
;
542 XenPCIPassthroughState
*s
= arg
->s
;
543 uint8_t type
= arg
->type
;
546 if (d
->devfn
== s
->dev
.devfn
) {
550 /* xxx: This ignores bridges. */
551 for (i
= 0; i
< PCI_NUM_REGIONS
; i
++) {
552 const PCIIORegion
*r
= &d
->io_regions
[i
];
557 if ((type
& PCI_BASE_ADDRESS_SPACE_IO
)
558 != (r
->type
& PCI_BASE_ADDRESS_SPACE_IO
)) {
562 if (ranges_overlap(arg
->addr
, arg
->size
, r
->addr
, r
->size
)) {
564 "Overlapped to device [%02x:%02x.%d] Region: %i"
565 " (addr: %#"FMT_PCIBUS
", len: %#"FMT_PCIBUS
")\n",
566 pci_bus_num(bus
), PCI_SLOT(d
->devfn
),
567 PCI_FUNC(d
->devfn
), i
, r
->addr
, r
->size
);
573 static void xen_pt_region_update(XenPCIPassthroughState
*s
,
574 MemoryRegionSection
*sec
, bool adding
)
576 PCIDevice
*d
= &s
->dev
;
577 MemoryRegion
*mr
= sec
->mr
;
580 int op
= adding
? DPCI_ADD_MAPPING
: DPCI_REMOVE_MAPPING
;
581 struct CheckBarArgs args
= {
583 .addr
= sec
->offset_within_address_space
,
584 .size
= int128_get64(sec
->size
),
588 bar
= xen_pt_bar_from_region(s
, mr
);
589 if (bar
== -1 && (!s
->msix
|| &s
->msix
->mmio
!= mr
)) {
593 if (s
->msix
&& &s
->msix
->mmio
== mr
) {
595 s
->msix
->mmio_base_addr
= sec
->offset_within_address_space
;
596 rc
= xen_pt_msix_update_remap(s
, s
->msix
->bar_index
);
601 args
.type
= d
->io_regions
[bar
].type
;
602 pci_for_each_device(d
->bus
, pci_bus_num(d
->bus
),
603 xen_pt_check_bar_overlap
, &args
);
605 XEN_PT_WARN(d
, "Region: %d (addr: %#"FMT_PCIBUS
606 ", len: %#"FMT_PCIBUS
") is overlapped.\n",
607 bar
, sec
->offset_within_address_space
,
608 int128_get64(sec
->size
));
611 if (d
->io_regions
[bar
].type
& PCI_BASE_ADDRESS_SPACE_IO
) {
612 uint32_t guest_port
= sec
->offset_within_address_space
;
613 uint32_t machine_port
= s
->bases
[bar
].access
.pio_base
;
614 uint32_t size
= int128_get64(sec
->size
);
615 rc
= xc_domain_ioport_mapping(xen_xc
, xen_domid
,
616 guest_port
, machine_port
, size
,
619 XEN_PT_ERR(d
, "%s ioport mapping failed! (err: %i)\n",
620 adding
? "create new" : "remove old", errno
);
623 pcibus_t guest_addr
= sec
->offset_within_address_space
;
624 pcibus_t machine_addr
= s
->bases
[bar
].access
.maddr
625 + sec
->offset_within_region
;
626 pcibus_t size
= int128_get64(sec
->size
);
627 rc
= xc_domain_memory_mapping(xen_xc
, xen_domid
,
628 XEN_PFN(guest_addr
+ XC_PAGE_SIZE
- 1),
629 XEN_PFN(machine_addr
+ XC_PAGE_SIZE
- 1),
630 XEN_PFN(size
+ XC_PAGE_SIZE
- 1),
633 XEN_PT_ERR(d
, "%s mem mapping failed! (err: %i)\n",
634 adding
? "create new" : "remove old", errno
);
639 static void xen_pt_region_add(MemoryListener
*l
, MemoryRegionSection
*sec
)
641 XenPCIPassthroughState
*s
= container_of(l
, XenPCIPassthroughState
,
644 memory_region_ref(sec
->mr
);
645 xen_pt_region_update(s
, sec
, true);
648 static void xen_pt_region_del(MemoryListener
*l
, MemoryRegionSection
*sec
)
650 XenPCIPassthroughState
*s
= container_of(l
, XenPCIPassthroughState
,
653 xen_pt_region_update(s
, sec
, false);
654 memory_region_unref(sec
->mr
);
657 static void xen_pt_io_region_add(MemoryListener
*l
, MemoryRegionSection
*sec
)
659 XenPCIPassthroughState
*s
= container_of(l
, XenPCIPassthroughState
,
662 memory_region_ref(sec
->mr
);
663 xen_pt_region_update(s
, sec
, true);
666 static void xen_pt_io_region_del(MemoryListener
*l
, MemoryRegionSection
*sec
)
668 XenPCIPassthroughState
*s
= container_of(l
, XenPCIPassthroughState
,
671 xen_pt_region_update(s
, sec
, false);
672 memory_region_unref(sec
->mr
);
675 static const MemoryListener xen_pt_memory_listener
= {
676 .region_add
= xen_pt_region_add
,
677 .region_del
= xen_pt_region_del
,
681 static const MemoryListener xen_pt_io_listener
= {
682 .region_add
= xen_pt_io_region_add
,
683 .region_del
= xen_pt_io_region_del
,
689 static int xen_pt_initfn(PCIDevice
*d
)
691 XenPCIPassthroughState
*s
= XEN_PT_DEVICE(d
);
693 uint8_t machine_irq
= 0;
695 int pirq
= XEN_PT_UNASSIGNED_PIRQ
;
697 /* register real device */
698 XEN_PT_LOG(d
, "Assigning real physical device %02x:%02x.%d"
700 s
->hostaddr
.bus
, s
->hostaddr
.slot
, s
->hostaddr
.function
,
703 rc
= xen_host_pci_device_get(&s
->real_device
,
704 s
->hostaddr
.domain
, s
->hostaddr
.bus
,
705 s
->hostaddr
.slot
, s
->hostaddr
.function
);
707 XEN_PT_ERR(d
, "Failed to \"open\" the real pci device. rc: %i\n", rc
);
711 s
->is_virtfn
= s
->real_device
.is_virtfn
;
713 XEN_PT_LOG(d
, "%04x:%02x:%02x.%d is a SR-IOV Virtual Function\n",
714 s
->real_device
.domain
, s
->real_device
.bus
,
715 s
->real_device
.dev
, s
->real_device
.func
);
718 /* Initialize virtualized PCI configuration (Extended 256 Bytes) */
719 if (xen_host_pci_get_block(&s
->real_device
, 0, d
->config
,
720 PCI_CONFIG_SPACE_SIZE
) == -1) {
721 xen_host_pci_device_put(&s
->real_device
);
725 s
->memory_listener
= xen_pt_memory_listener
;
726 s
->io_listener
= xen_pt_io_listener
;
728 /* Handle real device's MMIO/PIO BARs */
729 xen_pt_register_regions(s
, &cmd
);
731 /* reinitialize each config register to be emulated */
732 if (xen_pt_config_init(s
)) {
733 XEN_PT_ERR(d
, "PCI Config space initialisation failed.\n");
734 xen_host_pci_device_put(&s
->real_device
);
739 if (!s
->dev
.config
[PCI_INTERRUPT_PIN
]) {
740 XEN_PT_LOG(d
, "no pin interrupt\n");
744 machine_irq
= s
->real_device
.irq
;
745 rc
= xc_physdev_map_pirq(xen_xc
, xen_domid
, machine_irq
, &pirq
);
748 XEN_PT_ERR(d
, "Mapping machine irq %u to pirq %i failed, (err: %d)\n",
749 machine_irq
, pirq
, errno
);
751 /* Disable PCI intx assertion (turn on bit10 of devctl) */
752 cmd
|= PCI_COMMAND_INTX_DISABLE
;
757 s
->machine_irq
= pirq
;
758 xen_pt_mapped_machine_irq
[machine_irq
]++;
761 /* bind machine_irq to device */
762 if (machine_irq
!= 0) {
763 uint8_t e_intx
= xen_pt_pci_intx(s
);
765 rc
= xc_domain_bind_pt_pci_irq(xen_xc
, xen_domid
, machine_irq
,
770 XEN_PT_ERR(d
, "Binding of interrupt %i failed! (err: %d)\n",
773 /* Disable PCI intx assertion (turn on bit10 of devctl) */
774 cmd
|= PCI_COMMAND_INTX_DISABLE
;
775 xen_pt_mapped_machine_irq
[machine_irq
]--;
777 if (xen_pt_mapped_machine_irq
[machine_irq
] == 0) {
778 if (xc_physdev_unmap_pirq(xen_xc
, xen_domid
, machine_irq
)) {
779 XEN_PT_ERR(d
, "Unmapping of machine interrupt %i failed!"
780 " (err: %d)\n", machine_irq
, errno
);
789 xen_host_pci_set_word(&s
->real_device
, PCI_COMMAND
,
790 pci_get_word(d
->config
+ PCI_COMMAND
) | cmd
);
793 memory_listener_register(&s
->memory_listener
, &s
->dev
.bus_master_as
);
794 memory_listener_register(&s
->io_listener
, &address_space_io
);
796 "Real physical device %02x:%02x.%d registered successfully!\n",
797 s
->hostaddr
.bus
, s
->hostaddr
.slot
, s
->hostaddr
.function
);
802 static void xen_pt_unregister_device(PCIDevice
*d
)
804 XenPCIPassthroughState
*s
= XEN_PT_DEVICE(d
);
805 XenHostPCIDevice
*host_dev
= &s
->real_device
;
806 uint8_t machine_irq
= s
->machine_irq
;
807 uint8_t intx
= xen_pt_pci_intx(s
);
811 rc
= xc_domain_unbind_pt_irq(xen_xc
, xen_domid
, machine_irq
,
814 PCI_SLOT(s
->dev
.devfn
),
818 XEN_PT_ERR(d
, "unbinding of interrupt INT%c failed."
819 " (machine irq: %i, err: %d)"
820 " But bravely continuing on..\n",
821 'a' + intx
, machine_irq
, errno
);
826 xen_pt_msi_disable(s
);
829 xen_pt_msix_disable(s
);
833 xen_pt_mapped_machine_irq
[machine_irq
]--;
835 if (xen_pt_mapped_machine_irq
[machine_irq
] == 0) {
836 rc
= xc_physdev_unmap_pirq(xen_xc
, xen_domid
, machine_irq
);
839 XEN_PT_ERR(d
, "unmapping of interrupt %i failed. (err: %d)"
840 " But bravely continuing on..\n",
846 /* delete all emulated config registers */
847 xen_pt_config_delete(s
);
849 xen_pt_unregister_vga_regions(host_dev
);
851 memory_listener_unregister(&s
->memory_listener
);
852 memory_listener_unregister(&s
->io_listener
);
854 xen_host_pci_device_put(&s
->real_device
);
857 static Property xen_pci_passthrough_properties
[] = {
858 DEFINE_PROP_PCI_HOST_DEVADDR("hostaddr", XenPCIPassthroughState
, hostaddr
),
859 DEFINE_PROP_BOOL("permissive", XenPCIPassthroughState
, permissive
, false),
860 DEFINE_PROP_END_OF_LIST(),
863 static void xen_pci_passthrough_class_init(ObjectClass
*klass
, void *data
)
865 DeviceClass
*dc
= DEVICE_CLASS(klass
);
866 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
868 k
->init
= xen_pt_initfn
;
869 k
->exit
= xen_pt_unregister_device
;
870 k
->config_read
= xen_pt_pci_read_config
;
871 k
->config_write
= xen_pt_pci_write_config
;
872 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
873 dc
->desc
= "Assign an host PCI device with Xen";
874 dc
->props
= xen_pci_passthrough_properties
;
877 static const TypeInfo xen_pci_passthrough_info
= {
878 .name
= TYPE_XEN_PT_DEVICE
,
879 .parent
= TYPE_PCI_DEVICE
,
880 .instance_size
= sizeof(XenPCIPassthroughState
),
881 .class_init
= xen_pci_passthrough_class_init
,
884 static void xen_pci_passthrough_register_types(void)
886 type_register_static(&xen_pci_passthrough_info
);
889 type_init(xen_pci_passthrough_register_types
)