]> git.proxmox.com Git - mirror_qemu.git/blob - hw/xen_pt_config_init.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'mdroth/qga-pull-6-21-12' into staging
[mirror_qemu.git] / hw / xen_pt_config_init.c
1 /*
2 * Copyright (c) 2007, Neocleus Corporation.
3 * Copyright (c) 2007, Intel Corporation.
4 *
5 * This work is licensed under the terms of the GNU GPL, version 2. See
6 * the COPYING file in the top-level directory.
7 *
8 * Alex Novik <alex@neocleus.com>
9 * Allen Kay <allen.m.kay@intel.com>
10 * Guy Zana <guy@neocleus.com>
11 *
12 * This file implements direct PCI assignment to a HVM guest
13 */
14
15 #include "qemu-timer.h"
16 #include "xen_backend.h"
17 #include "xen_pt.h"
18
19 #define XEN_PT_MERGE_VALUE(value, data, val_mask) \
20 (((value) & (val_mask)) | ((data) & ~(val_mask)))
21
22 #define XEN_PT_INVALID_REG 0xFFFFFFFF /* invalid register value */
23
24 /* prototype */
25
26 static int xen_pt_ptr_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg,
27 uint32_t real_offset, uint32_t *data);
28
29
30 /* helper */
31
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)
34 {
35 switch (grp_id) {
36 case PCI_CAP_ID_EXP:
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.
40 *
41 * The datasheet is available at
42 * http://download.intel.com/design/network/datashts/82599_datasheet.pdf
43 *
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.
49 */
50 if (d->vendor_id == PCI_VENDOR_ID_INTEL &&
51 d->device_id == PCI_DEVICE_ID_INTEL_82599_SFP_VF) {
52 return 1;
53 }
54 break;
55 }
56 return 0;
57 }
58
59 /* find emulate register group entry */
60 XenPTRegGroup *xen_pt_find_reg_grp(XenPCIPassthroughState *s, uint32_t address)
61 {
62 XenPTRegGroup *entry = NULL;
63
64 /* find register group entry */
65 QLIST_FOREACH(entry, &s->reg_grps, entries) {
66 /* check address */
67 if ((entry->base_offset <= address)
68 && ((entry->base_offset + entry->size) > address)) {
69 return entry;
70 }
71 }
72
73 /* group entry not found */
74 return NULL;
75 }
76
77 /* find emulate register entry */
78 XenPTReg *xen_pt_find_reg(XenPTRegGroup *reg_grp, uint32_t address)
79 {
80 XenPTReg *reg_entry = NULL;
81 XenPTRegInfo *reg = NULL;
82 uint32_t real_offset = 0;
83
84 /* find register entry */
85 QLIST_FOREACH(reg_entry, &reg_grp->reg_tbl_list, entries) {
86 reg = reg_entry->reg;
87 real_offset = reg_grp->base_offset + reg->offset;
88 /* check address */
89 if ((real_offset <= address)
90 && ((real_offset + reg->size) > address)) {
91 return reg_entry;
92 }
93 }
94
95 return NULL;
96 }
97
98
99 /****************
100 * general register functions
101 */
102
103 /* register initialization function */
104
105 static int xen_pt_common_reg_init(XenPCIPassthroughState *s,
106 XenPTRegInfo *reg, uint32_t real_offset,
107 uint32_t *data)
108 {
109 *data = reg->init_val;
110 return 0;
111 }
112
113 /* Read register functions */
114
115 static int xen_pt_byte_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
116 uint8_t *value, uint8_t valid_mask)
117 {
118 XenPTRegInfo *reg = cfg_entry->reg;
119 uint8_t valid_emu_mask = 0;
120
121 /* emulate byte register */
122 valid_emu_mask = reg->emu_mask & valid_mask;
123 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
124
125 return 0;
126 }
127 static int xen_pt_word_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
128 uint16_t *value, uint16_t valid_mask)
129 {
130 XenPTRegInfo *reg = cfg_entry->reg;
131 uint16_t valid_emu_mask = 0;
132
133 /* emulate word register */
134 valid_emu_mask = reg->emu_mask & valid_mask;
135 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
136
137 return 0;
138 }
139 static int xen_pt_long_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
140 uint32_t *value, uint32_t valid_mask)
141 {
142 XenPTRegInfo *reg = cfg_entry->reg;
143 uint32_t valid_emu_mask = 0;
144
145 /* emulate long register */
146 valid_emu_mask = reg->emu_mask & valid_mask;
147 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
148
149 return 0;
150 }
151
152 /* Write register functions */
153
154 static int xen_pt_byte_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
155 uint8_t *val, uint8_t dev_value,
156 uint8_t valid_mask)
157 {
158 XenPTRegInfo *reg = cfg_entry->reg;
159 uint8_t writable_mask = 0;
160 uint8_t throughable_mask = 0;
161
162 /* modify emulate register */
163 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
164 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
165
166 /* create value for writing to I/O device register */
167 throughable_mask = ~reg->emu_mask & valid_mask;
168 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
169
170 return 0;
171 }
172 static int xen_pt_word_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
173 uint16_t *val, uint16_t dev_value,
174 uint16_t valid_mask)
175 {
176 XenPTRegInfo *reg = cfg_entry->reg;
177 uint16_t writable_mask = 0;
178 uint16_t throughable_mask = 0;
179
180 /* modify emulate register */
181 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
182 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
183
184 /* create value for writing to I/O device register */
185 throughable_mask = ~reg->emu_mask & valid_mask;
186 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
187
188 return 0;
189 }
190 static int xen_pt_long_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
191 uint32_t *val, uint32_t dev_value,
192 uint32_t valid_mask)
193 {
194 XenPTRegInfo *reg = cfg_entry->reg;
195 uint32_t writable_mask = 0;
196 uint32_t throughable_mask = 0;
197
198 /* modify emulate register */
199 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
200 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
201
202 /* create value for writing to I/O device register */
203 throughable_mask = ~reg->emu_mask & valid_mask;
204 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
205
206 return 0;
207 }
208
209
210 /* XenPTRegInfo declaration
211 * - only for emulated register (either a part or whole bit).
212 * - for passthrough register that need special behavior (like interacting with
213 * other component), set emu_mask to all 0 and specify r/w func properly.
214 * - do NOT use ALL F for init_val, otherwise the tbl will not be registered.
215 */
216
217 /********************
218 * Header Type0
219 */
220
221 static int xen_pt_vendor_reg_init(XenPCIPassthroughState *s,
222 XenPTRegInfo *reg, uint32_t real_offset,
223 uint32_t *data)
224 {
225 *data = s->real_device.vendor_id;
226 return 0;
227 }
228 static int xen_pt_device_reg_init(XenPCIPassthroughState *s,
229 XenPTRegInfo *reg, uint32_t real_offset,
230 uint32_t *data)
231 {
232 *data = s->real_device.device_id;
233 return 0;
234 }
235 static int xen_pt_status_reg_init(XenPCIPassthroughState *s,
236 XenPTRegInfo *reg, uint32_t real_offset,
237 uint32_t *data)
238 {
239 XenPTRegGroup *reg_grp_entry = NULL;
240 XenPTReg *reg_entry = NULL;
241 uint32_t reg_field = 0;
242
243 /* find Header register group */
244 reg_grp_entry = xen_pt_find_reg_grp(s, PCI_CAPABILITY_LIST);
245 if (reg_grp_entry) {
246 /* find Capabilities Pointer register */
247 reg_entry = xen_pt_find_reg(reg_grp_entry, PCI_CAPABILITY_LIST);
248 if (reg_entry) {
249 /* check Capabilities Pointer register */
250 if (reg_entry->data) {
251 reg_field |= PCI_STATUS_CAP_LIST;
252 } else {
253 reg_field &= ~PCI_STATUS_CAP_LIST;
254 }
255 } else {
256 xen_shutdown_fatal_error("Internal error: Couldn't find XenPTReg*"
257 " for Capabilities Pointer register."
258 " (%s)\n", __func__);
259 return -1;
260 }
261 } else {
262 xen_shutdown_fatal_error("Internal error: Couldn't find XenPTRegGroup"
263 " for Header. (%s)\n", __func__);
264 return -1;
265 }
266
267 *data = reg_field;
268 return 0;
269 }
270 static int xen_pt_header_type_reg_init(XenPCIPassthroughState *s,
271 XenPTRegInfo *reg, uint32_t real_offset,
272 uint32_t *data)
273 {
274 /* read PCI_HEADER_TYPE */
275 *data = reg->init_val | 0x80;
276 return 0;
277 }
278
279 /* initialize Interrupt Pin register */
280 static int xen_pt_irqpin_reg_init(XenPCIPassthroughState *s,
281 XenPTRegInfo *reg, uint32_t real_offset,
282 uint32_t *data)
283 {
284 *data = xen_pt_pci_read_intx(s);
285 return 0;
286 }
287
288 /* Command register */
289 static int xen_pt_cmd_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
290 uint16_t *value, uint16_t valid_mask)
291 {
292 XenPTRegInfo *reg = cfg_entry->reg;
293 uint16_t valid_emu_mask = 0;
294 uint16_t emu_mask = reg->emu_mask;
295
296 if (s->is_virtfn) {
297 emu_mask |= PCI_COMMAND_MEMORY;
298 }
299
300 /* emulate word register */
301 valid_emu_mask = emu_mask & valid_mask;
302 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
303
304 return 0;
305 }
306 static int xen_pt_cmd_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
307 uint16_t *val, uint16_t dev_value,
308 uint16_t valid_mask)
309 {
310 XenPTRegInfo *reg = cfg_entry->reg;
311 uint16_t writable_mask = 0;
312 uint16_t throughable_mask = 0;
313 uint16_t emu_mask = reg->emu_mask;
314
315 if (s->is_virtfn) {
316 emu_mask |= PCI_COMMAND_MEMORY;
317 }
318
319 /* modify emulate register */
320 writable_mask = ~reg->ro_mask & valid_mask;
321 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
322
323 /* create value for writing to I/O device register */
324 throughable_mask = ~emu_mask & valid_mask;
325
326 if (*val & PCI_COMMAND_INTX_DISABLE) {
327 throughable_mask |= PCI_COMMAND_INTX_DISABLE;
328 } else {
329 if (s->machine_irq) {
330 throughable_mask |= PCI_COMMAND_INTX_DISABLE;
331 }
332 }
333
334 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
335
336 return 0;
337 }
338
339 /* BAR */
340 #define XEN_PT_BAR_MEM_RO_MASK 0x0000000F /* BAR ReadOnly mask(Memory) */
341 #define XEN_PT_BAR_MEM_EMU_MASK 0xFFFFFFF0 /* BAR emul mask(Memory) */
342 #define XEN_PT_BAR_IO_RO_MASK 0x00000003 /* BAR ReadOnly mask(I/O) */
343 #define XEN_PT_BAR_IO_EMU_MASK 0xFFFFFFFC /* BAR emul mask(I/O) */
344
345 static XenPTBarFlag xen_pt_bar_reg_parse(XenPCIPassthroughState *s,
346 XenPTRegInfo *reg)
347 {
348 PCIDevice *d = &s->dev;
349 XenPTRegion *region = NULL;
350 PCIIORegion *r;
351 int index = 0;
352
353 /* check 64bit BAR */
354 index = xen_pt_bar_offset_to_index(reg->offset);
355 if ((0 < index) && (index < PCI_ROM_SLOT)) {
356 int type = s->real_device.io_regions[index - 1].type;
357
358 if ((type & XEN_HOST_PCI_REGION_TYPE_MEM)
359 && (type & XEN_HOST_PCI_REGION_TYPE_MEM_64)) {
360 region = &s->bases[index - 1];
361 if (region->bar_flag != XEN_PT_BAR_FLAG_UPPER) {
362 return XEN_PT_BAR_FLAG_UPPER;
363 }
364 }
365 }
366
367 /* check unused BAR */
368 r = &d->io_regions[index];
369 if (r->size == 0) {
370 return XEN_PT_BAR_FLAG_UNUSED;
371 }
372
373 /* for ExpROM BAR */
374 if (index == PCI_ROM_SLOT) {
375 return XEN_PT_BAR_FLAG_MEM;
376 }
377
378 /* check BAR I/O indicator */
379 if (s->real_device.io_regions[index].type & XEN_HOST_PCI_REGION_TYPE_IO) {
380 return XEN_PT_BAR_FLAG_IO;
381 } else {
382 return XEN_PT_BAR_FLAG_MEM;
383 }
384 }
385
386 static inline uint32_t base_address_with_flags(XenHostPCIIORegion *hr)
387 {
388 if (hr->type & XEN_HOST_PCI_REGION_TYPE_IO) {
389 return hr->base_addr | (hr->bus_flags & ~PCI_BASE_ADDRESS_IO_MASK);
390 } else {
391 return hr->base_addr | (hr->bus_flags & ~PCI_BASE_ADDRESS_MEM_MASK);
392 }
393 }
394
395 static int xen_pt_bar_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg,
396 uint32_t real_offset, uint32_t *data)
397 {
398 uint32_t reg_field = 0;
399 int index;
400
401 index = xen_pt_bar_offset_to_index(reg->offset);
402 if (index < 0 || index >= PCI_NUM_REGIONS) {
403 XEN_PT_ERR(&s->dev, "Internal error: Invalid BAR index [%d].\n", index);
404 return -1;
405 }
406
407 /* set BAR flag */
408 s->bases[index].bar_flag = xen_pt_bar_reg_parse(s, reg);
409 if (s->bases[index].bar_flag == XEN_PT_BAR_FLAG_UNUSED) {
410 reg_field = XEN_PT_INVALID_REG;
411 }
412
413 *data = reg_field;
414 return 0;
415 }
416 static int xen_pt_bar_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
417 uint32_t *value, uint32_t valid_mask)
418 {
419 XenPTRegInfo *reg = cfg_entry->reg;
420 uint32_t valid_emu_mask = 0;
421 uint32_t bar_emu_mask = 0;
422 int index;
423
424 /* get BAR index */
425 index = xen_pt_bar_offset_to_index(reg->offset);
426 if (index < 0 || index >= PCI_NUM_REGIONS) {
427 XEN_PT_ERR(&s->dev, "Internal error: Invalid BAR index [%d].\n", index);
428 return -1;
429 }
430
431 /* use fixed-up value from kernel sysfs */
432 *value = base_address_with_flags(&s->real_device.io_regions[index]);
433
434 /* set emulate mask depend on BAR flag */
435 switch (s->bases[index].bar_flag) {
436 case XEN_PT_BAR_FLAG_MEM:
437 bar_emu_mask = XEN_PT_BAR_MEM_EMU_MASK;
438 break;
439 case XEN_PT_BAR_FLAG_IO:
440 bar_emu_mask = XEN_PT_BAR_IO_EMU_MASK;
441 break;
442 case XEN_PT_BAR_FLAG_UPPER:
443 bar_emu_mask = XEN_PT_BAR_ALLF;
444 break;
445 default:
446 break;
447 }
448
449 /* emulate BAR */
450 valid_emu_mask = bar_emu_mask & valid_mask;
451 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
452
453 return 0;
454 }
455 static int xen_pt_bar_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
456 uint32_t *val, uint32_t dev_value,
457 uint32_t valid_mask)
458 {
459 XenPTRegInfo *reg = cfg_entry->reg;
460 XenPTRegion *base = NULL;
461 PCIDevice *d = &s->dev;
462 const PCIIORegion *r;
463 uint32_t writable_mask = 0;
464 uint32_t throughable_mask = 0;
465 uint32_t bar_emu_mask = 0;
466 uint32_t bar_ro_mask = 0;
467 uint32_t r_size = 0;
468 int index = 0;
469
470 index = xen_pt_bar_offset_to_index(reg->offset);
471 if (index < 0 || index >= PCI_NUM_REGIONS) {
472 XEN_PT_ERR(d, "Internal error: Invalid BAR index [%d].\n", index);
473 return -1;
474 }
475
476 r = &d->io_regions[index];
477 base = &s->bases[index];
478 r_size = xen_pt_get_emul_size(base->bar_flag, r->size);
479
480 /* set emulate mask and read-only mask values depend on the BAR flag */
481 switch (s->bases[index].bar_flag) {
482 case XEN_PT_BAR_FLAG_MEM:
483 bar_emu_mask = XEN_PT_BAR_MEM_EMU_MASK;
484 bar_ro_mask = XEN_PT_BAR_MEM_RO_MASK | (r_size - 1);
485 break;
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);
489 break;
490 case XEN_PT_BAR_FLAG_UPPER:
491 bar_emu_mask = XEN_PT_BAR_ALLF;
492 bar_ro_mask = 0; /* all upper 32bit are R/W */
493 break;
494 default:
495 break;
496 }
497
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);
501
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_MEM:
505 /* nothing to do */
506 break;
507 case XEN_PT_BAR_FLAG_IO:
508 /* nothing to do */
509 break;
510 case XEN_PT_BAR_FLAG_UPPER:
511 if (cfg_entry->data) {
512 if (cfg_entry->data != (XEN_PT_BAR_ALLF & ~bar_ro_mask)) {
513 XEN_PT_WARN(d, "Guest attempt to set high MMIO Base Address. "
514 "Ignore mapping. "
515 "(offset: 0x%02x, high address: 0x%08x)\n",
516 reg->offset, cfg_entry->data);
517 }
518 }
519 break;
520 default:
521 break;
522 }
523
524 /* create value for writing to I/O device register */
525 throughable_mask = ~bar_emu_mask & valid_mask;
526 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
527
528 return 0;
529 }
530
531 /* write Exp ROM BAR */
532 static int xen_pt_exp_rom_bar_reg_write(XenPCIPassthroughState *s,
533 XenPTReg *cfg_entry, uint32_t *val,
534 uint32_t dev_value, uint32_t valid_mask)
535 {
536 XenPTRegInfo *reg = cfg_entry->reg;
537 XenPTRegion *base = NULL;
538 PCIDevice *d = (PCIDevice *)&s->dev;
539 uint32_t writable_mask = 0;
540 uint32_t throughable_mask = 0;
541 pcibus_t r_size = 0;
542 uint32_t bar_emu_mask = 0;
543 uint32_t bar_ro_mask = 0;
544
545 r_size = d->io_regions[PCI_ROM_SLOT].size;
546 base = &s->bases[PCI_ROM_SLOT];
547 /* align memory type resource size */
548 r_size = xen_pt_get_emul_size(base->bar_flag, r_size);
549
550 /* set emulate mask and read-only mask */
551 bar_emu_mask = reg->emu_mask;
552 bar_ro_mask = (reg->ro_mask | (r_size - 1)) & ~PCI_ROM_ADDRESS_ENABLE;
553
554 /* modify emulate register */
555 writable_mask = ~bar_ro_mask & valid_mask;
556 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
557
558 /* create value for writing to I/O device register */
559 throughable_mask = ~bar_emu_mask & valid_mask;
560 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
561
562 return 0;
563 }
564
565 /* Header Type0 reg static infomation table */
566 static XenPTRegInfo xen_pt_emu_reg_header0[] = {
567 /* Vendor ID reg */
568 {
569 .offset = PCI_VENDOR_ID,
570 .size = 2,
571 .init_val = 0x0000,
572 .ro_mask = 0xFFFF,
573 .emu_mask = 0xFFFF,
574 .init = xen_pt_vendor_reg_init,
575 .u.w.read = xen_pt_word_reg_read,
576 .u.w.write = xen_pt_word_reg_write,
577 },
578 /* Device ID reg */
579 {
580 .offset = PCI_DEVICE_ID,
581 .size = 2,
582 .init_val = 0x0000,
583 .ro_mask = 0xFFFF,
584 .emu_mask = 0xFFFF,
585 .init = xen_pt_device_reg_init,
586 .u.w.read = xen_pt_word_reg_read,
587 .u.w.write = xen_pt_word_reg_write,
588 },
589 /* Command reg */
590 {
591 .offset = PCI_COMMAND,
592 .size = 2,
593 .init_val = 0x0000,
594 .ro_mask = 0xF880,
595 .emu_mask = 0x0740,
596 .init = xen_pt_common_reg_init,
597 .u.w.read = xen_pt_cmd_reg_read,
598 .u.w.write = xen_pt_cmd_reg_write,
599 },
600 /* Capabilities Pointer reg */
601 {
602 .offset = PCI_CAPABILITY_LIST,
603 .size = 1,
604 .init_val = 0x00,
605 .ro_mask = 0xFF,
606 .emu_mask = 0xFF,
607 .init = xen_pt_ptr_reg_init,
608 .u.b.read = xen_pt_byte_reg_read,
609 .u.b.write = xen_pt_byte_reg_write,
610 },
611 /* Status reg */
612 /* use emulated Cap Ptr value to initialize,
613 * so need to be declared after Cap Ptr reg
614 */
615 {
616 .offset = PCI_STATUS,
617 .size = 2,
618 .init_val = 0x0000,
619 .ro_mask = 0x06FF,
620 .emu_mask = 0x0010,
621 .init = xen_pt_status_reg_init,
622 .u.w.read = xen_pt_word_reg_read,
623 .u.w.write = xen_pt_word_reg_write,
624 },
625 /* Cache Line Size reg */
626 {
627 .offset = PCI_CACHE_LINE_SIZE,
628 .size = 1,
629 .init_val = 0x00,
630 .ro_mask = 0x00,
631 .emu_mask = 0xFF,
632 .init = xen_pt_common_reg_init,
633 .u.b.read = xen_pt_byte_reg_read,
634 .u.b.write = xen_pt_byte_reg_write,
635 },
636 /* Latency Timer reg */
637 {
638 .offset = PCI_LATENCY_TIMER,
639 .size = 1,
640 .init_val = 0x00,
641 .ro_mask = 0x00,
642 .emu_mask = 0xFF,
643 .init = xen_pt_common_reg_init,
644 .u.b.read = xen_pt_byte_reg_read,
645 .u.b.write = xen_pt_byte_reg_write,
646 },
647 /* Header Type reg */
648 {
649 .offset = PCI_HEADER_TYPE,
650 .size = 1,
651 .init_val = 0x00,
652 .ro_mask = 0xFF,
653 .emu_mask = 0x00,
654 .init = xen_pt_header_type_reg_init,
655 .u.b.read = xen_pt_byte_reg_read,
656 .u.b.write = xen_pt_byte_reg_write,
657 },
658 /* Interrupt Line reg */
659 {
660 .offset = PCI_INTERRUPT_LINE,
661 .size = 1,
662 .init_val = 0x00,
663 .ro_mask = 0x00,
664 .emu_mask = 0xFF,
665 .init = xen_pt_common_reg_init,
666 .u.b.read = xen_pt_byte_reg_read,
667 .u.b.write = xen_pt_byte_reg_write,
668 },
669 /* Interrupt Pin reg */
670 {
671 .offset = PCI_INTERRUPT_PIN,
672 .size = 1,
673 .init_val = 0x00,
674 .ro_mask = 0xFF,
675 .emu_mask = 0xFF,
676 .init = xen_pt_irqpin_reg_init,
677 .u.b.read = xen_pt_byte_reg_read,
678 .u.b.write = xen_pt_byte_reg_write,
679 },
680 /* BAR 0 reg */
681 /* mask of BAR need to be decided later, depends on IO/MEM type */
682 {
683 .offset = PCI_BASE_ADDRESS_0,
684 .size = 4,
685 .init_val = 0x00000000,
686 .init = xen_pt_bar_reg_init,
687 .u.dw.read = xen_pt_bar_reg_read,
688 .u.dw.write = xen_pt_bar_reg_write,
689 },
690 /* BAR 1 reg */
691 {
692 .offset = PCI_BASE_ADDRESS_1,
693 .size = 4,
694 .init_val = 0x00000000,
695 .init = xen_pt_bar_reg_init,
696 .u.dw.read = xen_pt_bar_reg_read,
697 .u.dw.write = xen_pt_bar_reg_write,
698 },
699 /* BAR 2 reg */
700 {
701 .offset = PCI_BASE_ADDRESS_2,
702 .size = 4,
703 .init_val = 0x00000000,
704 .init = xen_pt_bar_reg_init,
705 .u.dw.read = xen_pt_bar_reg_read,
706 .u.dw.write = xen_pt_bar_reg_write,
707 },
708 /* BAR 3 reg */
709 {
710 .offset = PCI_BASE_ADDRESS_3,
711 .size = 4,
712 .init_val = 0x00000000,
713 .init = xen_pt_bar_reg_init,
714 .u.dw.read = xen_pt_bar_reg_read,
715 .u.dw.write = xen_pt_bar_reg_write,
716 },
717 /* BAR 4 reg */
718 {
719 .offset = PCI_BASE_ADDRESS_4,
720 .size = 4,
721 .init_val = 0x00000000,
722 .init = xen_pt_bar_reg_init,
723 .u.dw.read = xen_pt_bar_reg_read,
724 .u.dw.write = xen_pt_bar_reg_write,
725 },
726 /* BAR 5 reg */
727 {
728 .offset = PCI_BASE_ADDRESS_5,
729 .size = 4,
730 .init_val = 0x00000000,
731 .init = xen_pt_bar_reg_init,
732 .u.dw.read = xen_pt_bar_reg_read,
733 .u.dw.write = xen_pt_bar_reg_write,
734 },
735 /* Expansion ROM BAR reg */
736 {
737 .offset = PCI_ROM_ADDRESS,
738 .size = 4,
739 .init_val = 0x00000000,
740 .ro_mask = 0x000007FE,
741 .emu_mask = 0xFFFFF800,
742 .init = xen_pt_bar_reg_init,
743 .u.dw.read = xen_pt_long_reg_read,
744 .u.dw.write = xen_pt_exp_rom_bar_reg_write,
745 },
746 {
747 .size = 0,
748 },
749 };
750
751
752 /*********************************
753 * Vital Product Data Capability
754 */
755
756 /* Vital Product Data Capability Structure reg static infomation table */
757 static XenPTRegInfo xen_pt_emu_reg_vpd[] = {
758 {
759 .offset = PCI_CAP_LIST_NEXT,
760 .size = 1,
761 .init_val = 0x00,
762 .ro_mask = 0xFF,
763 .emu_mask = 0xFF,
764 .init = xen_pt_ptr_reg_init,
765 .u.b.read = xen_pt_byte_reg_read,
766 .u.b.write = xen_pt_byte_reg_write,
767 },
768 {
769 .size = 0,
770 },
771 };
772
773
774 /**************************************
775 * Vendor Specific Capability
776 */
777
778 /* Vendor Specific Capability Structure reg static infomation table */
779 static XenPTRegInfo xen_pt_emu_reg_vendor[] = {
780 {
781 .offset = PCI_CAP_LIST_NEXT,
782 .size = 1,
783 .init_val = 0x00,
784 .ro_mask = 0xFF,
785 .emu_mask = 0xFF,
786 .init = xen_pt_ptr_reg_init,
787 .u.b.read = xen_pt_byte_reg_read,
788 .u.b.write = xen_pt_byte_reg_write,
789 },
790 {
791 .size = 0,
792 },
793 };
794
795
796 /*****************************
797 * PCI Express Capability
798 */
799
800 static inline uint8_t get_capability_version(XenPCIPassthroughState *s,
801 uint32_t offset)
802 {
803 uint8_t flags = pci_get_byte(s->dev.config + offset + PCI_EXP_FLAGS);
804 return flags & PCI_EXP_FLAGS_VERS;
805 }
806
807 static inline uint8_t get_device_type(XenPCIPassthroughState *s,
808 uint32_t offset)
809 {
810 uint8_t flags = pci_get_byte(s->dev.config + offset + PCI_EXP_FLAGS);
811 return (flags & PCI_EXP_FLAGS_TYPE) >> 4;
812 }
813
814 /* initialize Link Control register */
815 static int xen_pt_linkctrl_reg_init(XenPCIPassthroughState *s,
816 XenPTRegInfo *reg, uint32_t real_offset,
817 uint32_t *data)
818 {
819 uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset);
820 uint8_t dev_type = get_device_type(s, real_offset - reg->offset);
821
822 /* no need to initialize in case of Root Complex Integrated Endpoint
823 * with cap_ver 1.x
824 */
825 if ((dev_type == PCI_EXP_TYPE_RC_END) && (cap_ver == 1)) {
826 *data = XEN_PT_INVALID_REG;
827 }
828
829 *data = reg->init_val;
830 return 0;
831 }
832 /* initialize Device Control 2 register */
833 static int xen_pt_devctrl2_reg_init(XenPCIPassthroughState *s,
834 XenPTRegInfo *reg, uint32_t real_offset,
835 uint32_t *data)
836 {
837 uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset);
838
839 /* no need to initialize in case of cap_ver 1.x */
840 if (cap_ver == 1) {
841 *data = XEN_PT_INVALID_REG;
842 }
843
844 *data = reg->init_val;
845 return 0;
846 }
847 /* initialize Link Control 2 register */
848 static int xen_pt_linkctrl2_reg_init(XenPCIPassthroughState *s,
849 XenPTRegInfo *reg, uint32_t real_offset,
850 uint32_t *data)
851 {
852 uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset);
853 uint32_t reg_field = 0;
854
855 /* no need to initialize in case of cap_ver 1.x */
856 if (cap_ver == 1) {
857 reg_field = XEN_PT_INVALID_REG;
858 } else {
859 /* set Supported Link Speed */
860 uint8_t lnkcap = pci_get_byte(s->dev.config + real_offset - reg->offset
861 + PCI_EXP_LNKCAP);
862 reg_field |= PCI_EXP_LNKCAP_SLS & lnkcap;
863 }
864
865 *data = reg_field;
866 return 0;
867 }
868
869 /* PCI Express Capability Structure reg static infomation table */
870 static XenPTRegInfo xen_pt_emu_reg_pcie[] = {
871 /* Next Pointer reg */
872 {
873 .offset = PCI_CAP_LIST_NEXT,
874 .size = 1,
875 .init_val = 0x00,
876 .ro_mask = 0xFF,
877 .emu_mask = 0xFF,
878 .init = xen_pt_ptr_reg_init,
879 .u.b.read = xen_pt_byte_reg_read,
880 .u.b.write = xen_pt_byte_reg_write,
881 },
882 /* Device Capabilities reg */
883 {
884 .offset = PCI_EXP_DEVCAP,
885 .size = 4,
886 .init_val = 0x00000000,
887 .ro_mask = 0x1FFCFFFF,
888 .emu_mask = 0x10000000,
889 .init = xen_pt_common_reg_init,
890 .u.dw.read = xen_pt_long_reg_read,
891 .u.dw.write = xen_pt_long_reg_write,
892 },
893 /* Device Control reg */
894 {
895 .offset = PCI_EXP_DEVCTL,
896 .size = 2,
897 .init_val = 0x2810,
898 .ro_mask = 0x8400,
899 .emu_mask = 0xFFFF,
900 .init = xen_pt_common_reg_init,
901 .u.w.read = xen_pt_word_reg_read,
902 .u.w.write = xen_pt_word_reg_write,
903 },
904 /* Link Control reg */
905 {
906 .offset = PCI_EXP_LNKCTL,
907 .size = 2,
908 .init_val = 0x0000,
909 .ro_mask = 0xFC34,
910 .emu_mask = 0xFFFF,
911 .init = xen_pt_linkctrl_reg_init,
912 .u.w.read = xen_pt_word_reg_read,
913 .u.w.write = xen_pt_word_reg_write,
914 },
915 /* Device Control 2 reg */
916 {
917 .offset = 0x28,
918 .size = 2,
919 .init_val = 0x0000,
920 .ro_mask = 0xFFE0,
921 .emu_mask = 0xFFFF,
922 .init = xen_pt_devctrl2_reg_init,
923 .u.w.read = xen_pt_word_reg_read,
924 .u.w.write = xen_pt_word_reg_write,
925 },
926 /* Link Control 2 reg */
927 {
928 .offset = 0x30,
929 .size = 2,
930 .init_val = 0x0000,
931 .ro_mask = 0xE040,
932 .emu_mask = 0xFFFF,
933 .init = xen_pt_linkctrl2_reg_init,
934 .u.w.read = xen_pt_word_reg_read,
935 .u.w.write = xen_pt_word_reg_write,
936 },
937 {
938 .size = 0,
939 },
940 };
941
942
943 /*********************************
944 * Power Management Capability
945 */
946
947 /* read Power Management Control/Status register */
948 static int xen_pt_pmcsr_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
949 uint16_t *value, uint16_t valid_mask)
950 {
951 XenPTRegInfo *reg = cfg_entry->reg;
952 uint16_t valid_emu_mask = reg->emu_mask;
953
954 valid_emu_mask |= PCI_PM_CTRL_STATE_MASK | PCI_PM_CTRL_NO_SOFT_RESET;
955
956 valid_emu_mask = valid_emu_mask & valid_mask;
957 *value = XEN_PT_MERGE_VALUE(*value, cfg_entry->data, ~valid_emu_mask);
958
959 return 0;
960 }
961 /* write Power Management Control/Status register */
962 static int xen_pt_pmcsr_reg_write(XenPCIPassthroughState *s,
963 XenPTReg *cfg_entry, uint16_t *val,
964 uint16_t dev_value, uint16_t valid_mask)
965 {
966 XenPTRegInfo *reg = cfg_entry->reg;
967 uint16_t emu_mask = reg->emu_mask;
968 uint16_t writable_mask = 0;
969 uint16_t throughable_mask = 0;
970
971 emu_mask |= PCI_PM_CTRL_STATE_MASK | PCI_PM_CTRL_NO_SOFT_RESET;
972
973 /* modify emulate register */
974 writable_mask = emu_mask & ~reg->ro_mask & valid_mask;
975 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
976
977 /* create value for writing to I/O device register */
978 throughable_mask = ~emu_mask & valid_mask;
979 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
980
981 return 0;
982 }
983
984 /* Power Management Capability reg static infomation table */
985 static XenPTRegInfo xen_pt_emu_reg_pm[] = {
986 /* Next Pointer reg */
987 {
988 .offset = PCI_CAP_LIST_NEXT,
989 .size = 1,
990 .init_val = 0x00,
991 .ro_mask = 0xFF,
992 .emu_mask = 0xFF,
993 .init = xen_pt_ptr_reg_init,
994 .u.b.read = xen_pt_byte_reg_read,
995 .u.b.write = xen_pt_byte_reg_write,
996 },
997 /* Power Management Capabilities reg */
998 {
999 .offset = PCI_CAP_FLAGS,
1000 .size = 2,
1001 .init_val = 0x0000,
1002 .ro_mask = 0xFFFF,
1003 .emu_mask = 0xF9C8,
1004 .init = xen_pt_common_reg_init,
1005 .u.w.read = xen_pt_word_reg_read,
1006 .u.w.write = xen_pt_word_reg_write,
1007 },
1008 /* PCI Power Management Control/Status reg */
1009 {
1010 .offset = PCI_PM_CTRL,
1011 .size = 2,
1012 .init_val = 0x0008,
1013 .ro_mask = 0xE1FC,
1014 .emu_mask = 0x8100,
1015 .init = xen_pt_common_reg_init,
1016 .u.w.read = xen_pt_pmcsr_reg_read,
1017 .u.w.write = xen_pt_pmcsr_reg_write,
1018 },
1019 {
1020 .size = 0,
1021 },
1022 };
1023
1024
1025 /********************************
1026 * MSI Capability
1027 */
1028
1029 /* Helper */
1030 static bool xen_pt_msgdata_check_type(uint32_t offset, uint16_t flags)
1031 {
1032 /* check the offset whether matches the type or not */
1033 bool is_32 = (offset == PCI_MSI_DATA_32) && !(flags & PCI_MSI_FLAGS_64BIT);
1034 bool is_64 = (offset == PCI_MSI_DATA_64) && (flags & PCI_MSI_FLAGS_64BIT);
1035 return is_32 || is_64;
1036 }
1037
1038 /* Message Control register */
1039 static int xen_pt_msgctrl_reg_init(XenPCIPassthroughState *s,
1040 XenPTRegInfo *reg, uint32_t real_offset,
1041 uint32_t *data)
1042 {
1043 PCIDevice *d = &s->dev;
1044 XenPTMSI *msi = s->msi;
1045 uint16_t reg_field = 0;
1046
1047 /* use I/O device register's value as initial value */
1048 reg_field = pci_get_word(d->config + real_offset);
1049
1050 if (reg_field & PCI_MSI_FLAGS_ENABLE) {
1051 XEN_PT_LOG(&s->dev, "MSI already enabled, disabling it first\n");
1052 xen_host_pci_set_word(&s->real_device, real_offset,
1053 reg_field & ~PCI_MSI_FLAGS_ENABLE);
1054 }
1055 msi->flags |= reg_field;
1056 msi->ctrl_offset = real_offset;
1057 msi->initialized = false;
1058 msi->mapped = false;
1059
1060 *data = reg->init_val;
1061 return 0;
1062 }
1063 static int xen_pt_msgctrl_reg_write(XenPCIPassthroughState *s,
1064 XenPTReg *cfg_entry, uint16_t *val,
1065 uint16_t dev_value, uint16_t valid_mask)
1066 {
1067 XenPTRegInfo *reg = cfg_entry->reg;
1068 XenPTMSI *msi = s->msi;
1069 uint16_t writable_mask = 0;
1070 uint16_t throughable_mask = 0;
1071 uint16_t raw_val;
1072
1073 /* Currently no support for multi-vector */
1074 if (*val & PCI_MSI_FLAGS_QSIZE) {
1075 XEN_PT_WARN(&s->dev, "Tries to set more than 1 vector ctrl %x\n", *val);
1076 }
1077
1078 /* modify emulate register */
1079 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
1080 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
1081 msi->flags |= cfg_entry->data & ~PCI_MSI_FLAGS_ENABLE;
1082
1083 /* create value for writing to I/O device register */
1084 raw_val = *val;
1085 throughable_mask = ~reg->emu_mask & valid_mask;
1086 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
1087
1088 /* update MSI */
1089 if (raw_val & PCI_MSI_FLAGS_ENABLE) {
1090 /* setup MSI pirq for the first time */
1091 if (!msi->initialized) {
1092 /* Init physical one */
1093 XEN_PT_LOG(&s->dev, "setup MSI\n");
1094 if (xen_pt_msi_setup(s)) {
1095 /* We do not broadcast the error to the framework code, so
1096 * that MSI errors are contained in MSI emulation code and
1097 * QEMU can go on running.
1098 * Guest MSI would be actually not working.
1099 */
1100 *val &= ~PCI_MSI_FLAGS_ENABLE;
1101 XEN_PT_WARN(&s->dev, "Can not map MSI.\n");
1102 return 0;
1103 }
1104 if (xen_pt_msi_update(s)) {
1105 *val &= ~PCI_MSI_FLAGS_ENABLE;
1106 XEN_PT_WARN(&s->dev, "Can not bind MSI\n");
1107 return 0;
1108 }
1109 msi->initialized = true;
1110 msi->mapped = true;
1111 }
1112 msi->flags |= PCI_MSI_FLAGS_ENABLE;
1113 } else {
1114 msi->flags &= ~PCI_MSI_FLAGS_ENABLE;
1115 }
1116
1117 /* pass through MSI_ENABLE bit */
1118 *val &= ~PCI_MSI_FLAGS_ENABLE;
1119 *val |= raw_val & PCI_MSI_FLAGS_ENABLE;
1120
1121 return 0;
1122 }
1123
1124 /* initialize Message Upper Address register */
1125 static int xen_pt_msgaddr64_reg_init(XenPCIPassthroughState *s,
1126 XenPTRegInfo *reg, uint32_t real_offset,
1127 uint32_t *data)
1128 {
1129 /* no need to initialize in case of 32 bit type */
1130 if (!(s->msi->flags & PCI_MSI_FLAGS_64BIT)) {
1131 *data = XEN_PT_INVALID_REG;
1132 } else {
1133 *data = reg->init_val;
1134 }
1135
1136 return 0;
1137 }
1138 /* this function will be called twice (for 32 bit and 64 bit type) */
1139 /* initialize Message Data register */
1140 static int xen_pt_msgdata_reg_init(XenPCIPassthroughState *s,
1141 XenPTRegInfo *reg, uint32_t real_offset,
1142 uint32_t *data)
1143 {
1144 uint32_t flags = s->msi->flags;
1145 uint32_t offset = reg->offset;
1146
1147 /* check the offset whether matches the type or not */
1148 if (xen_pt_msgdata_check_type(offset, flags)) {
1149 *data = reg->init_val;
1150 } else {
1151 *data = XEN_PT_INVALID_REG;
1152 }
1153 return 0;
1154 }
1155
1156 /* write Message Address register */
1157 static int xen_pt_msgaddr32_reg_write(XenPCIPassthroughState *s,
1158 XenPTReg *cfg_entry, uint32_t *val,
1159 uint32_t dev_value, uint32_t valid_mask)
1160 {
1161 XenPTRegInfo *reg = cfg_entry->reg;
1162 uint32_t writable_mask = 0;
1163 uint32_t throughable_mask = 0;
1164 uint32_t old_addr = cfg_entry->data;
1165
1166 /* modify emulate register */
1167 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
1168 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
1169 s->msi->addr_lo = cfg_entry->data;
1170
1171 /* create value for writing to I/O device register */
1172 throughable_mask = ~reg->emu_mask & valid_mask;
1173 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
1174
1175 /* update MSI */
1176 if (cfg_entry->data != old_addr) {
1177 if (s->msi->mapped) {
1178 xen_pt_msi_update(s);
1179 }
1180 }
1181
1182 return 0;
1183 }
1184 /* write Message Upper Address register */
1185 static int xen_pt_msgaddr64_reg_write(XenPCIPassthroughState *s,
1186 XenPTReg *cfg_entry, uint32_t *val,
1187 uint32_t dev_value, uint32_t valid_mask)
1188 {
1189 XenPTRegInfo *reg = cfg_entry->reg;
1190 uint32_t writable_mask = 0;
1191 uint32_t throughable_mask = 0;
1192 uint32_t old_addr = cfg_entry->data;
1193
1194 /* check whether the type is 64 bit or not */
1195 if (!(s->msi->flags & PCI_MSI_FLAGS_64BIT)) {
1196 XEN_PT_ERR(&s->dev,
1197 "Can't write to the upper address without 64 bit support\n");
1198 return -1;
1199 }
1200
1201 /* modify emulate register */
1202 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
1203 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
1204 /* update the msi_info too */
1205 s->msi->addr_hi = cfg_entry->data;
1206
1207 /* create value for writing to I/O device register */
1208 throughable_mask = ~reg->emu_mask & valid_mask;
1209 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
1210
1211 /* update MSI */
1212 if (cfg_entry->data != old_addr) {
1213 if (s->msi->mapped) {
1214 xen_pt_msi_update(s);
1215 }
1216 }
1217
1218 return 0;
1219 }
1220
1221
1222 /* this function will be called twice (for 32 bit and 64 bit type) */
1223 /* write Message Data register */
1224 static int xen_pt_msgdata_reg_write(XenPCIPassthroughState *s,
1225 XenPTReg *cfg_entry, uint16_t *val,
1226 uint16_t dev_value, uint16_t valid_mask)
1227 {
1228 XenPTRegInfo *reg = cfg_entry->reg;
1229 XenPTMSI *msi = s->msi;
1230 uint16_t writable_mask = 0;
1231 uint16_t throughable_mask = 0;
1232 uint16_t old_data = cfg_entry->data;
1233 uint32_t offset = reg->offset;
1234
1235 /* check the offset whether matches the type or not */
1236 if (!xen_pt_msgdata_check_type(offset, msi->flags)) {
1237 /* exit I/O emulator */
1238 XEN_PT_ERR(&s->dev, "the offset does not match the 32/64 bit type!\n");
1239 return -1;
1240 }
1241
1242 /* modify emulate register */
1243 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
1244 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
1245 /* update the msi_info too */
1246 msi->data = cfg_entry->data;
1247
1248 /* create value for writing to I/O device register */
1249 throughable_mask = ~reg->emu_mask & valid_mask;
1250 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
1251
1252 /* update MSI */
1253 if (cfg_entry->data != old_data) {
1254 if (msi->mapped) {
1255 xen_pt_msi_update(s);
1256 }
1257 }
1258
1259 return 0;
1260 }
1261
1262 /* MSI Capability Structure reg static infomation table */
1263 static XenPTRegInfo xen_pt_emu_reg_msi[] = {
1264 /* Next Pointer reg */
1265 {
1266 .offset = PCI_CAP_LIST_NEXT,
1267 .size = 1,
1268 .init_val = 0x00,
1269 .ro_mask = 0xFF,
1270 .emu_mask = 0xFF,
1271 .init = xen_pt_ptr_reg_init,
1272 .u.b.read = xen_pt_byte_reg_read,
1273 .u.b.write = xen_pt_byte_reg_write,
1274 },
1275 /* Message Control reg */
1276 {
1277 .offset = PCI_MSI_FLAGS,
1278 .size = 2,
1279 .init_val = 0x0000,
1280 .ro_mask = 0xFF8E,
1281 .emu_mask = 0x007F,
1282 .init = xen_pt_msgctrl_reg_init,
1283 .u.w.read = xen_pt_word_reg_read,
1284 .u.w.write = xen_pt_msgctrl_reg_write,
1285 },
1286 /* Message Address reg */
1287 {
1288 .offset = PCI_MSI_ADDRESS_LO,
1289 .size = 4,
1290 .init_val = 0x00000000,
1291 .ro_mask = 0x00000003,
1292 .emu_mask = 0xFFFFFFFF,
1293 .no_wb = 1,
1294 .init = xen_pt_common_reg_init,
1295 .u.dw.read = xen_pt_long_reg_read,
1296 .u.dw.write = xen_pt_msgaddr32_reg_write,
1297 },
1298 /* Message Upper Address reg (if PCI_MSI_FLAGS_64BIT set) */
1299 {
1300 .offset = PCI_MSI_ADDRESS_HI,
1301 .size = 4,
1302 .init_val = 0x00000000,
1303 .ro_mask = 0x00000000,
1304 .emu_mask = 0xFFFFFFFF,
1305 .no_wb = 1,
1306 .init = xen_pt_msgaddr64_reg_init,
1307 .u.dw.read = xen_pt_long_reg_read,
1308 .u.dw.write = xen_pt_msgaddr64_reg_write,
1309 },
1310 /* Message Data reg (16 bits of data for 32-bit devices) */
1311 {
1312 .offset = PCI_MSI_DATA_32,
1313 .size = 2,
1314 .init_val = 0x0000,
1315 .ro_mask = 0x0000,
1316 .emu_mask = 0xFFFF,
1317 .no_wb = 1,
1318 .init = xen_pt_msgdata_reg_init,
1319 .u.w.read = xen_pt_word_reg_read,
1320 .u.w.write = xen_pt_msgdata_reg_write,
1321 },
1322 /* Message Data reg (16 bits of data for 64-bit devices) */
1323 {
1324 .offset = PCI_MSI_DATA_64,
1325 .size = 2,
1326 .init_val = 0x0000,
1327 .ro_mask = 0x0000,
1328 .emu_mask = 0xFFFF,
1329 .no_wb = 1,
1330 .init = xen_pt_msgdata_reg_init,
1331 .u.w.read = xen_pt_word_reg_read,
1332 .u.w.write = xen_pt_msgdata_reg_write,
1333 },
1334 {
1335 .size = 0,
1336 },
1337 };
1338
1339
1340 /**************************************
1341 * MSI-X Capability
1342 */
1343
1344 /* Message Control register for MSI-X */
1345 static int xen_pt_msixctrl_reg_init(XenPCIPassthroughState *s,
1346 XenPTRegInfo *reg, uint32_t real_offset,
1347 uint32_t *data)
1348 {
1349 PCIDevice *d = &s->dev;
1350 uint16_t reg_field = 0;
1351
1352 /* use I/O device register's value as initial value */
1353 reg_field = pci_get_word(d->config + real_offset);
1354
1355 if (reg_field & PCI_MSIX_FLAGS_ENABLE) {
1356 XEN_PT_LOG(d, "MSIX already enabled, disabling it first\n");
1357 xen_host_pci_set_word(&s->real_device, real_offset,
1358 reg_field & ~PCI_MSIX_FLAGS_ENABLE);
1359 }
1360
1361 s->msix->ctrl_offset = real_offset;
1362
1363 *data = reg->init_val;
1364 return 0;
1365 }
1366 static int xen_pt_msixctrl_reg_write(XenPCIPassthroughState *s,
1367 XenPTReg *cfg_entry, uint16_t *val,
1368 uint16_t dev_value, uint16_t valid_mask)
1369 {
1370 XenPTRegInfo *reg = cfg_entry->reg;
1371 uint16_t writable_mask = 0;
1372 uint16_t throughable_mask = 0;
1373 int debug_msix_enabled_old;
1374
1375 /* modify emulate register */
1376 writable_mask = reg->emu_mask & ~reg->ro_mask & valid_mask;
1377 cfg_entry->data = XEN_PT_MERGE_VALUE(*val, cfg_entry->data, writable_mask);
1378
1379 /* create value for writing to I/O device register */
1380 throughable_mask = ~reg->emu_mask & valid_mask;
1381 *val = XEN_PT_MERGE_VALUE(*val, dev_value, throughable_mask);
1382
1383 /* update MSI-X */
1384 if ((*val & PCI_MSIX_FLAGS_ENABLE)
1385 && !(*val & PCI_MSIX_FLAGS_MASKALL)) {
1386 xen_pt_msix_update(s);
1387 }
1388
1389 debug_msix_enabled_old = s->msix->enabled;
1390 s->msix->enabled = !!(*val & PCI_MSIX_FLAGS_ENABLE);
1391 if (s->msix->enabled != debug_msix_enabled_old) {
1392 XEN_PT_LOG(&s->dev, "%s MSI-X\n",
1393 s->msix->enabled ? "enable" : "disable");
1394 }
1395
1396 return 0;
1397 }
1398
1399 /* MSI-X Capability Structure reg static infomation table */
1400 static XenPTRegInfo xen_pt_emu_reg_msix[] = {
1401 /* Next Pointer reg */
1402 {
1403 .offset = PCI_CAP_LIST_NEXT,
1404 .size = 1,
1405 .init_val = 0x00,
1406 .ro_mask = 0xFF,
1407 .emu_mask = 0xFF,
1408 .init = xen_pt_ptr_reg_init,
1409 .u.b.read = xen_pt_byte_reg_read,
1410 .u.b.write = xen_pt_byte_reg_write,
1411 },
1412 /* Message Control reg */
1413 {
1414 .offset = PCI_MSI_FLAGS,
1415 .size = 2,
1416 .init_val = 0x0000,
1417 .ro_mask = 0x3FFF,
1418 .emu_mask = 0x0000,
1419 .init = xen_pt_msixctrl_reg_init,
1420 .u.w.read = xen_pt_word_reg_read,
1421 .u.w.write = xen_pt_msixctrl_reg_write,
1422 },
1423 {
1424 .size = 0,
1425 },
1426 };
1427
1428
1429 /****************************
1430 * Capabilities
1431 */
1432
1433 /* capability structure register group size functions */
1434
1435 static int xen_pt_reg_grp_size_init(XenPCIPassthroughState *s,
1436 const XenPTRegGroupInfo *grp_reg,
1437 uint32_t base_offset, uint8_t *size)
1438 {
1439 *size = grp_reg->grp_size;
1440 return 0;
1441 }
1442 /* get Vendor Specific Capability Structure register group size */
1443 static int xen_pt_vendor_size_init(XenPCIPassthroughState *s,
1444 const XenPTRegGroupInfo *grp_reg,
1445 uint32_t base_offset, uint8_t *size)
1446 {
1447 *size = pci_get_byte(s->dev.config + base_offset + 0x02);
1448 return 0;
1449 }
1450 /* get PCI Express Capability Structure register group size */
1451 static int xen_pt_pcie_size_init(XenPCIPassthroughState *s,
1452 const XenPTRegGroupInfo *grp_reg,
1453 uint32_t base_offset, uint8_t *size)
1454 {
1455 PCIDevice *d = &s->dev;
1456 uint8_t version = get_capability_version(s, base_offset);
1457 uint8_t type = get_device_type(s, base_offset);
1458 uint8_t pcie_size = 0;
1459
1460
1461 /* calculate size depend on capability version and device/port type */
1462 /* in case of PCI Express Base Specification Rev 1.x */
1463 if (version == 1) {
1464 /* The PCI Express Capabilities, Device Capabilities, and Device
1465 * Status/Control registers are required for all PCI Express devices.
1466 * The Link Capabilities and Link Status/Control are required for all
1467 * Endpoints that are not Root Complex Integrated Endpoints. Endpoints
1468 * are not required to implement registers other than those listed
1469 * above and terminate the capability structure.
1470 */
1471 switch (type) {
1472 case PCI_EXP_TYPE_ENDPOINT:
1473 case PCI_EXP_TYPE_LEG_END:
1474 pcie_size = 0x14;
1475 break;
1476 case PCI_EXP_TYPE_RC_END:
1477 /* has no link */
1478 pcie_size = 0x0C;
1479 break;
1480 /* only EndPoint passthrough is supported */
1481 case PCI_EXP_TYPE_ROOT_PORT:
1482 case PCI_EXP_TYPE_UPSTREAM:
1483 case PCI_EXP_TYPE_DOWNSTREAM:
1484 case PCI_EXP_TYPE_PCI_BRIDGE:
1485 case PCI_EXP_TYPE_PCIE_BRIDGE:
1486 case PCI_EXP_TYPE_RC_EC:
1487 default:
1488 XEN_PT_ERR(d, "Unsupported device/port type %#x.\n", type);
1489 return -1;
1490 }
1491 }
1492 /* in case of PCI Express Base Specification Rev 2.0 */
1493 else if (version == 2) {
1494 switch (type) {
1495 case PCI_EXP_TYPE_ENDPOINT:
1496 case PCI_EXP_TYPE_LEG_END:
1497 case PCI_EXP_TYPE_RC_END:
1498 /* For Functions that do not implement the registers,
1499 * these spaces must be hardwired to 0b.
1500 */
1501 pcie_size = 0x3C;
1502 break;
1503 /* only EndPoint passthrough is supported */
1504 case PCI_EXP_TYPE_ROOT_PORT:
1505 case PCI_EXP_TYPE_UPSTREAM:
1506 case PCI_EXP_TYPE_DOWNSTREAM:
1507 case PCI_EXP_TYPE_PCI_BRIDGE:
1508 case PCI_EXP_TYPE_PCIE_BRIDGE:
1509 case PCI_EXP_TYPE_RC_EC:
1510 default:
1511 XEN_PT_ERR(d, "Unsupported device/port type %#x.\n", type);
1512 return -1;
1513 }
1514 } else {
1515 XEN_PT_ERR(d, "Unsupported capability version %#x.\n", version);
1516 return -1;
1517 }
1518
1519 *size = pcie_size;
1520 return 0;
1521 }
1522 /* get MSI Capability Structure register group size */
1523 static int xen_pt_msi_size_init(XenPCIPassthroughState *s,
1524 const XenPTRegGroupInfo *grp_reg,
1525 uint32_t base_offset, uint8_t *size)
1526 {
1527 PCIDevice *d = &s->dev;
1528 uint16_t msg_ctrl = 0;
1529 uint8_t msi_size = 0xa;
1530
1531 msg_ctrl = pci_get_word(d->config + (base_offset + PCI_MSI_FLAGS));
1532
1533 /* check if 64-bit address is capable of per-vector masking */
1534 if (msg_ctrl & PCI_MSI_FLAGS_64BIT) {
1535 msi_size += 4;
1536 }
1537 if (msg_ctrl & PCI_MSI_FLAGS_MASKBIT) {
1538 msi_size += 10;
1539 }
1540
1541 s->msi = g_new0(XenPTMSI, 1);
1542 s->msi->pirq = XEN_PT_UNASSIGNED_PIRQ;
1543
1544 *size = msi_size;
1545 return 0;
1546 }
1547 /* get MSI-X Capability Structure register group size */
1548 static int xen_pt_msix_size_init(XenPCIPassthroughState *s,
1549 const XenPTRegGroupInfo *grp_reg,
1550 uint32_t base_offset, uint8_t *size)
1551 {
1552 int rc = 0;
1553
1554 rc = xen_pt_msix_init(s, base_offset);
1555
1556 if (rc < 0) {
1557 XEN_PT_ERR(&s->dev, "Internal error: Invalid xen_pt_msix_init.\n");
1558 return rc;
1559 }
1560
1561 *size = grp_reg->grp_size;
1562 return 0;
1563 }
1564
1565
1566 static const XenPTRegGroupInfo xen_pt_emu_reg_grps[] = {
1567 /* Header Type0 reg group */
1568 {
1569 .grp_id = 0xFF,
1570 .grp_type = XEN_PT_GRP_TYPE_EMU,
1571 .grp_size = 0x40,
1572 .size_init = xen_pt_reg_grp_size_init,
1573 .emu_regs = xen_pt_emu_reg_header0,
1574 },
1575 /* PCI PowerManagement Capability reg group */
1576 {
1577 .grp_id = PCI_CAP_ID_PM,
1578 .grp_type = XEN_PT_GRP_TYPE_EMU,
1579 .grp_size = PCI_PM_SIZEOF,
1580 .size_init = xen_pt_reg_grp_size_init,
1581 .emu_regs = xen_pt_emu_reg_pm,
1582 },
1583 /* AGP Capability Structure reg group */
1584 {
1585 .grp_id = PCI_CAP_ID_AGP,
1586 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1587 .grp_size = 0x30,
1588 .size_init = xen_pt_reg_grp_size_init,
1589 },
1590 /* Vital Product Data Capability Structure reg group */
1591 {
1592 .grp_id = PCI_CAP_ID_VPD,
1593 .grp_type = XEN_PT_GRP_TYPE_EMU,
1594 .grp_size = 0x08,
1595 .size_init = xen_pt_reg_grp_size_init,
1596 .emu_regs = xen_pt_emu_reg_vpd,
1597 },
1598 /* Slot Identification reg group */
1599 {
1600 .grp_id = PCI_CAP_ID_SLOTID,
1601 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1602 .grp_size = 0x04,
1603 .size_init = xen_pt_reg_grp_size_init,
1604 },
1605 /* MSI Capability Structure reg group */
1606 {
1607 .grp_id = PCI_CAP_ID_MSI,
1608 .grp_type = XEN_PT_GRP_TYPE_EMU,
1609 .grp_size = 0xFF,
1610 .size_init = xen_pt_msi_size_init,
1611 .emu_regs = xen_pt_emu_reg_msi,
1612 },
1613 /* PCI-X Capabilities List Item reg group */
1614 {
1615 .grp_id = PCI_CAP_ID_PCIX,
1616 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1617 .grp_size = 0x18,
1618 .size_init = xen_pt_reg_grp_size_init,
1619 },
1620 /* Vendor Specific Capability Structure reg group */
1621 {
1622 .grp_id = PCI_CAP_ID_VNDR,
1623 .grp_type = XEN_PT_GRP_TYPE_EMU,
1624 .grp_size = 0xFF,
1625 .size_init = xen_pt_vendor_size_init,
1626 .emu_regs = xen_pt_emu_reg_vendor,
1627 },
1628 /* SHPC Capability List Item reg group */
1629 {
1630 .grp_id = PCI_CAP_ID_SHPC,
1631 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1632 .grp_size = 0x08,
1633 .size_init = xen_pt_reg_grp_size_init,
1634 },
1635 /* Subsystem ID and Subsystem Vendor ID Capability List Item reg group */
1636 {
1637 .grp_id = PCI_CAP_ID_SSVID,
1638 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1639 .grp_size = 0x08,
1640 .size_init = xen_pt_reg_grp_size_init,
1641 },
1642 /* AGP 8x Capability Structure reg group */
1643 {
1644 .grp_id = PCI_CAP_ID_AGP3,
1645 .grp_type = XEN_PT_GRP_TYPE_HARDWIRED,
1646 .grp_size = 0x30,
1647 .size_init = xen_pt_reg_grp_size_init,
1648 },
1649 /* PCI Express Capability Structure reg group */
1650 {
1651 .grp_id = PCI_CAP_ID_EXP,
1652 .grp_type = XEN_PT_GRP_TYPE_EMU,
1653 .grp_size = 0xFF,
1654 .size_init = xen_pt_pcie_size_init,
1655 .emu_regs = xen_pt_emu_reg_pcie,
1656 },
1657 /* MSI-X Capability Structure reg group */
1658 {
1659 .grp_id = PCI_CAP_ID_MSIX,
1660 .grp_type = XEN_PT_GRP_TYPE_EMU,
1661 .grp_size = 0x0C,
1662 .size_init = xen_pt_msix_size_init,
1663 .emu_regs = xen_pt_emu_reg_msix,
1664 },
1665 {
1666 .grp_size = 0,
1667 },
1668 };
1669
1670 /* initialize Capabilities Pointer or Next Pointer register */
1671 static int xen_pt_ptr_reg_init(XenPCIPassthroughState *s,
1672 XenPTRegInfo *reg, uint32_t real_offset,
1673 uint32_t *data)
1674 {
1675 int i;
1676 uint8_t *config = s->dev.config;
1677 uint32_t reg_field = pci_get_byte(config + real_offset);
1678 uint8_t cap_id = 0;
1679
1680 /* find capability offset */
1681 while (reg_field) {
1682 for (i = 0; xen_pt_emu_reg_grps[i].grp_size != 0; i++) {
1683 if (xen_pt_hide_dev_cap(&s->real_device,
1684 xen_pt_emu_reg_grps[i].grp_id)) {
1685 continue;
1686 }
1687
1688 cap_id = pci_get_byte(config + reg_field + PCI_CAP_LIST_ID);
1689 if (xen_pt_emu_reg_grps[i].grp_id == cap_id) {
1690 if (xen_pt_emu_reg_grps[i].grp_type == XEN_PT_GRP_TYPE_EMU) {
1691 goto out;
1692 }
1693 /* ignore the 0 hardwired capability, find next one */
1694 break;
1695 }
1696 }
1697
1698 /* next capability */
1699 reg_field = pci_get_byte(config + reg_field + PCI_CAP_LIST_NEXT);
1700 }
1701
1702 out:
1703 *data = reg_field;
1704 return 0;
1705 }
1706
1707
1708 /*************
1709 * Main
1710 */
1711
1712 static uint8_t find_cap_offset(XenPCIPassthroughState *s, uint8_t cap)
1713 {
1714 uint8_t id;
1715 unsigned max_cap = PCI_CAP_MAX;
1716 uint8_t pos = PCI_CAPABILITY_LIST;
1717 uint8_t status = 0;
1718
1719 if (xen_host_pci_get_byte(&s->real_device, PCI_STATUS, &status)) {
1720 return 0;
1721 }
1722 if ((status & PCI_STATUS_CAP_LIST) == 0) {
1723 return 0;
1724 }
1725
1726 while (max_cap--) {
1727 if (xen_host_pci_get_byte(&s->real_device, pos, &pos)) {
1728 break;
1729 }
1730 if (pos < PCI_CONFIG_HEADER_SIZE) {
1731 break;
1732 }
1733
1734 pos &= ~3;
1735 if (xen_host_pci_get_byte(&s->real_device,
1736 pos + PCI_CAP_LIST_ID, &id)) {
1737 break;
1738 }
1739
1740 if (id == 0xff) {
1741 break;
1742 }
1743 if (id == cap) {
1744 return pos;
1745 }
1746
1747 pos += PCI_CAP_LIST_NEXT;
1748 }
1749 return 0;
1750 }
1751
1752 static int xen_pt_config_reg_init(XenPCIPassthroughState *s,
1753 XenPTRegGroup *reg_grp, XenPTRegInfo *reg)
1754 {
1755 XenPTReg *reg_entry;
1756 uint32_t data = 0;
1757 int rc = 0;
1758
1759 reg_entry = g_new0(XenPTReg, 1);
1760 reg_entry->reg = reg;
1761
1762 if (reg->init) {
1763 /* initialize emulate register */
1764 rc = reg->init(s, reg_entry->reg,
1765 reg_grp->base_offset + reg->offset, &data);
1766 if (rc < 0) {
1767 free(reg_entry);
1768 return rc;
1769 }
1770 if (data == XEN_PT_INVALID_REG) {
1771 /* free unused BAR register entry */
1772 free(reg_entry);
1773 return 0;
1774 }
1775 /* set register value */
1776 reg_entry->data = data;
1777 }
1778 /* list add register entry */
1779 QLIST_INSERT_HEAD(&reg_grp->reg_tbl_list, reg_entry, entries);
1780
1781 return 0;
1782 }
1783
1784 int xen_pt_config_init(XenPCIPassthroughState *s)
1785 {
1786 int i, rc;
1787
1788 QLIST_INIT(&s->reg_grps);
1789
1790 for (i = 0; xen_pt_emu_reg_grps[i].grp_size != 0; i++) {
1791 uint32_t reg_grp_offset = 0;
1792 XenPTRegGroup *reg_grp_entry = NULL;
1793
1794 if (xen_pt_emu_reg_grps[i].grp_id != 0xFF) {
1795 if (xen_pt_hide_dev_cap(&s->real_device,
1796 xen_pt_emu_reg_grps[i].grp_id)) {
1797 continue;
1798 }
1799
1800 reg_grp_offset = find_cap_offset(s, xen_pt_emu_reg_grps[i].grp_id);
1801
1802 if (!reg_grp_offset) {
1803 continue;
1804 }
1805 }
1806
1807 reg_grp_entry = g_new0(XenPTRegGroup, 1);
1808 QLIST_INIT(&reg_grp_entry->reg_tbl_list);
1809 QLIST_INSERT_HEAD(&s->reg_grps, reg_grp_entry, entries);
1810
1811 reg_grp_entry->base_offset = reg_grp_offset;
1812 reg_grp_entry->reg_grp = xen_pt_emu_reg_grps + i;
1813 if (xen_pt_emu_reg_grps[i].size_init) {
1814 /* get register group size */
1815 rc = xen_pt_emu_reg_grps[i].size_init(s, reg_grp_entry->reg_grp,
1816 reg_grp_offset,
1817 &reg_grp_entry->size);
1818 if (rc < 0) {
1819 xen_pt_config_delete(s);
1820 return rc;
1821 }
1822 }
1823
1824 if (xen_pt_emu_reg_grps[i].grp_type == XEN_PT_GRP_TYPE_EMU) {
1825 if (xen_pt_emu_reg_grps[i].emu_regs) {
1826 int j = 0;
1827 XenPTRegInfo *regs = xen_pt_emu_reg_grps[i].emu_regs;
1828 /* initialize capability register */
1829 for (j = 0; regs->size != 0; j++, regs++) {
1830 /* initialize capability register */
1831 rc = xen_pt_config_reg_init(s, reg_grp_entry, regs);
1832 if (rc < 0) {
1833 xen_pt_config_delete(s);
1834 return rc;
1835 }
1836 }
1837 }
1838 }
1839 }
1840
1841 return 0;
1842 }
1843
1844 /* delete all emulate register */
1845 void xen_pt_config_delete(XenPCIPassthroughState *s)
1846 {
1847 struct XenPTRegGroup *reg_group, *next_grp;
1848 struct XenPTReg *reg, *next_reg;
1849
1850 /* free MSI/MSI-X info table */
1851 if (s->msix) {
1852 xen_pt_msix_delete(s);
1853 }
1854 if (s->msi) {
1855 g_free(s->msi);
1856 }
1857
1858 /* free all register group entry */
1859 QLIST_FOREACH_SAFE(reg_group, &s->reg_grps, entries, next_grp) {
1860 /* free all register entry */
1861 QLIST_FOREACH_SAFE(reg, &reg_group->reg_tbl_list, entries, next_reg) {
1862 QLIST_REMOVE(reg, entries);
1863 g_free(reg);
1864 }
1865
1866 QLIST_REMOVE(reg_group, entries);
1867 g_free(reg_group);
1868 }
1869 }
QEMU mirror