VirtualBox

source: vbox/trunk/src/VBox/Devices/Bus/MsiCommon.cpp@ 66969

Last change on this file since 66969 was 66270, checked in by vboxsync, 8 years ago

Devices/Bus/MsiCommon.cpp: support devices with MSI, but without vector masking
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.7 KB
Line 
1/* $Id: MsiCommon.cpp 66270 2017-03-27 18:33:42Z vboxsync $ */
2/** @file
3 * MSI support routines
4 *
5 * @todo Straighten up this file!!
6 */
7
8/*
9 * Copyright (C) 2010-2017 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19#define LOG_GROUP LOG_GROUP_DEV_PCI
20#define PDMPCIDEV_INCLUDE_PRIVATE /* Hack to get pdmpcidevint.h included at the right point. */
21#include <VBox/pci.h>
22#include <VBox/msi.h>
23#include <VBox/vmm/pdmdev.h>
24#include <VBox/log.h>
25
26#include "MsiCommon.h"
27#include "PciInline.h"
28
29DECLINLINE(uint16_t) msiGetMessageControl(PPDMPCIDEV pDev)
30{
31 uint32_t idxMessageControl = pDev->Int.s.u8MsiCapOffset + VBOX_MSI_CAP_MESSAGE_CONTROL;
32#ifdef IN_RING3
33 if (pciDevIsPassthrough(pDev)) {
34 return pDev->Int.s.pfnConfigRead(pDev->Int.s.CTX_SUFF(pDevIns), pDev, idxMessageControl, 2);
35 }
36#endif
37 return PCIDevGetWord(pDev, idxMessageControl);
38}
39
40DECLINLINE(bool) msiIs64Bit(PPDMPCIDEV pDev)
41{
42 return pciDevIsMsi64Capable(pDev);
43}
44
45/** @todo r=klaus This design assumes that the config space cache is always
46 * up to date, which is a wrong assumption for the "emulate passthrough" case
47 * where only the callbacks give the correct data. */
48DECLINLINE(uint32_t*) msiGetMaskBits(PPDMPCIDEV pDev)
49{
50 uint8_t iOff = msiIs64Bit(pDev) ? VBOX_MSI_CAP_MASK_BITS_64 : VBOX_MSI_CAP_MASK_BITS_32;
51 /* devices may have no masked/pending support */
52 if (iOff >= pDev->Int.s.u8MsiCapSize)
53 return NULL;
54 iOff += pDev->Int.s.u8MsiCapOffset;
55 return (uint32_t*)(pDev->abConfig + iOff);
56}
57
58/** @todo r=klaus This design assumes that the config space cache is always
59 * up to date, which is a wrong assumption for the "emulate passthrough" case
60 * where only the callbacks give the correct data. */
61DECLINLINE(uint32_t*) msiGetPendingBits(PPDMPCIDEV pDev)
62{
63 uint8_t iOff = msiIs64Bit(pDev) ? VBOX_MSI_CAP_PENDING_BITS_64 : VBOX_MSI_CAP_PENDING_BITS_32;
64 /* devices may have no masked/pending support */
65 if (iOff >= pDev->Int.s.u8MsiCapSize)
66 return NULL;
67 iOff += pDev->Int.s.u8MsiCapOffset;
68 return (uint32_t*)(pDev->abConfig + iOff);
69}
70
71DECLINLINE(bool) msiIsEnabled(PPDMPCIDEV pDev)
72{
73 return (msiGetMessageControl(pDev) & VBOX_PCI_MSI_FLAGS_ENABLE) != 0;
74}
75
76DECLINLINE(uint8_t) msiGetMme(PPDMPCIDEV pDev)
77{
78 return (msiGetMessageControl(pDev) & VBOX_PCI_MSI_FLAGS_QSIZE) >> 4;
79}
80
81DECLINLINE(RTGCPHYS) msiGetMsiAddress(PPDMPCIDEV pDev)
82{
83 if (msiIs64Bit(pDev))
84 {
85 uint32_t lo = PCIDevGetDWord(pDev, pDev->Int.s.u8MsiCapOffset + VBOX_MSI_CAP_MESSAGE_ADDRESS_LO);
86 uint32_t hi = PCIDevGetDWord(pDev, pDev->Int.s.u8MsiCapOffset + VBOX_MSI_CAP_MESSAGE_ADDRESS_HI);
87 return RT_MAKE_U64(lo, hi);
88 }
89 else
90 {
91 return PCIDevGetDWord(pDev, pDev->Int.s.u8MsiCapOffset + VBOX_MSI_CAP_MESSAGE_ADDRESS_32);
92 }
93}
94
95DECLINLINE(uint32_t) msiGetMsiData(PPDMPCIDEV pDev, int32_t iVector)
96{
97 int16_t iOff = msiIs64Bit(pDev) ? VBOX_MSI_CAP_MESSAGE_DATA_64 : VBOX_MSI_CAP_MESSAGE_DATA_32;
98 uint16_t lo = PCIDevGetWord(pDev, pDev->Int.s.u8MsiCapOffset + iOff);
99
100 // vector encoding into lower bits of message data
101 uint8_t bits = msiGetMme(pDev);
102 uint16_t uMask = ((1 << bits) - 1);
103 lo &= ~uMask;
104 lo |= iVector & uMask;
105
106 return RT_MAKE_U32(lo, 0);
107}
108
109#ifdef IN_RING3
110
111DECLINLINE(bool) msiBitJustCleared(uint32_t uOldValue,
112 uint32_t uNewValue,
113 uint32_t uMask)
114{
115 return (!!(uOldValue & uMask) && !(uNewValue & uMask));
116}
117
118DECLINLINE(bool) msiBitJustSet(uint32_t uOldValue,
119 uint32_t uNewValue,
120 uint32_t uMask)
121{
122 return (!(uOldValue & uMask) && !!(uNewValue & uMask));
123}
124
125void MsiPciConfigWrite(PPDMDEVINS pDevIns, PCPDMPCIHLP pPciHlp, PPDMPCIDEV pDev,
126 uint32_t u32Address, uint32_t val, unsigned len)
127{
128 int32_t iOff = u32Address - pDev->Int.s.u8MsiCapOffset;
129 Assert(iOff >= 0 && (pciDevIsMsiCapable(pDev) && iOff < pDev->Int.s.u8MsiCapSize));
130
131 Log2(("MsiPciConfigWrite: %d <- %x (%d)\n", iOff, val, len));
132
133 uint32_t uAddr = u32Address;
134 bool f64Bit = msiIs64Bit(pDev);
135
136 for (uint32_t i = 0; i < len; i++)
137 {
138 uint32_t reg = i + iOff;
139 uint8_t u8Val = (uint8_t)val;
140 switch (reg)
141 {
142 case 0: /* Capability ID, ro */
143 case 1: /* Next pointer, ro */
144 break;
145 case VBOX_MSI_CAP_MESSAGE_CONTROL:
146 /* don't change read-only bits: 1-3,7 */
147 u8Val &= UINT8_C(~0x8e);
148 pDev->abConfig[uAddr] = u8Val | (pDev->abConfig[uAddr] & UINT8_C(0x8e));
149 break;
150 case VBOX_MSI_CAP_MESSAGE_CONTROL + 1:
151 /* don't change read-only bit 8, and reserved 9-15 */
152 break;
153 default:
154 if (pDev->abConfig[uAddr] != u8Val)
155 {
156 int32_t maskUpdated = -1;
157
158 /* If we're enabling masked vector, and have pending messages
159 for this vector, we have to send this message now */
160 if ( !f64Bit
161 && (reg >= VBOX_MSI_CAP_MASK_BITS_32)
162 && (reg < VBOX_MSI_CAP_MASK_BITS_32 + 4)
163 )
164 {
165 maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_32;
166 }
167 if ( f64Bit
168 && (reg >= VBOX_MSI_CAP_MASK_BITS_64)
169 && (reg < VBOX_MSI_CAP_MASK_BITS_64 + 4)
170 )
171 {
172 maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_64;
173 }
174
175 if (maskUpdated != -1 && msiIsEnabled(pDev))
176 {
177 uint32_t* puPending = msiGetPendingBits(pDev);
178 for (int iBitNum = 0; iBitNum < 8; iBitNum++)
179 {
180 int32_t iBit = 1 << iBitNum;
181 uint32_t uVector = maskUpdated*8 + iBitNum;
182
183 if (msiBitJustCleared(pDev->abConfig[uAddr], u8Val, iBit))
184 {
185 Log(("msi: mask updated bit %d@%x (%d)\n", iBitNum, uAddr, maskUpdated));
186
187 /* To ensure that we're no longer masked */
188 pDev->abConfig[uAddr] &= ~iBit;
189 if ((*puPending & (1 << uVector)) != 0)
190 {
191 Log(("msi: notify earlier masked pending vector: %d\n", uVector));
192 MsiNotify(pDevIns, pPciHlp, pDev, uVector, PDM_IRQ_LEVEL_HIGH, 0 /*uTagSrc*/);
193 }
194 }
195 if (msiBitJustSet(pDev->abConfig[uAddr], u8Val, iBit))
196 {
197 Log(("msi: mask vector: %d\n", uVector));
198 }
199 }
200 }
201
202 pDev->abConfig[uAddr] = u8Val;
203 }
204 }
205 uAddr++;
206 val >>= 8;
207 }
208}
209
210int MsiInit(PPDMPCIDEV pDev, PPDMMSIREG pMsiReg)
211{
212 if (pMsiReg->cMsiVectors == 0)
213 return VINF_SUCCESS;
214
215 /* XXX: done in pcirawAnalyzePciCaps() */
216 if (pciDevIsPassthrough(pDev))
217 return VINF_SUCCESS;
218
219 uint16_t cVectors = pMsiReg->cMsiVectors;
220 uint8_t iCapOffset = pMsiReg->iMsiCapOffset;
221 uint8_t iNextOffset = pMsiReg->iMsiNextOffset;
222 bool f64bit = pMsiReg->fMsi64bit;
223 bool fNoMasking = pMsiReg->fMsiNoMasking;
224 uint16_t iFlags = 0;
225
226 Assert(iCapOffset != 0 && iCapOffset < 0xff && iNextOffset < 0xff);
227
228 if (!fNoMasking)
229 {
230 int iMmc;
231
232 /* Compute multiple-message capable bitfield */
233 for (iMmc = 0; iMmc < 6; iMmc++)
234 {
235 if ((1 << iMmc) >= cVectors)
236 break;
237 }
238
239 if ((cVectors > VBOX_MSI_MAX_ENTRIES) || (1 << iMmc) < cVectors)
240 return VERR_TOO_MUCH_DATA;
241
242 /* We support per-vector masking */
243 iFlags |= VBOX_PCI_MSI_FLAGS_MASKBIT;
244 /* How many vectors we're capable of */
245 iFlags |= iMmc;
246 }
247 else
248 AssertReturn(cVectors == 1, VERR_TOO_MUCH_DATA);
249
250 if (f64bit)
251 iFlags |= VBOX_PCI_MSI_FLAGS_64BIT;
252
253 pDev->Int.s.u8MsiCapOffset = iCapOffset;
254 pDev->Int.s.u8MsiCapSize = f64bit ? VBOX_MSI_CAP_SIZE_64 : VBOX_MSI_CAP_SIZE_32;
255
256 PCIDevSetByte(pDev, iCapOffset + 0, VBOX_PCI_CAP_ID_MSI);
257 PCIDevSetByte(pDev, iCapOffset + 1, iNextOffset); /* next */
258 PCIDevSetWord(pDev, iCapOffset + VBOX_MSI_CAP_MESSAGE_CONTROL, iFlags);
259
260 if (!fNoMasking)
261 {
262 *msiGetMaskBits(pDev) = 0;
263 *msiGetPendingBits(pDev) = 0;
264 }
265
266 pciDevSetMsiCapable(pDev);
267 if (f64bit)
268 pciDevSetMsi64Capable(pDev);
269
270 return VINF_SUCCESS;
271}
272
273#endif /* IN_RING3 */
274
275
276bool MsiIsEnabled(PPDMPCIDEV pDev)
277{
278 return pciDevIsMsiCapable(pDev) && msiIsEnabled(pDev);
279}
280
281void MsiNotify(PPDMDEVINS pDevIns, PCPDMPCIHLP pPciHlp, PPDMPCIDEV pDev, int iVector, int iLevel, uint32_t uTagSrc)
282{
283 AssertMsg(msiIsEnabled(pDev), ("Must be enabled to use that"));
284
285 uint32_t uMask;
286 uint32_t *puPending = msiGetPendingBits(pDev);
287 if (puPending)
288 {
289 uint32_t *puMask = msiGetMaskBits(pDev);
290 AssertPtr(puMask);
291 uMask = *puMask;
292 LogFlow(("MsiNotify: %d pending=%x mask=%x\n", iVector, *puPending, uMask));
293 }
294 else
295 {
296 uMask = 0;
297 LogFlow(("MsiNotify: %d\n", iVector));
298 }
299
300 /* We only trigger MSI on level up */
301 if ((iLevel & PDM_IRQ_LEVEL_HIGH) == 0)
302 {
303 /** @todo maybe clear pending interrupts on level down? */
304#if 0
305 if (puPending)
306 {
307 *puPending &= ~(1<<iVector);
308 LogFlow(("msi: clear pending %d, now %x\n", iVector, *puPending));
309 }
310#endif
311 return;
312 }
313
314 if ((uMask & (1<<iVector)) != 0)
315 {
316 *puPending |= (1<<iVector);
317 LogFlow(("msi: %d is masked, mark pending, now %x\n", iVector, *puPending));
318 return;
319 }
320
321 RTGCPHYS GCAddr = msiGetMsiAddress(pDev);
322 uint32_t u32Value = msiGetMsiData(pDev, iVector);
323
324 if (puPending)
325 *puPending &= ~(1<<iVector);
326
327 Assert(pPciHlp->pfnIoApicSendMsi != NULL);
328 pPciHlp->pfnIoApicSendMsi(pDevIns, GCAddr, u32Value, uTagSrc);
329}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette