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
15 #include "qemu/timer.h"
16 #include "hw/xen/xen_backend.h"
19 #define XEN_PT_MERGE_VALUE(value, data, val_mask) \
20 (((value) & (val_mask)) | ((data) & ~(val_mask)))
22 #define XEN_PT_INVALID_REG 0xFFFFFFFF /* invalid register value */
26 static int xen_pt_ptr_reg_init(XenPCIPassthroughState
*s
, XenPTRegInfo
*reg
,
27 uint32_t real_offset
, uint32_t *data
);
32 /* A return value of 1 means the capability should NOT be exposed to guest. */
33 static int xen_pt_hide_dev_cap(const XenHostPCIDevice
*d
, uint8_t grp_id
)
37 /* The PCI Express Capability Structure of the VF of Intel 82599 10GbE
38 * Controller looks trivial, e.g., the PCI Express Capabilities
39 * Register is 0. We should not try to expose it to guest.
41 * The datasheet is available at
42 * http://download.intel.com/design/network/datashts/82599_datasheet.pdf
44 * See 'Table 9.7. VF PCIe Configuration Space' of the datasheet, the
45 * PCI Express Capability Structure of the VF of Intel 82599 10GbE
46 * Controller looks trivial, e.g., the PCI Express Capabilities
47 * Register is 0, so the Capability Version is 0 and
48 * xen_pt_pcie_size_init() would fail.
50 if (d
->vendor_id
== PCI_VENDOR_ID_INTEL
&&
51 d
->device_id
== PCI_DEVICE_ID_INTEL_82599_SFP_VF
) {
59 /* find emulate register group entry */
60 XenPTRegGroup
*xen_pt_find_reg_grp(XenPCIPassthroughState
*s
, uint32_t address
)
62 XenPTRegGroup
*entry
= NULL
;
64 /* find register group entry */
65 QLIST_FOREACH(entry
, &s
->reg_grps
, entries
) {
67 if ((entry
->base_offset
<= address
)
68 && ((entry
->base_offset
+ entry
->size
) > address
)) {
73 /* group entry not found */
77 /* find emulate register entry */
78 XenPTReg
*xen_pt_find_reg(XenPTRegGroup
*reg_grp
, uint32_t address
)
80 XenPTReg
*reg_entry
= NULL
;
81 XenPTRegInfo
*reg
= NULL
;
82 uint32_t real_offset
= 0;
84 /* find register entry */
85 QLIST_FOREACH(reg_entry
, ®_grp
->reg_tbl_list
, entries
) {
87 real_offset
= reg_grp
->base_offset
+ reg
->offset
;
89 if ((real_offset
<= address
)
90 && ((real_offset
+ reg
->size
) > address
)) {
98 static uint32_t get_throughable_mask(const XenPCIPassthroughState
*s
,
99 const XenPTRegInfo
*reg
,
102 uint32_t throughable_mask
= ~(reg
->emu_mask
| reg
->ro_mask
);
104 return throughable_mask
& valid_mask
;
108 * general register functions
111 /* register initialization function */
113 static int xen_pt_common_reg_init(XenPCIPassthroughState
*s
,
114 XenPTRegInfo
*reg
, uint32_t real_offset
,
117 *data
= reg
->init_val
;
121 /* Read register functions */
123 static int xen_pt_byte_reg_read(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
124 uint8_t *value
, uint8_t valid_mask
)
126 XenPTRegInfo
*reg
= cfg_entry
->reg
;
127 uint8_t valid_emu_mask
= 0;
129 /* emulate byte register */
130 valid_emu_mask
= reg
->emu_mask
& valid_mask
;
131 *value
= XEN_PT_MERGE_VALUE(*value
, cfg_entry
->data
, ~valid_emu_mask
);
135 static int xen_pt_word_reg_read(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
136 uint16_t *value
, uint16_t valid_mask
)
138 XenPTRegInfo
*reg
= cfg_entry
->reg
;
139 uint16_t valid_emu_mask
= 0;
141 /* emulate word register */
142 valid_emu_mask
= reg
->emu_mask
& valid_mask
;
143 *value
= XEN_PT_MERGE_VALUE(*value
, cfg_entry
->data
, ~valid_emu_mask
);
147 static int xen_pt_long_reg_read(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
148 uint32_t *value
, uint32_t valid_mask
)
150 XenPTRegInfo
*reg
= cfg_entry
->reg
;
151 uint32_t valid_emu_mask
= 0;
153 /* emulate long register */
154 valid_emu_mask
= reg
->emu_mask
& valid_mask
;
155 *value
= XEN_PT_MERGE_VALUE(*value
, cfg_entry
->data
, ~valid_emu_mask
);
160 /* Write register functions */
162 static int xen_pt_byte_reg_write(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
163 uint8_t *val
, uint8_t dev_value
,
166 XenPTRegInfo
*reg
= cfg_entry
->reg
;
167 uint8_t writable_mask
= 0;
168 uint8_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
170 /* modify emulate register */
171 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
172 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
174 /* create value for writing to I/O device register */
175 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
179 static int xen_pt_word_reg_write(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
180 uint16_t *val
, uint16_t dev_value
,
183 XenPTRegInfo
*reg
= cfg_entry
->reg
;
184 uint16_t writable_mask
= 0;
185 uint16_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
187 /* modify emulate register */
188 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
189 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
191 /* create value for writing to I/O device register */
192 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
196 static int xen_pt_long_reg_write(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
197 uint32_t *val
, uint32_t dev_value
,
200 XenPTRegInfo
*reg
= cfg_entry
->reg
;
201 uint32_t writable_mask
= 0;
202 uint32_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
204 /* modify emulate register */
205 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
206 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
208 /* create value for writing to I/O device register */
209 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
215 /* XenPTRegInfo declaration
216 * - only for emulated register (either a part or whole bit).
217 * - for passthrough register that need special behavior (like interacting with
218 * other component), set emu_mask to all 0 and specify r/w func properly.
219 * - do NOT use ALL F for init_val, otherwise the tbl will not be registered.
222 /********************
226 static int xen_pt_vendor_reg_init(XenPCIPassthroughState
*s
,
227 XenPTRegInfo
*reg
, uint32_t real_offset
,
230 *data
= s
->real_device
.vendor_id
;
233 static int xen_pt_device_reg_init(XenPCIPassthroughState
*s
,
234 XenPTRegInfo
*reg
, uint32_t real_offset
,
237 *data
= s
->real_device
.device_id
;
240 static int xen_pt_status_reg_init(XenPCIPassthroughState
*s
,
241 XenPTRegInfo
*reg
, uint32_t real_offset
,
244 XenPTRegGroup
*reg_grp_entry
= NULL
;
245 XenPTReg
*reg_entry
= NULL
;
246 uint32_t reg_field
= 0;
248 /* find Header register group */
249 reg_grp_entry
= xen_pt_find_reg_grp(s
, PCI_CAPABILITY_LIST
);
251 /* find Capabilities Pointer register */
252 reg_entry
= xen_pt_find_reg(reg_grp_entry
, PCI_CAPABILITY_LIST
);
254 /* check Capabilities Pointer register */
255 if (reg_entry
->data
) {
256 reg_field
|= PCI_STATUS_CAP_LIST
;
258 reg_field
&= ~PCI_STATUS_CAP_LIST
;
261 xen_shutdown_fatal_error("Internal error: Couldn't find XenPTReg*"
262 " for Capabilities Pointer register."
263 " (%s)\n", __func__
);
267 xen_shutdown_fatal_error("Internal error: Couldn't find XenPTRegGroup"
268 " for Header. (%s)\n", __func__
);
275 static int xen_pt_header_type_reg_init(XenPCIPassthroughState
*s
,
276 XenPTRegInfo
*reg
, uint32_t real_offset
,
279 /* read PCI_HEADER_TYPE */
280 *data
= reg
->init_val
| 0x80;
284 /* initialize Interrupt Pin register */
285 static int xen_pt_irqpin_reg_init(XenPCIPassthroughState
*s
,
286 XenPTRegInfo
*reg
, uint32_t real_offset
,
289 *data
= xen_pt_pci_read_intx(s
);
293 /* Command register */
294 static int xen_pt_cmd_reg_write(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
295 uint16_t *val
, uint16_t dev_value
,
298 XenPTRegInfo
*reg
= cfg_entry
->reg
;
299 uint16_t writable_mask
= 0;
300 uint16_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
302 /* modify emulate register */
303 writable_mask
= ~reg
->ro_mask
& valid_mask
;
304 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
306 /* create value for writing to I/O device register */
307 if (*val
& PCI_COMMAND_INTX_DISABLE
) {
308 throughable_mask
|= PCI_COMMAND_INTX_DISABLE
;
310 if (s
->machine_irq
) {
311 throughable_mask
|= PCI_COMMAND_INTX_DISABLE
;
315 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
321 #define XEN_PT_BAR_MEM_RO_MASK 0x0000000F /* BAR ReadOnly mask(Memory) */
322 #define XEN_PT_BAR_MEM_EMU_MASK 0xFFFFFFF0 /* BAR emul mask(Memory) */
323 #define XEN_PT_BAR_IO_RO_MASK 0x00000003 /* BAR ReadOnly mask(I/O) */
324 #define XEN_PT_BAR_IO_EMU_MASK 0xFFFFFFFC /* BAR emul mask(I/O) */
326 static bool is_64bit_bar(PCIIORegion
*r
)
328 return !!(r
->type
& PCI_BASE_ADDRESS_MEM_TYPE_64
);
331 static uint64_t xen_pt_get_bar_size(PCIIORegion
*r
)
333 if (is_64bit_bar(r
)) {
335 size64
= (r
+ 1)->size
;
343 static XenPTBarFlag
xen_pt_bar_reg_parse(XenPCIPassthroughState
*s
,
346 PCIDevice
*d
= &s
->dev
;
347 XenPTRegion
*region
= NULL
;
350 /* check 64bit BAR */
351 if ((0 < index
) && (index
< PCI_ROM_SLOT
)) {
352 int type
= s
->real_device
.io_regions
[index
- 1].type
;
354 if ((type
& XEN_HOST_PCI_REGION_TYPE_MEM
)
355 && (type
& XEN_HOST_PCI_REGION_TYPE_MEM_64
)) {
356 region
= &s
->bases
[index
- 1];
357 if (region
->bar_flag
!= XEN_PT_BAR_FLAG_UPPER
) {
358 return XEN_PT_BAR_FLAG_UPPER
;
363 /* check unused BAR */
364 r
= &d
->io_regions
[index
];
365 if (!xen_pt_get_bar_size(r
)) {
366 return XEN_PT_BAR_FLAG_UNUSED
;
370 if (index
== PCI_ROM_SLOT
) {
371 return XEN_PT_BAR_FLAG_MEM
;
374 /* check BAR I/O indicator */
375 if (s
->real_device
.io_regions
[index
].type
& XEN_HOST_PCI_REGION_TYPE_IO
) {
376 return XEN_PT_BAR_FLAG_IO
;
378 return XEN_PT_BAR_FLAG_MEM
;
382 static inline uint32_t base_address_with_flags(XenHostPCIIORegion
*hr
)
384 if (hr
->type
& XEN_HOST_PCI_REGION_TYPE_IO
) {
385 return hr
->base_addr
| (hr
->bus_flags
& ~PCI_BASE_ADDRESS_IO_MASK
);
387 return hr
->base_addr
| (hr
->bus_flags
& ~PCI_BASE_ADDRESS_MEM_MASK
);
391 static int xen_pt_bar_reg_init(XenPCIPassthroughState
*s
, XenPTRegInfo
*reg
,
392 uint32_t real_offset
, uint32_t *data
)
394 uint32_t reg_field
= 0;
397 index
= xen_pt_bar_offset_to_index(reg
->offset
);
398 if (index
< 0 || index
>= PCI_NUM_REGIONS
) {
399 XEN_PT_ERR(&s
->dev
, "Internal error: Invalid BAR index [%d].\n", index
);
404 s
->bases
[index
].bar_flag
= xen_pt_bar_reg_parse(s
, index
);
405 if (s
->bases
[index
].bar_flag
== XEN_PT_BAR_FLAG_UNUSED
) {
406 reg_field
= XEN_PT_INVALID_REG
;
412 static int xen_pt_bar_reg_read(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
413 uint32_t *value
, uint32_t valid_mask
)
415 XenPTRegInfo
*reg
= cfg_entry
->reg
;
416 uint32_t valid_emu_mask
= 0;
417 uint32_t bar_emu_mask
= 0;
421 index
= xen_pt_bar_offset_to_index(reg
->offset
);
422 if (index
< 0 || index
>= PCI_NUM_REGIONS
- 1) {
423 XEN_PT_ERR(&s
->dev
, "Internal error: Invalid BAR index [%d].\n", index
);
427 /* use fixed-up value from kernel sysfs */
428 *value
= base_address_with_flags(&s
->real_device
.io_regions
[index
]);
430 /* set emulate mask depend on BAR flag */
431 switch (s
->bases
[index
].bar_flag
) {
432 case XEN_PT_BAR_FLAG_MEM
:
433 bar_emu_mask
= XEN_PT_BAR_MEM_EMU_MASK
;
435 case XEN_PT_BAR_FLAG_IO
:
436 bar_emu_mask
= XEN_PT_BAR_IO_EMU_MASK
;
438 case XEN_PT_BAR_FLAG_UPPER
:
439 bar_emu_mask
= XEN_PT_BAR_ALLF
;
446 valid_emu_mask
= bar_emu_mask
& valid_mask
;
447 *value
= XEN_PT_MERGE_VALUE(*value
, cfg_entry
->data
, ~valid_emu_mask
);
451 static int xen_pt_bar_reg_write(XenPCIPassthroughState
*s
, XenPTReg
*cfg_entry
,
452 uint32_t *val
, uint32_t dev_value
,
455 XenPTRegInfo
*reg
= cfg_entry
->reg
;
456 XenPTRegion
*base
= NULL
;
457 PCIDevice
*d
= &s
->dev
;
458 const PCIIORegion
*r
;
459 uint32_t writable_mask
= 0;
460 uint32_t bar_emu_mask
= 0;
461 uint32_t bar_ro_mask
= 0;
465 index
= xen_pt_bar_offset_to_index(reg
->offset
);
466 if (index
< 0 || index
>= PCI_NUM_REGIONS
) {
467 XEN_PT_ERR(d
, "Internal error: Invalid BAR index [%d].\n", index
);
471 r
= &d
->io_regions
[index
];
472 base
= &s
->bases
[index
];
473 r_size
= xen_pt_get_emul_size(base
->bar_flag
, r
->size
);
475 /* set emulate mask and read-only mask values depend on the BAR flag */
476 switch (s
->bases
[index
].bar_flag
) {
477 case XEN_PT_BAR_FLAG_MEM
:
478 bar_emu_mask
= XEN_PT_BAR_MEM_EMU_MASK
;
480 /* low 32 bits mask for 64 bit bars */
481 bar_ro_mask
= XEN_PT_BAR_ALLF
;
483 bar_ro_mask
= XEN_PT_BAR_MEM_RO_MASK
| (r_size
- 1);
486 case XEN_PT_BAR_FLAG_IO
:
487 bar_emu_mask
= XEN_PT_BAR_IO_EMU_MASK
;
488 bar_ro_mask
= XEN_PT_BAR_IO_RO_MASK
| (r_size
- 1);
490 case XEN_PT_BAR_FLAG_UPPER
:
491 bar_emu_mask
= XEN_PT_BAR_ALLF
;
492 bar_ro_mask
= r_size
? r_size
- 1 : 0;
498 /* modify emulate register */
499 writable_mask
= bar_emu_mask
& ~bar_ro_mask
& valid_mask
;
500 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
502 /* check whether we need to update the virtual region address or not */
503 switch (s
->bases
[index
].bar_flag
) {
504 case XEN_PT_BAR_FLAG_UPPER
:
505 case XEN_PT_BAR_FLAG_MEM
:
508 case XEN_PT_BAR_FLAG_IO
:
515 /* create value for writing to I/O device register */
516 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, 0);
521 /* write Exp ROM BAR */
522 static int xen_pt_exp_rom_bar_reg_write(XenPCIPassthroughState
*s
,
523 XenPTReg
*cfg_entry
, uint32_t *val
,
524 uint32_t dev_value
, uint32_t valid_mask
)
526 XenPTRegInfo
*reg
= cfg_entry
->reg
;
527 XenPTRegion
*base
= NULL
;
528 PCIDevice
*d
= (PCIDevice
*)&s
->dev
;
529 uint32_t writable_mask
= 0;
530 uint32_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
532 uint32_t bar_ro_mask
= 0;
534 r_size
= d
->io_regions
[PCI_ROM_SLOT
].size
;
535 base
= &s
->bases
[PCI_ROM_SLOT
];
536 /* align memory type resource size */
537 r_size
= xen_pt_get_emul_size(base
->bar_flag
, r_size
);
539 /* set emulate mask and read-only mask */
540 bar_ro_mask
= (reg
->ro_mask
| (r_size
- 1)) & ~PCI_ROM_ADDRESS_ENABLE
;
542 /* modify emulate register */
543 writable_mask
= ~bar_ro_mask
& valid_mask
;
544 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
546 /* create value for writing to I/O device register */
547 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
552 /* Header Type0 reg static information table */
553 static XenPTRegInfo xen_pt_emu_reg_header0
[] = {
556 .offset
= PCI_VENDOR_ID
,
561 .init
= xen_pt_vendor_reg_init
,
562 .u
.w
.read
= xen_pt_word_reg_read
,
563 .u
.w
.write
= xen_pt_word_reg_write
,
567 .offset
= PCI_DEVICE_ID
,
572 .init
= xen_pt_device_reg_init
,
573 .u
.w
.read
= xen_pt_word_reg_read
,
574 .u
.w
.write
= xen_pt_word_reg_write
,
578 .offset
= PCI_COMMAND
,
583 .init
= xen_pt_common_reg_init
,
584 .u
.w
.read
= xen_pt_word_reg_read
,
585 .u
.w
.write
= xen_pt_cmd_reg_write
,
587 /* Capabilities Pointer reg */
589 .offset
= PCI_CAPABILITY_LIST
,
594 .init
= xen_pt_ptr_reg_init
,
595 .u
.b
.read
= xen_pt_byte_reg_read
,
596 .u
.b
.write
= xen_pt_byte_reg_write
,
599 /* use emulated Cap Ptr value to initialize,
600 * so need to be declared after Cap Ptr reg
603 .offset
= PCI_STATUS
,
608 .init
= xen_pt_status_reg_init
,
609 .u
.w
.read
= xen_pt_word_reg_read
,
610 .u
.w
.write
= xen_pt_word_reg_write
,
612 /* Cache Line Size reg */
614 .offset
= PCI_CACHE_LINE_SIZE
,
619 .init
= xen_pt_common_reg_init
,
620 .u
.b
.read
= xen_pt_byte_reg_read
,
621 .u
.b
.write
= xen_pt_byte_reg_write
,
623 /* Latency Timer reg */
625 .offset
= PCI_LATENCY_TIMER
,
630 .init
= xen_pt_common_reg_init
,
631 .u
.b
.read
= xen_pt_byte_reg_read
,
632 .u
.b
.write
= xen_pt_byte_reg_write
,
634 /* Header Type reg */
636 .offset
= PCI_HEADER_TYPE
,
641 .init
= xen_pt_header_type_reg_init
,
642 .u
.b
.read
= xen_pt_byte_reg_read
,
643 .u
.b
.write
= xen_pt_byte_reg_write
,
645 /* Interrupt Line reg */
647 .offset
= PCI_INTERRUPT_LINE
,
652 .init
= xen_pt_common_reg_init
,
653 .u
.b
.read
= xen_pt_byte_reg_read
,
654 .u
.b
.write
= xen_pt_byte_reg_write
,
656 /* Interrupt Pin reg */
658 .offset
= PCI_INTERRUPT_PIN
,
663 .init
= xen_pt_irqpin_reg_init
,
664 .u
.b
.read
= xen_pt_byte_reg_read
,
665 .u
.b
.write
= xen_pt_byte_reg_write
,
668 /* mask of BAR need to be decided later, depends on IO/MEM type */
670 .offset
= PCI_BASE_ADDRESS_0
,
672 .init_val
= 0x00000000,
673 .init
= xen_pt_bar_reg_init
,
674 .u
.dw
.read
= xen_pt_bar_reg_read
,
675 .u
.dw
.write
= xen_pt_bar_reg_write
,
679 .offset
= PCI_BASE_ADDRESS_1
,
681 .init_val
= 0x00000000,
682 .init
= xen_pt_bar_reg_init
,
683 .u
.dw
.read
= xen_pt_bar_reg_read
,
684 .u
.dw
.write
= xen_pt_bar_reg_write
,
688 .offset
= PCI_BASE_ADDRESS_2
,
690 .init_val
= 0x00000000,
691 .init
= xen_pt_bar_reg_init
,
692 .u
.dw
.read
= xen_pt_bar_reg_read
,
693 .u
.dw
.write
= xen_pt_bar_reg_write
,
697 .offset
= PCI_BASE_ADDRESS_3
,
699 .init_val
= 0x00000000,
700 .init
= xen_pt_bar_reg_init
,
701 .u
.dw
.read
= xen_pt_bar_reg_read
,
702 .u
.dw
.write
= xen_pt_bar_reg_write
,
706 .offset
= PCI_BASE_ADDRESS_4
,
708 .init_val
= 0x00000000,
709 .init
= xen_pt_bar_reg_init
,
710 .u
.dw
.read
= xen_pt_bar_reg_read
,
711 .u
.dw
.write
= xen_pt_bar_reg_write
,
715 .offset
= PCI_BASE_ADDRESS_5
,
717 .init_val
= 0x00000000,
718 .init
= xen_pt_bar_reg_init
,
719 .u
.dw
.read
= xen_pt_bar_reg_read
,
720 .u
.dw
.write
= xen_pt_bar_reg_write
,
722 /* Expansion ROM BAR reg */
724 .offset
= PCI_ROM_ADDRESS
,
726 .init_val
= 0x00000000,
727 .ro_mask
= 0x000007FE,
728 .emu_mask
= 0xFFFFF800,
729 .init
= xen_pt_bar_reg_init
,
730 .u
.dw
.read
= xen_pt_long_reg_read
,
731 .u
.dw
.write
= xen_pt_exp_rom_bar_reg_write
,
739 /*********************************
740 * Vital Product Data Capability
743 /* Vital Product Data Capability Structure reg static information table */
744 static XenPTRegInfo xen_pt_emu_reg_vpd
[] = {
746 .offset
= PCI_CAP_LIST_NEXT
,
751 .init
= xen_pt_ptr_reg_init
,
752 .u
.b
.read
= xen_pt_byte_reg_read
,
753 .u
.b
.write
= xen_pt_byte_reg_write
,
761 /**************************************
762 * Vendor Specific Capability
765 /* Vendor Specific Capability Structure reg static information table */
766 static XenPTRegInfo xen_pt_emu_reg_vendor
[] = {
768 .offset
= PCI_CAP_LIST_NEXT
,
773 .init
= xen_pt_ptr_reg_init
,
774 .u
.b
.read
= xen_pt_byte_reg_read
,
775 .u
.b
.write
= xen_pt_byte_reg_write
,
783 /*****************************
784 * PCI Express Capability
787 static inline uint8_t get_capability_version(XenPCIPassthroughState
*s
,
790 uint8_t flags
= pci_get_byte(s
->dev
.config
+ offset
+ PCI_EXP_FLAGS
);
791 return flags
& PCI_EXP_FLAGS_VERS
;
794 static inline uint8_t get_device_type(XenPCIPassthroughState
*s
,
797 uint8_t flags
= pci_get_byte(s
->dev
.config
+ offset
+ PCI_EXP_FLAGS
);
798 return (flags
& PCI_EXP_FLAGS_TYPE
) >> 4;
801 /* initialize Link Control register */
802 static int xen_pt_linkctrl_reg_init(XenPCIPassthroughState
*s
,
803 XenPTRegInfo
*reg
, uint32_t real_offset
,
806 uint8_t cap_ver
= get_capability_version(s
, real_offset
- reg
->offset
);
807 uint8_t dev_type
= get_device_type(s
, real_offset
- reg
->offset
);
809 /* no need to initialize in case of Root Complex Integrated Endpoint
812 if ((dev_type
== PCI_EXP_TYPE_RC_END
) && (cap_ver
== 1)) {
813 *data
= XEN_PT_INVALID_REG
;
816 *data
= reg
->init_val
;
819 /* initialize Device Control 2 register */
820 static int xen_pt_devctrl2_reg_init(XenPCIPassthroughState
*s
,
821 XenPTRegInfo
*reg
, uint32_t real_offset
,
824 uint8_t cap_ver
= get_capability_version(s
, real_offset
- reg
->offset
);
826 /* no need to initialize in case of cap_ver 1.x */
828 *data
= XEN_PT_INVALID_REG
;
831 *data
= reg
->init_val
;
834 /* initialize Link Control 2 register */
835 static int xen_pt_linkctrl2_reg_init(XenPCIPassthroughState
*s
,
836 XenPTRegInfo
*reg
, uint32_t real_offset
,
839 uint8_t cap_ver
= get_capability_version(s
, real_offset
- reg
->offset
);
840 uint32_t reg_field
= 0;
842 /* no need to initialize in case of cap_ver 1.x */
844 reg_field
= XEN_PT_INVALID_REG
;
846 /* set Supported Link Speed */
847 uint8_t lnkcap
= pci_get_byte(s
->dev
.config
+ real_offset
- reg
->offset
849 reg_field
|= PCI_EXP_LNKCAP_SLS
& lnkcap
;
856 /* PCI Express Capability Structure reg static information table */
857 static XenPTRegInfo xen_pt_emu_reg_pcie
[] = {
858 /* Next Pointer reg */
860 .offset
= PCI_CAP_LIST_NEXT
,
865 .init
= xen_pt_ptr_reg_init
,
866 .u
.b
.read
= xen_pt_byte_reg_read
,
867 .u
.b
.write
= xen_pt_byte_reg_write
,
869 /* Device Capabilities reg */
871 .offset
= PCI_EXP_DEVCAP
,
873 .init_val
= 0x00000000,
874 .ro_mask
= 0xFFFFFFFF,
875 .emu_mask
= 0x10000000,
876 .init
= xen_pt_common_reg_init
,
877 .u
.dw
.read
= xen_pt_long_reg_read
,
878 .u
.dw
.write
= xen_pt_long_reg_write
,
880 /* Device Control reg */
882 .offset
= PCI_EXP_DEVCTL
,
887 .init
= xen_pt_common_reg_init
,
888 .u
.w
.read
= xen_pt_word_reg_read
,
889 .u
.w
.write
= xen_pt_word_reg_write
,
891 /* Link Control reg */
893 .offset
= PCI_EXP_LNKCTL
,
898 .init
= xen_pt_linkctrl_reg_init
,
899 .u
.w
.read
= xen_pt_word_reg_read
,
900 .u
.w
.write
= xen_pt_word_reg_write
,
902 /* Device Control 2 reg */
909 .init
= xen_pt_devctrl2_reg_init
,
910 .u
.w
.read
= xen_pt_word_reg_read
,
911 .u
.w
.write
= xen_pt_word_reg_write
,
913 /* Link Control 2 reg */
920 .init
= xen_pt_linkctrl2_reg_init
,
921 .u
.w
.read
= xen_pt_word_reg_read
,
922 .u
.w
.write
= xen_pt_word_reg_write
,
930 /*********************************
931 * Power Management Capability
934 /* write Power Management Control/Status register */
935 static int xen_pt_pmcsr_reg_write(XenPCIPassthroughState
*s
,
936 XenPTReg
*cfg_entry
, uint16_t *val
,
937 uint16_t dev_value
, uint16_t valid_mask
)
939 XenPTRegInfo
*reg
= cfg_entry
->reg
;
940 uint16_t writable_mask
= 0;
941 uint16_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
943 /* modify emulate register */
944 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
945 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
947 /* create value for writing to I/O device register */
948 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
& ~PCI_PM_CTRL_PME_STATUS
,
954 /* Power Management Capability reg static information table */
955 static XenPTRegInfo xen_pt_emu_reg_pm
[] = {
956 /* Next Pointer reg */
958 .offset
= PCI_CAP_LIST_NEXT
,
963 .init
= xen_pt_ptr_reg_init
,
964 .u
.b
.read
= xen_pt_byte_reg_read
,
965 .u
.b
.write
= xen_pt_byte_reg_write
,
967 /* Power Management Capabilities reg */
969 .offset
= PCI_CAP_FLAGS
,
974 .init
= xen_pt_common_reg_init
,
975 .u
.w
.read
= xen_pt_word_reg_read
,
976 .u
.w
.write
= xen_pt_word_reg_write
,
978 /* PCI Power Management Control/Status reg */
980 .offset
= PCI_PM_CTRL
,
985 .init
= xen_pt_common_reg_init
,
986 .u
.w
.read
= xen_pt_word_reg_read
,
987 .u
.w
.write
= xen_pt_pmcsr_reg_write
,
995 /********************************
1000 #define xen_pt_msi_check_type(offset, flags, what) \
1001 ((offset) == ((flags) & PCI_MSI_FLAGS_64BIT ? \
1002 PCI_MSI_##what##_64 : PCI_MSI_##what##_32))
1004 /* Message Control register */
1005 static int xen_pt_msgctrl_reg_init(XenPCIPassthroughState
*s
,
1006 XenPTRegInfo
*reg
, uint32_t real_offset
,
1009 PCIDevice
*d
= &s
->dev
;
1010 XenPTMSI
*msi
= s
->msi
;
1011 uint16_t reg_field
= 0;
1013 /* use I/O device register's value as initial value */
1014 reg_field
= pci_get_word(d
->config
+ real_offset
);
1016 if (reg_field
& PCI_MSI_FLAGS_ENABLE
) {
1017 XEN_PT_LOG(&s
->dev
, "MSI already enabled, disabling it first\n");
1018 xen_host_pci_set_word(&s
->real_device
, real_offset
,
1019 reg_field
& ~PCI_MSI_FLAGS_ENABLE
);
1021 msi
->flags
|= reg_field
;
1022 msi
->ctrl_offset
= real_offset
;
1023 msi
->initialized
= false;
1024 msi
->mapped
= false;
1026 *data
= reg
->init_val
;
1029 static int xen_pt_msgctrl_reg_write(XenPCIPassthroughState
*s
,
1030 XenPTReg
*cfg_entry
, uint16_t *val
,
1031 uint16_t dev_value
, uint16_t valid_mask
)
1033 XenPTRegInfo
*reg
= cfg_entry
->reg
;
1034 XenPTMSI
*msi
= s
->msi
;
1035 uint16_t writable_mask
= 0;
1036 uint16_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
1038 /* Currently no support for multi-vector */
1039 if (*val
& PCI_MSI_FLAGS_QSIZE
) {
1040 XEN_PT_WARN(&s
->dev
, "Tries to set more than 1 vector ctrl %x\n", *val
);
1043 /* modify emulate register */
1044 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
1045 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
1046 msi
->flags
|= cfg_entry
->data
& ~PCI_MSI_FLAGS_ENABLE
;
1048 /* create value for writing to I/O device register */
1049 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
1052 if (*val
& PCI_MSI_FLAGS_ENABLE
) {
1053 /* setup MSI pirq for the first time */
1054 if (!msi
->initialized
) {
1055 /* Init physical one */
1056 XEN_PT_LOG(&s
->dev
, "setup MSI\n");
1057 if (xen_pt_msi_setup(s
)) {
1058 /* We do not broadcast the error to the framework code, so
1059 * that MSI errors are contained in MSI emulation code and
1060 * QEMU can go on running.
1061 * Guest MSI would be actually not working.
1063 *val
&= ~PCI_MSI_FLAGS_ENABLE
;
1064 XEN_PT_WARN(&s
->dev
, "Can not map MSI.\n");
1067 if (xen_pt_msi_update(s
)) {
1068 *val
&= ~PCI_MSI_FLAGS_ENABLE
;
1069 XEN_PT_WARN(&s
->dev
, "Can not bind MSI\n");
1072 msi
->initialized
= true;
1075 msi
->flags
|= PCI_MSI_FLAGS_ENABLE
;
1076 } else if (msi
->mapped
) {
1077 xen_pt_msi_disable(s
);
1083 /* initialize Message Upper Address register */
1084 static int xen_pt_msgaddr64_reg_init(XenPCIPassthroughState
*s
,
1085 XenPTRegInfo
*reg
, uint32_t real_offset
,
1088 /* no need to initialize in case of 32 bit type */
1089 if (!(s
->msi
->flags
& PCI_MSI_FLAGS_64BIT
)) {
1090 *data
= XEN_PT_INVALID_REG
;
1092 *data
= reg
->init_val
;
1097 /* this function will be called twice (for 32 bit and 64 bit type) */
1098 /* initialize Message Data register */
1099 static int xen_pt_msgdata_reg_init(XenPCIPassthroughState
*s
,
1100 XenPTRegInfo
*reg
, uint32_t real_offset
,
1103 uint32_t flags
= s
->msi
->flags
;
1104 uint32_t offset
= reg
->offset
;
1106 /* check the offset whether matches the type or not */
1107 if (xen_pt_msi_check_type(offset
, flags
, DATA
)) {
1108 *data
= reg
->init_val
;
1110 *data
= XEN_PT_INVALID_REG
;
1115 /* this function will be called twice (for 32 bit and 64 bit type) */
1116 /* initialize Mask register */
1117 static int xen_pt_mask_reg_init(XenPCIPassthroughState
*s
,
1118 XenPTRegInfo
*reg
, uint32_t real_offset
,
1121 uint32_t flags
= s
->msi
->flags
;
1123 /* check the offset whether matches the type or not */
1124 if (!(flags
& PCI_MSI_FLAGS_MASKBIT
)) {
1125 *data
= XEN_PT_INVALID_REG
;
1126 } else if (xen_pt_msi_check_type(reg
->offset
, flags
, MASK
)) {
1127 *data
= reg
->init_val
;
1129 *data
= XEN_PT_INVALID_REG
;
1134 /* this function will be called twice (for 32 bit and 64 bit type) */
1135 /* initialize Pending register */
1136 static int xen_pt_pending_reg_init(XenPCIPassthroughState
*s
,
1137 XenPTRegInfo
*reg
, uint32_t real_offset
,
1140 uint32_t flags
= s
->msi
->flags
;
1142 /* check the offset whether matches the type or not */
1143 if (!(flags
& PCI_MSI_FLAGS_MASKBIT
)) {
1144 *data
= XEN_PT_INVALID_REG
;
1145 } else if (xen_pt_msi_check_type(reg
->offset
, flags
, PENDING
)) {
1146 *data
= reg
->init_val
;
1148 *data
= XEN_PT_INVALID_REG
;
1153 /* write Message Address register */
1154 static int xen_pt_msgaddr32_reg_write(XenPCIPassthroughState
*s
,
1155 XenPTReg
*cfg_entry
, uint32_t *val
,
1156 uint32_t dev_value
, uint32_t valid_mask
)
1158 XenPTRegInfo
*reg
= cfg_entry
->reg
;
1159 uint32_t writable_mask
= 0;
1160 uint32_t old_addr
= cfg_entry
->data
;
1162 /* modify emulate register */
1163 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
1164 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
1165 s
->msi
->addr_lo
= cfg_entry
->data
;
1167 /* create value for writing to I/O device register */
1168 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, 0);
1171 if (cfg_entry
->data
!= old_addr
) {
1172 if (s
->msi
->mapped
) {
1173 xen_pt_msi_update(s
);
1179 /* write Message Upper Address register */
1180 static int xen_pt_msgaddr64_reg_write(XenPCIPassthroughState
*s
,
1181 XenPTReg
*cfg_entry
, uint32_t *val
,
1182 uint32_t dev_value
, uint32_t valid_mask
)
1184 XenPTRegInfo
*reg
= cfg_entry
->reg
;
1185 uint32_t writable_mask
= 0;
1186 uint32_t old_addr
= cfg_entry
->data
;
1188 /* check whether the type is 64 bit or not */
1189 if (!(s
->msi
->flags
& PCI_MSI_FLAGS_64BIT
)) {
1191 "Can't write to the upper address without 64 bit support\n");
1195 /* modify emulate register */
1196 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
1197 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
1198 /* update the msi_info too */
1199 s
->msi
->addr_hi
= cfg_entry
->data
;
1201 /* create value for writing to I/O device register */
1202 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, 0);
1205 if (cfg_entry
->data
!= old_addr
) {
1206 if (s
->msi
->mapped
) {
1207 xen_pt_msi_update(s
);
1215 /* this function will be called twice (for 32 bit and 64 bit type) */
1216 /* write Message Data register */
1217 static int xen_pt_msgdata_reg_write(XenPCIPassthroughState
*s
,
1218 XenPTReg
*cfg_entry
, uint16_t *val
,
1219 uint16_t dev_value
, uint16_t valid_mask
)
1221 XenPTRegInfo
*reg
= cfg_entry
->reg
;
1222 XenPTMSI
*msi
= s
->msi
;
1223 uint16_t writable_mask
= 0;
1224 uint16_t old_data
= cfg_entry
->data
;
1225 uint32_t offset
= reg
->offset
;
1227 /* check the offset whether matches the type or not */
1228 if (!xen_pt_msi_check_type(offset
, msi
->flags
, DATA
)) {
1229 /* exit I/O emulator */
1230 XEN_PT_ERR(&s
->dev
, "the offset does not match the 32/64 bit type!\n");
1234 /* modify emulate register */
1235 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
1236 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
1237 /* update the msi_info too */
1238 msi
->data
= cfg_entry
->data
;
1240 /* create value for writing to I/O device register */
1241 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, 0);
1244 if (cfg_entry
->data
!= old_data
) {
1246 xen_pt_msi_update(s
);
1253 /* MSI Capability Structure reg static information table */
1254 static XenPTRegInfo xen_pt_emu_reg_msi
[] = {
1255 /* Next Pointer reg */
1257 .offset
= PCI_CAP_LIST_NEXT
,
1262 .init
= xen_pt_ptr_reg_init
,
1263 .u
.b
.read
= xen_pt_byte_reg_read
,
1264 .u
.b
.write
= xen_pt_byte_reg_write
,
1266 /* Message Control reg */
1268 .offset
= PCI_MSI_FLAGS
,
1273 .init
= xen_pt_msgctrl_reg_init
,
1274 .u
.w
.read
= xen_pt_word_reg_read
,
1275 .u
.w
.write
= xen_pt_msgctrl_reg_write
,
1277 /* Message Address reg */
1279 .offset
= PCI_MSI_ADDRESS_LO
,
1281 .init_val
= 0x00000000,
1282 .ro_mask
= 0x00000003,
1283 .emu_mask
= 0xFFFFFFFF,
1284 .init
= xen_pt_common_reg_init
,
1285 .u
.dw
.read
= xen_pt_long_reg_read
,
1286 .u
.dw
.write
= xen_pt_msgaddr32_reg_write
,
1288 /* Message Upper Address reg (if PCI_MSI_FLAGS_64BIT set) */
1290 .offset
= PCI_MSI_ADDRESS_HI
,
1292 .init_val
= 0x00000000,
1293 .ro_mask
= 0x00000000,
1294 .emu_mask
= 0xFFFFFFFF,
1295 .init
= xen_pt_msgaddr64_reg_init
,
1296 .u
.dw
.read
= xen_pt_long_reg_read
,
1297 .u
.dw
.write
= xen_pt_msgaddr64_reg_write
,
1299 /* Message Data reg (16 bits of data for 32-bit devices) */
1301 .offset
= PCI_MSI_DATA_32
,
1306 .init
= xen_pt_msgdata_reg_init
,
1307 .u
.w
.read
= xen_pt_word_reg_read
,
1308 .u
.w
.write
= xen_pt_msgdata_reg_write
,
1310 /* Message Data reg (16 bits of data for 64-bit devices) */
1312 .offset
= PCI_MSI_DATA_64
,
1317 .init
= xen_pt_msgdata_reg_init
,
1318 .u
.w
.read
= xen_pt_word_reg_read
,
1319 .u
.w
.write
= xen_pt_msgdata_reg_write
,
1321 /* Mask reg (if PCI_MSI_FLAGS_MASKBIT set, for 32-bit devices) */
1323 .offset
= PCI_MSI_MASK_32
,
1325 .init_val
= 0x00000000,
1326 .ro_mask
= 0xFFFFFFFF,
1327 .emu_mask
= 0xFFFFFFFF,
1328 .init
= xen_pt_mask_reg_init
,
1329 .u
.dw
.read
= xen_pt_long_reg_read
,
1330 .u
.dw
.write
= xen_pt_long_reg_write
,
1332 /* Mask reg (if PCI_MSI_FLAGS_MASKBIT set, for 64-bit devices) */
1334 .offset
= PCI_MSI_MASK_64
,
1336 .init_val
= 0x00000000,
1337 .ro_mask
= 0xFFFFFFFF,
1338 .emu_mask
= 0xFFFFFFFF,
1339 .init
= xen_pt_mask_reg_init
,
1340 .u
.dw
.read
= xen_pt_long_reg_read
,
1341 .u
.dw
.write
= xen_pt_long_reg_write
,
1343 /* Pending reg (if PCI_MSI_FLAGS_MASKBIT set, for 32-bit devices) */
1345 .offset
= PCI_MSI_MASK_32
+ 4,
1347 .init_val
= 0x00000000,
1348 .ro_mask
= 0xFFFFFFFF,
1349 .emu_mask
= 0x00000000,
1350 .init
= xen_pt_pending_reg_init
,
1351 .u
.dw
.read
= xen_pt_long_reg_read
,
1352 .u
.dw
.write
= xen_pt_long_reg_write
,
1354 /* Pending reg (if PCI_MSI_FLAGS_MASKBIT set, for 64-bit devices) */
1356 .offset
= PCI_MSI_MASK_64
+ 4,
1358 .init_val
= 0x00000000,
1359 .ro_mask
= 0xFFFFFFFF,
1360 .emu_mask
= 0x00000000,
1361 .init
= xen_pt_pending_reg_init
,
1362 .u
.dw
.read
= xen_pt_long_reg_read
,
1363 .u
.dw
.write
= xen_pt_long_reg_write
,
1371 /**************************************
1375 /* Message Control register for MSI-X */
1376 static int xen_pt_msixctrl_reg_init(XenPCIPassthroughState
*s
,
1377 XenPTRegInfo
*reg
, uint32_t real_offset
,
1380 PCIDevice
*d
= &s
->dev
;
1381 uint16_t reg_field
= 0;
1383 /* use I/O device register's value as initial value */
1384 reg_field
= pci_get_word(d
->config
+ real_offset
);
1386 if (reg_field
& PCI_MSIX_FLAGS_ENABLE
) {
1387 XEN_PT_LOG(d
, "MSIX already enabled, disabling it first\n");
1388 xen_host_pci_set_word(&s
->real_device
, real_offset
,
1389 reg_field
& ~PCI_MSIX_FLAGS_ENABLE
);
1392 s
->msix
->ctrl_offset
= real_offset
;
1394 *data
= reg
->init_val
;
1397 static int xen_pt_msixctrl_reg_write(XenPCIPassthroughState
*s
,
1398 XenPTReg
*cfg_entry
, uint16_t *val
,
1399 uint16_t dev_value
, uint16_t valid_mask
)
1401 XenPTRegInfo
*reg
= cfg_entry
->reg
;
1402 uint16_t writable_mask
= 0;
1403 uint16_t throughable_mask
= get_throughable_mask(s
, reg
, valid_mask
);
1404 int debug_msix_enabled_old
;
1406 /* modify emulate register */
1407 writable_mask
= reg
->emu_mask
& ~reg
->ro_mask
& valid_mask
;
1408 cfg_entry
->data
= XEN_PT_MERGE_VALUE(*val
, cfg_entry
->data
, writable_mask
);
1410 /* create value for writing to I/O device register */
1411 *val
= XEN_PT_MERGE_VALUE(*val
, dev_value
, throughable_mask
);
1414 if ((*val
& PCI_MSIX_FLAGS_ENABLE
)
1415 && !(*val
& PCI_MSIX_FLAGS_MASKALL
)) {
1416 xen_pt_msix_update(s
);
1417 } else if (!(*val
& PCI_MSIX_FLAGS_ENABLE
) && s
->msix
->enabled
) {
1418 xen_pt_msix_disable(s
);
1421 debug_msix_enabled_old
= s
->msix
->enabled
;
1422 s
->msix
->enabled
= !!(*val
& PCI_MSIX_FLAGS_ENABLE
);
1423 if (s
->msix
->enabled
!= debug_msix_enabled_old
) {
1424 XEN_PT_LOG(&s
->dev
, "%s MSI-X\n",
1425 s
->msix
->enabled
? "enable" : "disable");
1431 /* MSI-X Capability Structure reg static information table */
1432 static XenPTRegInfo xen_pt_emu_reg_msix
[] = {
1433 /* Next Pointer reg */
1435 .offset
= PCI_CAP_LIST_NEXT
,
1440 .init
= xen_pt_ptr_reg_init
,
1441 .u
.b
.read
= xen_pt_byte_reg_read
,
1442 .u
.b
.write
= xen_pt_byte_reg_write
,
1444 /* Message Control reg */
1446 .offset
= PCI_MSI_FLAGS
,
1451 .init
= xen_pt_msixctrl_reg_init
,
1452 .u
.w
.read
= xen_pt_word_reg_read
,
1453 .u
.w
.write
= xen_pt_msixctrl_reg_write
,
1461 /****************************
1465 /* capability structure register group size functions */
1467 static int xen_pt_reg_grp_size_init(XenPCIPassthroughState
*s
,
1468 const XenPTRegGroupInfo
*grp_reg
,
1469 uint32_t base_offset
, uint8_t *size
)
1471 *size
= grp_reg
->grp_size
;
1474 /* get Vendor Specific Capability Structure register group size */
1475 static int xen_pt_vendor_size_init(XenPCIPassthroughState
*s
,
1476 const XenPTRegGroupInfo
*grp_reg
,
1477 uint32_t base_offset
, uint8_t *size
)
1479 *size
= pci_get_byte(s
->dev
.config
+ base_offset
+ 0x02);
1482 /* get PCI Express Capability Structure register group size */
1483 static int xen_pt_pcie_size_init(XenPCIPassthroughState
*s
,
1484 const XenPTRegGroupInfo
*grp_reg
,
1485 uint32_t base_offset
, uint8_t *size
)
1487 PCIDevice
*d
= &s
->dev
;
1488 uint8_t version
= get_capability_version(s
, base_offset
);
1489 uint8_t type
= get_device_type(s
, base_offset
);
1490 uint8_t pcie_size
= 0;
1493 /* calculate size depend on capability version and device/port type */
1494 /* in case of PCI Express Base Specification Rev 1.x */
1496 /* The PCI Express Capabilities, Device Capabilities, and Device
1497 * Status/Control registers are required for all PCI Express devices.
1498 * The Link Capabilities and Link Status/Control are required for all
1499 * Endpoints that are not Root Complex Integrated Endpoints. Endpoints
1500 * are not required to implement registers other than those listed
1501 * above and terminate the capability structure.
1504 case PCI_EXP_TYPE_ENDPOINT
:
1505 case PCI_EXP_TYPE_LEG_END
:
1508 case PCI_EXP_TYPE_RC_END
:
1512 /* only EndPoint passthrough is supported */
1513 case PCI_EXP_TYPE_ROOT_PORT
:
1514 case PCI_EXP_TYPE_UPSTREAM
:
1515 case PCI_EXP_TYPE_DOWNSTREAM
:
1516 case PCI_EXP_TYPE_PCI_BRIDGE
:
1517 case PCI_EXP_TYPE_PCIE_BRIDGE
:
1518 case PCI_EXP_TYPE_RC_EC
:
1520 XEN_PT_ERR(d
, "Unsupported device/port type %#x.\n", type
);
1524 /* in case of PCI Express Base Specification Rev 2.0 */
1525 else if (version
== 2) {
1527 case PCI_EXP_TYPE_ENDPOINT
:
1528 case PCI_EXP_TYPE_LEG_END
:
1529 case PCI_EXP_TYPE_RC_END
:
1530 /* For Functions that do not implement the registers,
1531 * these spaces must be hardwired to 0b.
1535 /* only EndPoint passthrough is supported */
1536 case PCI_EXP_TYPE_ROOT_PORT
:
1537 case PCI_EXP_TYPE_UPSTREAM
:
1538 case PCI_EXP_TYPE_DOWNSTREAM
:
1539 case PCI_EXP_TYPE_PCI_BRIDGE
:
1540 case PCI_EXP_TYPE_PCIE_BRIDGE
:
1541 case PCI_EXP_TYPE_RC_EC
:
1543 XEN_PT_ERR(d
, "Unsupported device/port type %#x.\n", type
);
1547 XEN_PT_ERR(d
, "Unsupported capability version %#x.\n", version
);
1554 /* get MSI Capability Structure register group size */
1555 static int xen_pt_msi_size_init(XenPCIPassthroughState
*s
,
1556 const XenPTRegGroupInfo
*grp_reg
,
1557 uint32_t base_offset
, uint8_t *size
)
1559 PCIDevice
*d
= &s
->dev
;
1560 uint16_t msg_ctrl
= 0;
1561 uint8_t msi_size
= 0xa;
1563 msg_ctrl
= pci_get_word(d
->config
+ (base_offset
+ PCI_MSI_FLAGS
));
1565 /* check if 64-bit address is capable of per-vector masking */
1566 if (msg_ctrl
& PCI_MSI_FLAGS_64BIT
) {
1569 if (msg_ctrl
& PCI_MSI_FLAGS_MASKBIT
) {
1573 s
->msi
= g_new0(XenPTMSI
, 1);
1574 s
->msi
->pirq
= XEN_PT_UNASSIGNED_PIRQ
;
1579 /* get MSI-X Capability Structure register group size */
1580 static int xen_pt_msix_size_init(XenPCIPassthroughState
*s
,
1581 const XenPTRegGroupInfo
*grp_reg
,
1582 uint32_t base_offset
, uint8_t *size
)
1586 rc
= xen_pt_msix_init(s
, base_offset
);
1589 XEN_PT_ERR(&s
->dev
, "Internal error: Invalid xen_pt_msix_init.\n");
1593 *size
= grp_reg
->grp_size
;
1598 static const XenPTRegGroupInfo xen_pt_emu_reg_grps
[] = {
1599 /* Header Type0 reg group */
1602 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1604 .size_init
= xen_pt_reg_grp_size_init
,
1605 .emu_regs
= xen_pt_emu_reg_header0
,
1607 /* PCI PowerManagement Capability reg group */
1609 .grp_id
= PCI_CAP_ID_PM
,
1610 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1611 .grp_size
= PCI_PM_SIZEOF
,
1612 .size_init
= xen_pt_reg_grp_size_init
,
1613 .emu_regs
= xen_pt_emu_reg_pm
,
1615 /* AGP Capability Structure reg group */
1617 .grp_id
= PCI_CAP_ID_AGP
,
1618 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1620 .size_init
= xen_pt_reg_grp_size_init
,
1622 /* Vital Product Data Capability Structure reg group */
1624 .grp_id
= PCI_CAP_ID_VPD
,
1625 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1627 .size_init
= xen_pt_reg_grp_size_init
,
1628 .emu_regs
= xen_pt_emu_reg_vpd
,
1630 /* Slot Identification reg group */
1632 .grp_id
= PCI_CAP_ID_SLOTID
,
1633 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1635 .size_init
= xen_pt_reg_grp_size_init
,
1637 /* MSI Capability Structure reg group */
1639 .grp_id
= PCI_CAP_ID_MSI
,
1640 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1642 .size_init
= xen_pt_msi_size_init
,
1643 .emu_regs
= xen_pt_emu_reg_msi
,
1645 /* PCI-X Capabilities List Item reg group */
1647 .grp_id
= PCI_CAP_ID_PCIX
,
1648 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1650 .size_init
= xen_pt_reg_grp_size_init
,
1652 /* Vendor Specific Capability Structure reg group */
1654 .grp_id
= PCI_CAP_ID_VNDR
,
1655 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1657 .size_init
= xen_pt_vendor_size_init
,
1658 .emu_regs
= xen_pt_emu_reg_vendor
,
1660 /* SHPC Capability List Item reg group */
1662 .grp_id
= PCI_CAP_ID_SHPC
,
1663 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1665 .size_init
= xen_pt_reg_grp_size_init
,
1667 /* Subsystem ID and Subsystem Vendor ID Capability List Item reg group */
1669 .grp_id
= PCI_CAP_ID_SSVID
,
1670 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1672 .size_init
= xen_pt_reg_grp_size_init
,
1674 /* AGP 8x Capability Structure reg group */
1676 .grp_id
= PCI_CAP_ID_AGP3
,
1677 .grp_type
= XEN_PT_GRP_TYPE_HARDWIRED
,
1679 .size_init
= xen_pt_reg_grp_size_init
,
1681 /* PCI Express Capability Structure reg group */
1683 .grp_id
= PCI_CAP_ID_EXP
,
1684 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1686 .size_init
= xen_pt_pcie_size_init
,
1687 .emu_regs
= xen_pt_emu_reg_pcie
,
1689 /* MSI-X Capability Structure reg group */
1691 .grp_id
= PCI_CAP_ID_MSIX
,
1692 .grp_type
= XEN_PT_GRP_TYPE_EMU
,
1694 .size_init
= xen_pt_msix_size_init
,
1695 .emu_regs
= xen_pt_emu_reg_msix
,
1702 /* initialize Capabilities Pointer or Next Pointer register */
1703 static int xen_pt_ptr_reg_init(XenPCIPassthroughState
*s
,
1704 XenPTRegInfo
*reg
, uint32_t real_offset
,
1708 uint8_t *config
= s
->dev
.config
;
1709 uint32_t reg_field
= pci_get_byte(config
+ real_offset
);
1712 /* find capability offset */
1714 for (i
= 0; xen_pt_emu_reg_grps
[i
].grp_size
!= 0; i
++) {
1715 if (xen_pt_hide_dev_cap(&s
->real_device
,
1716 xen_pt_emu_reg_grps
[i
].grp_id
)) {
1720 cap_id
= pci_get_byte(config
+ reg_field
+ PCI_CAP_LIST_ID
);
1721 if (xen_pt_emu_reg_grps
[i
].grp_id
== cap_id
) {
1722 if (xen_pt_emu_reg_grps
[i
].grp_type
== XEN_PT_GRP_TYPE_EMU
) {
1725 /* ignore the 0 hardwired capability, find next one */
1730 /* next capability */
1731 reg_field
= pci_get_byte(config
+ reg_field
+ PCI_CAP_LIST_NEXT
);
1744 static uint8_t find_cap_offset(XenPCIPassthroughState
*s
, uint8_t cap
)
1747 unsigned max_cap
= PCI_CAP_MAX
;
1748 uint8_t pos
= PCI_CAPABILITY_LIST
;
1751 if (xen_host_pci_get_byte(&s
->real_device
, PCI_STATUS
, &status
)) {
1754 if ((status
& PCI_STATUS_CAP_LIST
) == 0) {
1759 if (xen_host_pci_get_byte(&s
->real_device
, pos
, &pos
)) {
1762 if (pos
< PCI_CONFIG_HEADER_SIZE
) {
1767 if (xen_host_pci_get_byte(&s
->real_device
,
1768 pos
+ PCI_CAP_LIST_ID
, &id
)) {
1779 pos
+= PCI_CAP_LIST_NEXT
;
1784 static int xen_pt_config_reg_init(XenPCIPassthroughState
*s
,
1785 XenPTRegGroup
*reg_grp
, XenPTRegInfo
*reg
)
1787 XenPTReg
*reg_entry
;
1791 reg_entry
= g_new0(XenPTReg
, 1);
1792 reg_entry
->reg
= reg
;
1795 /* initialize emulate register */
1796 rc
= reg
->init(s
, reg_entry
->reg
,
1797 reg_grp
->base_offset
+ reg
->offset
, &data
);
1802 if (data
== XEN_PT_INVALID_REG
) {
1803 /* free unused BAR register entry */
1807 /* set register value */
1808 reg_entry
->data
= data
;
1810 /* list add register entry */
1811 QLIST_INSERT_HEAD(®_grp
->reg_tbl_list
, reg_entry
, entries
);
1816 int xen_pt_config_init(XenPCIPassthroughState
*s
)
1820 QLIST_INIT(&s
->reg_grps
);
1822 for (i
= 0; xen_pt_emu_reg_grps
[i
].grp_size
!= 0; i
++) {
1823 uint32_t reg_grp_offset
= 0;
1824 XenPTRegGroup
*reg_grp_entry
= NULL
;
1826 if (xen_pt_emu_reg_grps
[i
].grp_id
!= 0xFF) {
1827 if (xen_pt_hide_dev_cap(&s
->real_device
,
1828 xen_pt_emu_reg_grps
[i
].grp_id
)) {
1832 reg_grp_offset
= find_cap_offset(s
, xen_pt_emu_reg_grps
[i
].grp_id
);
1834 if (!reg_grp_offset
) {
1839 reg_grp_entry
= g_new0(XenPTRegGroup
, 1);
1840 QLIST_INIT(®_grp_entry
->reg_tbl_list
);
1841 QLIST_INSERT_HEAD(&s
->reg_grps
, reg_grp_entry
, entries
);
1843 reg_grp_entry
->base_offset
= reg_grp_offset
;
1844 reg_grp_entry
->reg_grp
= xen_pt_emu_reg_grps
+ i
;
1845 if (xen_pt_emu_reg_grps
[i
].size_init
) {
1846 /* get register group size */
1847 rc
= xen_pt_emu_reg_grps
[i
].size_init(s
, reg_grp_entry
->reg_grp
,
1849 ®_grp_entry
->size
);
1851 xen_pt_config_delete(s
);
1856 if (xen_pt_emu_reg_grps
[i
].grp_type
== XEN_PT_GRP_TYPE_EMU
) {
1857 if (xen_pt_emu_reg_grps
[i
].emu_regs
) {
1859 XenPTRegInfo
*regs
= xen_pt_emu_reg_grps
[i
].emu_regs
;
1860 /* initialize capability register */
1861 for (j
= 0; regs
->size
!= 0; j
++, regs
++) {
1862 /* initialize capability register */
1863 rc
= xen_pt_config_reg_init(s
, reg_grp_entry
, regs
);
1865 xen_pt_config_delete(s
);
1876 /* delete all emulate register */
1877 void xen_pt_config_delete(XenPCIPassthroughState
*s
)
1879 struct XenPTRegGroup
*reg_group
, *next_grp
;
1880 struct XenPTReg
*reg
, *next_reg
;
1882 /* free MSI/MSI-X info table */
1884 xen_pt_msix_delete(s
);
1890 /* free all register group entry */
1891 QLIST_FOREACH_SAFE(reg_group
, &s
->reg_grps
, entries
, next_grp
) {
1892 /* free all register entry */
1893 QLIST_FOREACH_SAFE(reg
, ®_group
->reg_tbl_list
, entries
, next_reg
) {
1894 QLIST_REMOVE(reg
, entries
);
1898 QLIST_REMOVE(reg_group
, entries
);