Changeset 81909 in vbox
- Timestamp:
- Nov 17, 2019 6:23:56 PM (5 years ago)
- svn:sync-xref-src-repo-rev:
- 134706
- Location:
- trunk
- Files:
-
- 7 edited
-
include/VBox/vmm/pdmdev.h (modified) (16 diffs)
-
src/VBox/Devices/PC/DevPIC.cpp (modified) (21 diffs)
-
src/VBox/VMM/VMMAll/APICAll.cpp (modified) (2 diffs)
-
src/VBox/VMM/VMMR0/PDMR0Device.cpp (modified) (8 diffs)
-
src/VBox/VMM/VMMR3/PDMDevHlp.cpp (modified) (1 diff)
-
src/VBox/VMM/VMMR3/PDMDevMiscHlp.cpp (modified) (5 diffs)
-
src/VBox/VMM/include/PDMInternal.h (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/VBox/vmm/pdmdev.h
r81853 r81909 1254 1254 1255 1255 /** 1256 * Programmable Interrupt Controller registration structure .1256 * Programmable Interrupt Controller registration structure (all contexts). 1257 1257 */ 1258 1258 typedef struct PDMPICREG … … 1270 1270 * @remarks Caller enters the PDM critical section. 1271 1271 */ 1272 DECL R3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc));1272 DECLCALLBACKMEMBER(void, pfnSetIrq)(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc); 1273 1273 1274 1274 /** … … 1280 1280 * @remarks Caller enters the PDM critical section. 1281 1281 */ 1282 DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns, uint32_t *puTagSrc)); 1283 1284 /** The name of the RC SetIrq entry point. */ 1285 const char *pszSetIrqRC; 1286 /** The name of the RC GetInterrupt entry point. */ 1287 const char *pszGetInterruptRC; 1288 1289 /** The name of the R0 SetIrq entry point. */ 1290 const char *pszSetIrqR0; 1291 /** The name of the R0 GetInterrupt entry point. */ 1292 const char *pszGetInterruptR0; 1282 DECLCALLBACKMEMBER(int, pfnGetInterrupt)(PPDMDEVINS pDevIns, uint32_t *puTagSrc); 1283 1284 /** Just a safety precaution. */ 1285 uint32_t u32TheEnd; 1293 1286 } PDMPICREG; 1294 1287 /** Pointer to a PIC registration structure. */ … … 1296 1289 1297 1290 /** Current PDMPICREG version number. */ 1298 #define PDM_PICREG_VERSION PDM_VERSION_MAKE(0xfffa, 2, 0)1299 1300 /** 1301 * PIC RC helpers.1302 */ 1303 typedef struct PDMPICHLP RC1304 { 1305 /** Structure version. PDM_PICHLP RC_VERSION defines the current version. */1291 #define PDM_PICREG_VERSION PDM_VERSION_MAKE(0xfffa, 3, 0) 1292 1293 /** 1294 * PIC helpers, same in all contexts. 1295 */ 1296 typedef struct PDMPICHLP 1297 { 1298 /** Structure version. PDM_PICHLP_VERSION defines the current version. */ 1306 1299 uint32_t u32Version; 1307 1300 … … 1311 1304 * @param pDevIns Device instance of the PIC. 1312 1305 */ 1313 DECL RCCALLBACKMEMBER(void, pfnSetInterruptFF,(PPDMDEVINS pDevIns));1306 DECLCALLBACKMEMBER(void, pfnSetInterruptFF)(PPDMDEVINS pDevIns); 1314 1307 1315 1308 /** … … 1318 1311 * @param pDevIns Device instance of the PIC. 1319 1312 */ 1320 DECL RCCALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns));1313 DECLCALLBACKMEMBER(void, pfnClearInterruptFF)(PPDMDEVINS pDevIns); 1321 1314 1322 1315 /** … … 1328 1321 * @param rc What to return if we fail to acquire the lock. 1329 1322 */ 1330 DECL RCCALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc));1323 DECLCALLBACKMEMBER(int, pfnLock)(PPDMDEVINS pDevIns, int rc); 1331 1324 1332 1325 /** … … 1335 1328 * @param pDevIns The PIC device instance. 1336 1329 */ 1337 DECL RCCALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns));1330 DECLCALLBACKMEMBER(void, pfnUnlock)(PPDMDEVINS pDevIns); 1338 1331 1339 1332 /** Just a safety precaution. */ 1340 1333 uint32_t u32TheEnd; 1341 } PDMPICHLPRC; 1342 1343 /** Pointer to PIC RC helpers. */ 1344 typedef RCPTRTYPE(PDMPICHLPRC *) PPDMPICHLPRC; 1345 /** Pointer to const PIC RC helpers. */ 1346 typedef RCPTRTYPE(const PDMPICHLPRC *) PCPDMPICHLPRC; 1347 1348 /** Current PDMPICHLPRC version number. */ 1349 #define PDM_PICHLPRC_VERSION PDM_VERSION_MAKE(0xfff9, 2, 0) 1350 1351 1352 /** 1353 * PIC R0 helpers. 1354 */ 1355 typedef struct PDMPICHLPR0 1356 { 1357 /** Structure version. PDM_PICHLPR0_VERSION defines the current version. */ 1358 uint32_t u32Version; 1359 1360 /** 1361 * Set the interrupt force action flag. 1362 * 1363 * @param pDevIns Device instance of the PIC. 1364 */ 1365 DECLR0CALLBACKMEMBER(void, pfnSetInterruptFF,(PPDMDEVINS pDevIns)); 1366 1367 /** 1368 * Clear the interrupt force action flag. 1369 * 1370 * @param pDevIns Device instance of the PIC. 1371 */ 1372 DECLR0CALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns)); 1373 1374 /** 1375 * Acquires the PDM lock. 1376 * 1377 * @returns VINF_SUCCESS on success. 1378 * @returns rc if we failed to acquire the lock. 1379 * @param pDevIns The PIC device instance. 1380 * @param rc What to return if we fail to acquire the lock. 1381 */ 1382 DECLR0CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc)); 1383 1384 /** 1385 * Releases the PDM lock. 1386 * 1387 * @param pDevIns The PCI device instance. 1388 */ 1389 DECLR0CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns)); 1390 1391 /** Just a safety precaution. */ 1392 uint32_t u32TheEnd; 1393 } PDMPICHLPR0; 1394 1395 /** Pointer to PIC R0 helpers. */ 1396 typedef R0PTRTYPE(PDMPICHLPR0 *) PPDMPICHLPR0; 1397 /** Pointer to const PIC R0 helpers. */ 1398 typedef R0PTRTYPE(const PDMPICHLPR0 *) PCPDMPICHLPR0; 1399 1400 /** Current PDMPICHLPR0 version number. */ 1401 #define PDM_PICHLPR0_VERSION PDM_VERSION_MAKE(0xfff8, 1, 0) 1402 1403 /** 1404 * PIC R3 helpers. 1405 */ 1406 typedef struct PDMPICHLPR3 1407 { 1408 /** Structure version. PDM_PICHLP_VERSION defines the current version. */ 1409 uint32_t u32Version; 1410 1411 /** 1412 * Set the interrupt force action flag. 1413 * 1414 * @param pDevIns Device instance of the PIC. 1415 */ 1416 DECLR3CALLBACKMEMBER(void, pfnSetInterruptFF,(PPDMDEVINS pDevIns)); 1417 1418 /** 1419 * Clear the interrupt force action flag. 1420 * 1421 * @param pDevIns Device instance of the PIC. 1422 */ 1423 DECLR3CALLBACKMEMBER(void, pfnClearInterruptFF,(PPDMDEVINS pDevIns)); 1424 1425 /** 1426 * Acquires the PDM lock. 1427 * 1428 * @returns VINF_SUCCESS on success. 1429 * @returns Fatal error on failure. 1430 * @param pDevIns The PIC device instance. 1431 * @param rc Dummy for making the interface identical to the RC and R0 versions. 1432 */ 1433 DECLR3CALLBACKMEMBER(int, pfnLock,(PPDMDEVINS pDevIns, int rc)); 1434 1435 /** 1436 * Releases the PDM lock. 1437 * 1438 * @param pDevIns The PIC device instance. 1439 */ 1440 DECLR3CALLBACKMEMBER(void, pfnUnlock,(PPDMDEVINS pDevIns)); 1441 1442 /** 1443 * Gets the address of the RC PIC helpers. 1444 * 1445 * This should be called at both construction and relocation time 1446 * to obtain the correct address of the RC helpers. 1447 * 1448 * @returns RC pointer to the PIC helpers. 1449 * @param pDevIns Device instance of the PIC. 1450 */ 1451 DECLR3CALLBACKMEMBER(PCPDMPICHLPRC, pfnGetRCHelpers,(PPDMDEVINS pDevIns)); 1452 1453 /** 1454 * Gets the address of the R0 PIC helpers. 1455 * 1456 * This should be called at both construction and relocation time 1457 * to obtain the correct address of the R0 helpers. 1458 * 1459 * @returns R0 pointer to the PIC helpers. 1460 * @param pDevIns Device instance of the PIC. 1461 */ 1462 DECLR3CALLBACKMEMBER(PCPDMPICHLPR0, pfnGetR0Helpers,(PPDMDEVINS pDevIns)); 1463 1464 /** Just a safety precaution. */ 1465 uint32_t u32TheEnd; 1466 } PDMPICHLPR3; 1467 1468 /** Pointer to PIC R3 helpers. */ 1469 typedef R3PTRTYPE(PDMPICHLPR3 *) PPDMPICHLPR3; 1470 /** Pointer to const PIC R3 helpers. */ 1471 typedef R3PTRTYPE(const PDMPICHLPR3 *) PCPDMPICHLPR3; 1472 1473 /** Current PDMPICHLPR3 version number. */ 1474 #define PDM_PICHLPR3_VERSION PDM_VERSION_MAKE(0xfff7, 1, 0) 1475 1334 } PDMPICHLP; 1335 /** Pointer to PIC helpers. */ 1336 typedef PDMPICHLP *PPDMPICHLP; 1337 /** Pointer to const PIC helpers. */ 1338 typedef const PDMPICHLP *PCPDMPICHLP; 1339 1340 /** Current PDMPICHLP version number. */ 1341 #define PDM_PICHLP_VERSION PDM_VERSION_MAKE(0xfff9, 3, 0) 1476 1342 1477 1343 … … 4033 3899 * @param pDevIns The device instance. 4034 3900 * @param pPicReg Pointer to a PIC registration structure. 4035 * @param ppPicHlp R3 Where to store the pointer to the PIC HC3901 * @param ppPicHlp Where to store the pointer to the ring-3 PIC 4036 3902 * helpers. 4037 */ 4038 DECLR3CALLBACKMEMBER(int, pfnPICRegister,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)); 3903 * @sa PDMDevHlpPICSetUpContext 3904 */ 3905 DECLR3CALLBACKMEMBER(int, pfnPICRegister,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)); 4039 3906 4040 3907 /** … … 4955 4822 DECLRCCALLBACKMEMBER(int, pfnPCIBusSetUpContext,(PPDMDEVINS pDevIns, PPDMPCIBUSREGRC pPciBusReg, PCPDMPCIHLPRC *ppPciHlp)); 4956 4823 4824 /** 4825 * Sets up the PIC for the raw-mode context. 4826 * 4827 * This must be called after ring-3 has registered the PIC using 4828 * PDMDevHlpPICRegister(). 4829 * 4830 * @returns VBox status code. 4831 * @param pDevIns The device instance. 4832 * @param pPicReg The PIC registration information for ring-0, 4833 * considered volatile and copied. 4834 * @param ppPciHlp Where to return the raw-mode PIC helpers. 4835 */ 4836 DECLRCCALLBACKMEMBER(int, pfnPCISetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)); 4837 4957 4838 /** Space reserved for future members. 4958 4839 * @{ */ … … 4978 4859 4979 4860 /** Current PDMDEVHLP version number. */ 4980 #define PDM_DEVHLPRC_VERSION PDM_VERSION_MAKE(0xffe6, 1 0, 0)4861 #define PDM_DEVHLPRC_VERSION PDM_VERSION_MAKE(0xffe6, 11, 0) 4981 4862 4982 4863 … … 5415 5296 * @param pDevIns The device instance. 5416 5297 * @param pPciBusReg The PCI bus registration information for ring-0, 5417 * considered volatile .5298 * considered volatile and copied. 5418 5299 * @param ppPciHlp Where to return the ring-0 PCI bus helpers. 5419 5300 */ 5420 5301 DECLR0CALLBACKMEMBER(int, pfnPCIBusSetUpContext,(PPDMDEVINS pDevIns, PPDMPCIBUSREGR0 pPciBusReg, PCPDMPCIHLPR0 *ppPciHlp)); 5302 5303 /** 5304 * Sets up the PIC for the ring-0 context. 5305 * 5306 * This must be called after ring-3 has registered the PIC using 5307 * PDMDevHlpPICRegister(). 5308 * 5309 * @returns VBox status code. 5310 * @param pDevIns The device instance. 5311 * @param pPicReg The PIC registration information for ring-0, 5312 * considered volatile and copied. 5313 * @param ppPciHlp Where to return the ring-0 PIC helpers. 5314 */ 5315 DECLR0CALLBACKMEMBER(int, pfnPICSetUpContext,(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)); 5421 5316 5422 5317 /** Space reserved for future members. … … 5443 5338 5444 5339 /** Current PDMDEVHLP version number. */ 5445 #define PDM_DEVHLPR0_VERSION PDM_VERSION_MAKE(0xffe5, 1 1, 0)5340 #define PDM_DEVHLPR0_VERSION PDM_VERSION_MAKE(0xffe5, 12, 0) 5446 5341 5447 5342 … … 7759 7654 #endif 7760 7655 7761 #if def IN_RING37656 #if defined(IN_RING3) || defined(DOXYGEN_RUNNING) 7762 7657 7763 7658 /** … … 7876 7771 * @copydoc PDMDEVHLPR3::pfnPICRegister 7877 7772 */ 7878 DECLINLINE(int) PDMDevHlpPICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP R3 *ppPicHlpR3)7879 { 7880 return pDevIns->pHlpR3->pfnPICRegister(pDevIns, pPicReg, ppPicHlp R3);7773 DECLINLINE(int) PDMDevHlpPICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp) 7774 { 7775 return pDevIns->pHlpR3->pfnPICRegister(pDevIns, pPicReg, ppPicHlp); 7881 7776 } 7882 7777 … … 8017 7912 } 8018 7913 8019 #else /* !IN_RING3 */ 8020 8021 /** 8022 * @copydoc PDMDEVHLPR0::pfnPCIBusSetUp 7914 #endif /* IN_RING3 || DOXYGEN_RUNNING */ 7915 7916 #if !defined(IN_RING3) || defined(DOXYGEN_RUNNING) 7917 7918 /** 7919 * @copydoc PDMDEVHLPR0::pfnPCIBusSetUpContext 8023 7920 */ 8024 7921 DECLINLINE(int) PDMDevHlpPCIBusSetUpContext(PPDMDEVINS pDevIns, CTX_SUFF(PPDMPCIBUSREG) pPciBusReg, CTX_SUFF(PCPDMPCIHLP) *ppPciHlp) 8025 7922 { 8026 7923 return pDevIns->CTX_SUFF(pHlp)->pfnPCIBusSetUpContext(pDevIns, pPciBusReg, ppPciHlp); 7924 } 7925 7926 /** 7927 * @copydoc PDMDEVHLPR0::pfnPICSetUpContext 7928 */ 7929 DECLINLINE(int) PDMDevHlpPICSetUpContext(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp) 7930 { 7931 return pDevIns->CTX_SUFF(pHlp)->pfnPICSetUpContext(pDevIns, pPicReg, ppPicHlp); 8027 7932 } 8028 7933 -
trunk/src/VBox/Devices/PC/DevPIC.cpp
r81591 r81909 124 124 PPDMDEVINSR3 pDevInsR3; 125 125 /** Pointer to the PIC R3 helpers. */ 126 PCPDMPICHLPR3pPicHlpR3;126 R3PTRTYPE(PCPDMPICHLP) pPicHlpR3; 127 127 /** Pointer to the device instance - R0 Ptr. */ 128 128 PPDMDEVINSR0 pDevInsR0; 129 129 /** Pointer to the PIC R0 helpers. */ 130 PCPDMPICHLPR0pPicHlpR0;130 R0PTRTYPE(PCPDMPICHLP) pPicHlpR0; 131 131 /** Pointer to the device instance - RC Ptr. */ 132 132 PPDMDEVINSRC pDevInsRC; 133 133 /** Pointer to the PIC RC helpers. */ 134 PCPDMPICHLPRCpPicHlpRC;134 RCPTRTYPE(PCPDMPICHLP) pPicHlpRC; 135 135 /** Number of release log entries. Used to prevent flooding. */ 136 136 uint32_t cRelLogEntries; … … 725 725 * @callback_method_impl{FNDBGFHANDLERDEV} 726 726 */ 727 static DECLCALLBACK(void) picI nfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)727 static DECLCALLBACK(void) picIR3nfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs) 728 728 { 729 729 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); … … 757 757 * @callback_method_impl{FNSSMDEVSAVEEXEC} 758 758 */ 759 static DECLCALLBACK(int) picSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 760 { 761 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 759 static DECLCALLBACK(int) picR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 760 { 761 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 762 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 763 762 764 for (unsigned i = 0; i < RT_ELEMENTS(pThis->aPics); i++) 763 765 { 764 SSMR3PutU8(pSSM, pThis->aPics[i].last_irr);765 SSMR3PutU8(pSSM, pThis->aPics[i].irr);766 SSMR3PutU8(pSSM, pThis->aPics[i].imr);767 SSMR3PutU8(pSSM, pThis->aPics[i].isr);768 SSMR3PutU8(pSSM, pThis->aPics[i].priority_add);769 SSMR3PutU8(pSSM, pThis->aPics[i].irq_base);770 SSMR3PutU8(pSSM, pThis->aPics[i].read_reg_select);771 SSMR3PutU8(pSSM, pThis->aPics[i].poll);772 SSMR3PutU8(pSSM, pThis->aPics[i].special_mask);773 SSMR3PutU8(pSSM, pThis->aPics[i].init_state);774 SSMR3PutU8(pSSM, pThis->aPics[i].auto_eoi);775 SSMR3PutU8(pSSM, pThis->aPics[i].rotate_on_auto_eoi);776 SSMR3PutU8(pSSM, pThis->aPics[i].special_fully_nested_mode);777 SSMR3PutU8(pSSM, pThis->aPics[i].init4);778 SSMR3PutU8(pSSM, pThis->aPics[i].elcr);766 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].last_irr); 767 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].irr); 768 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].imr); 769 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].isr); 770 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].priority_add); 771 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].irq_base); 772 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].read_reg_select); 773 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].poll); 774 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].special_mask); 775 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].init_state); 776 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].auto_eoi); 777 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].rotate_on_auto_eoi); 778 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].special_fully_nested_mode); 779 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].init4); 780 pHlp->pfnSSMPutU8(pSSM, pThis->aPics[i].elcr); 779 781 } 780 782 return VINF_SUCCESS; … … 785 787 * @callback_method_impl{FNSSMDEVLOADEXEC} 786 788 */ 787 static DECLCALLBACK(int) picLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass) 788 { 789 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 789 static DECLCALLBACK(int) picR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass) 790 { 791 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 792 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 790 793 791 794 if (uVersion != 1) … … 795 798 for (unsigned i = 0; i < RT_ELEMENTS(pThis->aPics); i++) 796 799 { 797 SSMR3GetU8(pSSM, &pThis->aPics[i].last_irr);798 SSMR3GetU8(pSSM, &pThis->aPics[i].irr);799 SSMR3GetU8(pSSM, &pThis->aPics[i].imr);800 SSMR3GetU8(pSSM, &pThis->aPics[i].isr);801 SSMR3GetU8(pSSM, &pThis->aPics[i].priority_add);802 SSMR3GetU8(pSSM, &pThis->aPics[i].irq_base);803 SSMR3GetU8(pSSM, &pThis->aPics[i].read_reg_select);804 SSMR3GetU8(pSSM, &pThis->aPics[i].poll);805 SSMR3GetU8(pSSM, &pThis->aPics[i].special_mask);806 SSMR3GetU8(pSSM, &pThis->aPics[i].init_state);807 SSMR3GetU8(pSSM, &pThis->aPics[i].auto_eoi);808 SSMR3GetU8(pSSM, &pThis->aPics[i].rotate_on_auto_eoi);809 SSMR3GetU8(pSSM, &pThis->aPics[i].special_fully_nested_mode);810 SSMR3GetU8(pSSM, &pThis->aPics[i].init4);811 SSMR3GetU8(pSSM, &pThis->aPics[i].elcr);800 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].last_irr); 801 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].irr); 802 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].imr); 803 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].isr); 804 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].priority_add); 805 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].irq_base); 806 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].read_reg_select); 807 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].poll); 808 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].special_mask); 809 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].init_state); 810 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].auto_eoi); 811 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].rotate_on_auto_eoi); 812 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].special_fully_nested_mode); 813 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].init4); 814 pHlp->pfnSSMGetU8(pSSM, &pThis->aPics[i].elcr); 812 815 } 813 816 … … 822 825 * @interface_method_impl{PDMDEVREG,pfnReset} 823 826 */ 824 static DECLCALLBACK(void) picR eset(PPDMDEVINS pDevIns)827 static DECLCALLBACK(void) picR3Reset(PPDMDEVINS pDevIns) 825 828 { 826 829 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 827 830 unsigned i; 828 LogFlow(("picR eset:\n"));831 LogFlow(("picR3Reset:\n")); 829 832 pThis->pPicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR); 830 833 … … 839 842 * @interface_method_impl{PDMDEVREG,pfnRelocate} 840 843 */ 841 static DECLCALLBACK(void) picR elocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)844 static DECLCALLBACK(void) picR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta) 842 845 { 843 846 RT_NOREF1(offDelta); … … 846 849 847 850 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 848 pThis->pPicHlpRC = pThis->pPicHlpR3->pfnGetRCHelpers(pDevIns);851 pThis->pPicHlpRC += offDelta; 849 852 for (i = 0; i < RT_ELEMENTS(pThis->aPics); i++) 850 853 pThis->aPics[i].pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); … … 855 858 * @interface_method_impl{PDMDEVREG,pfnConstruct} 856 859 */ 857 static DECLCALLBACK(int) pic Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)860 static DECLCALLBACK(int) picR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg) 858 861 { 859 862 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); 860 RT_NOREF1(iInstance);861 863 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 862 864 int rc; 863 bool fGCEnabled;864 bool fR0Enabled; 865 RT_NOREF(iInstance, pCfg); 866 865 867 Assert(iInstance == 0); 866 868 … … 868 870 * Validate and read configuration. 869 871 */ 870 if (!CFGMR3AreValuesValid(pCfg, "GCEnabled\0" "R0Enabled\0")) 871 return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES; 872 873 rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &fGCEnabled, true); 874 if (RT_FAILURE(rc)) 875 return PDMDEV_SET_ERROR(pDevIns, rc, 876 N_("Configuration error: failed to read GCEnabled as boolean")); 877 878 rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &fR0Enabled, true); 879 if (RT_FAILURE(rc)) 880 return PDMDEV_SET_ERROR(pDevIns, rc, 881 N_("Configuration error: failed to read R0Enabled as boolean")); 882 883 Log(("DevPIC: fGCEnabled=%RTbool fR0Enabled=%RTbool\n", fGCEnabled, fR0Enabled)); 872 PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "", ""); 873 Log(("DevPIC: fRCEnabled=%RTbool fR0Enabled=%RTbool\n", pDevIns->fRCEnabled, pDevIns->fR0Enabled)); 884 874 885 875 /* … … 907 897 PDMPICREG PicReg; 908 898 PicReg.u32Version = PDM_PICREG_VERSION; 909 PicReg.pfnSetIrqR3 = picSetIrq; 910 PicReg.pfnGetInterruptR3 = picGetInterrupt; 911 912 if (fGCEnabled) 913 { 914 PicReg.pszSetIrqRC = "picSetIrq"; 915 PicReg.pszGetInterruptRC = "picGetInterrupt"; 916 } 917 else 918 { 919 PicReg.pszSetIrqRC = NULL; 920 PicReg.pszGetInterruptRC = NULL; 921 } 922 923 if (fR0Enabled) 924 { 925 PicReg.pszSetIrqR0 = "picSetIrq"; 926 PicReg.pszGetInterruptR0 = "picGetInterrupt"; 927 } 928 else 929 { 930 PicReg.pszSetIrqR0 = NULL; 931 PicReg.pszGetInterruptR0 = NULL; 932 } 933 899 PicReg.pfnSetIrq = picSetIrq; 900 PicReg.pfnGetInterrupt = picGetInterrupt; 901 PicReg.u32TheEnd = PDM_PICREG_VERSION; 934 902 rc = PDMDevHlpPICRegister(pDevIns, &PicReg, &pThis->pPicHlpR3); 935 AssertLogRelMsgRCReturn(rc, ("PICRegister -> %Rrc\n", rc), rc); 936 if (fGCEnabled) 937 pThis->pPicHlpRC = pThis->pPicHlpR3->pfnGetRCHelpers(pDevIns); 938 if (fR0Enabled) 939 pThis->pPicHlpR0 = pThis->pPicHlpR3->pfnGetR0Helpers(pDevIns); 903 AssertLogRelMsgRCReturn(rc, ("PDMDevHlpPICRegister -> %Rrc\n", rc), rc); 940 904 941 905 /* … … 955 919 if (RT_FAILURE(rc)) 956 920 return rc; 957 if ( fGCEnabled)921 if (pDevIns->fRCEnabled) 958 922 { 959 923 rc = PDMDevHlpIOPortRegisterRC(pDevIns, 0x20, 2, 0, "picIOPortWrite", "picIOPortRead", NULL, NULL, "i8259 PIC #0"); … … 964 928 return rc; 965 929 } 966 if ( fR0Enabled)930 if (pDevIns->fR0Enabled) 967 931 { 968 932 rc = PDMDevHlpIOPortRegisterR0(pDevIns, 0x20, 2, 0, "picIOPortWrite", "picIOPortRead", NULL, NULL, "i8259 PIC #0"); … … 982 946 if (RT_FAILURE(rc)) 983 947 return rc; 984 if ( fGCEnabled)948 if (pDevIns->fRCEnabled) 985 949 { 986 950 RTRCPTR pDataRC = PDMINS_2_DATA_RCPTR(pDevIns); … … 994 958 return rc; 995 959 } 996 if ( fR0Enabled)960 if (pDevIns->fR0Enabled) 997 961 { 998 962 RTR0PTR pDataR0 = PDMINS_2_DATA_R0PTR(pDevIns); … … 1007 971 } 1008 972 1009 rc = PDMDevHlpSSMRegister(pDevIns, 1 /* uVersion */, sizeof(*pThis), pic SaveExec, picLoadExec);973 rc = PDMDevHlpSSMRegister(pDevIns, 1 /* uVersion */, sizeof(*pThis), picR3SaveExec, picR3LoadExec); 1010 974 if (RT_FAILURE(rc)) 1011 975 return rc; … … 1015 979 * Register the info item. 1016 980 */ 1017 PDMDevHlpDBGFInfoRegister(pDevIns, "pic", "PIC info.", picI nfo);981 PDMDevHlpDBGFInfoRegister(pDevIns, "pic", "PIC info.", picIR3nfo); 1018 982 1019 983 /* 1020 984 * Initialize the device state. 1021 985 */ 1022 picR eset(pDevIns);986 picR3Reset(pDevIns); 1023 987 1024 988 #ifdef VBOX_WITH_STATISTICS … … 1037 1001 } 1038 1002 1039 #endif /* IN_RING3 */ 1003 #else /* !IN_RING3 */ 1004 1005 /** 1006 * @callback_method_impl{PDMDEVREGR0,pfnConstruct} 1007 */ 1008 static DECLCALLBACK(int) picRZConstruct(PPDMDEVINS pDevIns) 1009 { 1010 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); 1011 PDEVPIC pThis = PDMDEVINS_2_DATA(pDevIns, PDEVPIC); 1012 1013 int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns)); 1014 AssertRCReturn(rc, rc); 1015 1016 PDMPICREG PicReg; 1017 PicReg.u32Version = PDM_PICREG_VERSION; 1018 PicReg.pfnSetIrq = picSetIrq; 1019 PicReg.pfnGetInterrupt = picGetInterrupt; 1020 PicReg.u32TheEnd = PDM_PICREG_VERSION; 1021 rc = PDMDevHlpPICSetUpContext(pDevIns, &PicReg, &pThis->CTX_SUFF(pPicHlp)); 1022 AssertLogRelMsgRCReturn(rc, ("PDMDevHlpPICSetUpContext -> %Rrc\n", rc), rc); 1023 1024 return VINF_SUCCESS; 1025 } 1026 1027 #endif /* !IN_RING3 */ 1040 1028 1041 1029 /** … … 1060 1048 /* .pszRCMod = */ "VBoxDDRC.rc", 1061 1049 /* .pszR0Mod = */ "VBoxDDR0.r0", 1062 /* .pfnConstruct = */ pic Construct,1050 /* .pfnConstruct = */ picR3Construct, 1063 1051 /* .pfnDestruct = */ NULL, 1064 /* .pfnRelocate = */ picR elocate,1052 /* .pfnRelocate = */ picR3Relocate, 1065 1053 /* .pfnMemSetup = */ NULL, 1066 1054 /* .pfnPowerOn = */ NULL, 1067 /* .pfnReset = */ picR eset,1055 /* .pfnReset = */ picR3Reset, 1068 1056 /* .pfnSuspend = */ NULL, 1069 1057 /* .pfnResume = */ NULL, … … 1084 1072 #elif defined(IN_RING0) 1085 1073 /* .pfnEarlyConstruct = */ NULL, 1086 /* .pfnConstruct = */ NULL,1074 /* .pfnConstruct = */ picRZConstruct, 1087 1075 /* .pfnDestruct = */ NULL, 1088 1076 /* .pfnFinalDestruct = */ NULL, … … 1097 1085 /* .pfnReserved7 = */ NULL, 1098 1086 #elif defined(IN_RC) 1099 /* .pfnConstruct = */ NULL,1087 /* .pfnConstruct = */ picRZConstruct, 1100 1088 /* .pfnReserved0 = */ NULL, 1101 1089 /* .pfnReserved1 = */ NULL, -
trunk/src/VBox/VMM/VMMAll/APICAll.cpp
r81591 r81909 2683 2683 * @param rcRZ The return code if the operation cannot be performed in 2684 2684 * the current context. 2685 * 2686 * @note All callers totally ignores the status code! 2685 2687 */ 2686 2688 VMM_INT_DECL(VBOXSTRICTRC) APICLocalInterrupt(PVMCPUCC pVCpu, uint8_t u8Pin, uint8_t u8Level, int rcRZ) … … 2808 2810 default: 2809 2811 { 2810 rcStrict = VERR_INTERNAL_ERROR_3;2811 2812 AssertMsgFailed(("APIC%u: LocalInterrupt: Invalid delivery mode %#x (%s) on LINT%d\n", pVCpu->idCpu, 2812 2813 enmDeliveryMode, apicGetDeliveryModeName(enmDeliveryMode), u8Pin)); 2814 rcStrict = VERR_INTERNAL_ERROR_3; 2813 2815 break; 2814 2816 } -
trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp
r81850 r81909 54 54 RT_C_DECLS_BEGIN 55 55 extern DECLEXPORT(const PDMDEVHLPR0) g_pdmR0DevHlp; 56 extern DECLEXPORT(const PDMPICHLP R0)g_pdmR0PicHlp;56 extern DECLEXPORT(const PDMPICHLP) g_pdmR0PicHlp; 57 57 extern DECLEXPORT(const PDMIOAPICHLPR0) g_pdmR0IoApicHlp; 58 58 extern DECLEXPORT(const PDMPCIHLPR0) g_pdmR0PciHlp; … … 1093 1093 1094 1094 LogFlow(("pdmR0DevHlp_PCIBusSetUpContext: caller='%p'/%d: returns VINF_SUCCESS\n", pDevIns, pDevIns->iInstance)); 1095 return VINF_SUCCESS; 1096 } 1097 1098 1099 /** @interface_method_impl{PDMDEVHLPR0,pfnPICSetUpContext} */ 1100 static DECLCALLBACK(int) pdmR0DevHlp_PICSetUpContext(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp) 1101 { 1102 PDMDEV_ASSERT_DEVINS(pDevIns); 1103 LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlp=%p\n", 1104 pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, ppPicHlp)); 1105 PGVM pGVM = pDevIns->Internal.s.pGVM; 1106 1107 /* 1108 * Validate input. 1109 */ 1110 AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION, 1111 ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION), 1112 VERR_INVALID_PARAMETER); 1113 AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER); 1114 AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER); 1115 AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION, 1116 ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION), 1117 VERR_INVALID_PARAMETER); 1118 AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER); 1119 1120 VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER); 1121 VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT); 1122 1123 /* Check that it's the same device as made the ring-3 registrations: */ 1124 AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR3 == pDevIns->pDevInsForR3, 1125 ("%p vs %p\n", pGVM->pdm.s.Pic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER); 1126 1127 /* Check that it isn't already registered in ring-0: */ 1128 AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Pic.pDevInsR0, pDevIns), 1129 VERR_ALREADY_EXISTS); 1130 1131 /* 1132 * Take down the callbacks and instance. 1133 */ 1134 pGVM->pdm.s.Pic.pDevInsR0 = pDevIns; 1135 pGVM->pdm.s.Pic.pfnSetIrqR0 = pPicReg->pfnSetIrq; 1136 pGVM->pdm.s.Pic.pfnGetInterruptR0 = pPicReg->pfnGetInterrupt; 1137 Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns)); 1138 1139 /* set the helper pointer and return. */ 1140 *ppPicHlp = &g_pdmR0PicHlp; 1141 LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS)); 1095 1142 return VINF_SUCCESS; 1096 1143 } … … 1174 1221 pdmR0DevHlp_DBGFTraceBuf, 1175 1222 pdmR0DevHlp_PCIBusSetUpContext, 1223 pdmR0DevHlp_PICSetUpContext, 1176 1224 NULL /*pfnReserved1*/, 1177 1225 NULL /*pfnReserved2*/, … … 1196 1244 */ 1197 1245 1198 /** @interface_method_impl{PDMPICHLP R0,pfnSetInterruptFF} */1246 /** @interface_method_impl{PDMPICHLP,pfnSetInterruptFF} */ 1199 1247 static DECLCALLBACK(void) pdmR0PicHlp_SetInterruptFF(PPDMDEVINS pDevIns) 1200 1248 { … … 1207 1255 1208 1256 1209 /** @interface_method_impl{PDMPICHLP R0,pfnClearInterruptFF} */1257 /** @interface_method_impl{PDMPICHLP,pfnClearInterruptFF} */ 1210 1258 static DECLCALLBACK(void) pdmR0PicHlp_ClearInterruptFF(PPDMDEVINS pDevIns) 1211 1259 { … … 1218 1266 1219 1267 1220 /** @interface_method_impl{PDMPICHLP R0,pfnLock} */1268 /** @interface_method_impl{PDMPICHLP,pfnLock} */ 1221 1269 static DECLCALLBACK(int) pdmR0PicHlp_Lock(PPDMDEVINS pDevIns, int rc) 1222 1270 { … … 1226 1274 1227 1275 1228 /** @interface_method_impl{PDMPICHLP R0,pfnUnlock} */1276 /** @interface_method_impl{PDMPICHLP,pfnUnlock} */ 1229 1277 static DECLCALLBACK(void) pdmR0PicHlp_Unlock(PPDMDEVINS pDevIns) 1230 1278 { … … 1237 1285 * The Ring-0 PIC Helper Callbacks. 1238 1286 */ 1239 extern DECLEXPORT(const PDMPICHLP R0) g_pdmR0PicHlp =1240 { 1241 PDM_PICHLP R0_VERSION,1287 extern DECLEXPORT(const PDMPICHLP) g_pdmR0PicHlp = 1288 { 1289 PDM_PICHLP_VERSION, 1242 1290 pdmR0PicHlp_SetInterruptFF, 1243 1291 pdmR0PicHlp_ClearInterruptFF, 1244 1292 pdmR0PicHlp_Lock, 1245 1293 pdmR0PicHlp_Unlock, 1246 PDM_PICHLP R0_VERSION1294 PDM_PICHLP_VERSION 1247 1295 }; 1248 1296 -
trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp
r81850 r81909 3678 3678 3679 3679 /** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */ 3680 static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP R3 *ppPicHlpR3)3680 static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp) 3681 3681 { 3682 3682 PDMDEV_ASSERT_DEVINS(pDevIns); 3683 3683 VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3); 3684 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n", 3685 pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3, 3686 pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC, 3687 pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0, 3688 ppPicHlpR3)); 3684 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlp=%p\n", 3685 pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, ppPicHlp)); 3686 PVM pVM = pDevIns->Internal.s.pVMR3; 3689 3687 3690 3688 /* 3691 3689 * Validate input. 3692 3690 */ 3693 if (pPicReg->u32Version != PDM_PICREG_VERSION) 3694 { 3695 AssertMsgFailed(("u32Version=%#x expected %#x\n", pPicReg->u32Version, PDM_PICREG_VERSION)); 3696 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3697 return VERR_INVALID_PARAMETER; 3698 } 3699 if ( !pPicReg->pfnSetIrqR3 3700 || !pPicReg->pfnGetInterruptR3) 3701 { 3702 Assert(pPicReg->pfnSetIrqR3); 3703 Assert(pPicReg->pfnGetInterruptR3); 3704 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3705 return VERR_INVALID_PARAMETER; 3706 } 3707 if ( ( pPicReg->pszSetIrqRC 3708 || pPicReg->pszGetInterruptRC) 3709 && ( !VALID_PTR(pPicReg->pszSetIrqRC) 3710 || !VALID_PTR(pPicReg->pszGetInterruptRC)) 3711 ) 3712 { 3713 Assert(VALID_PTR(pPicReg->pszSetIrqRC)); 3714 Assert(VALID_PTR(pPicReg->pszGetInterruptRC)); 3715 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3716 return VERR_INVALID_PARAMETER; 3717 } 3718 if ( pPicReg->pszSetIrqRC 3719 && !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)) 3720 { 3721 Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC); 3722 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3723 return VERR_INVALID_PARAMETER; 3724 } 3725 if ( pPicReg->pszSetIrqR0 3726 && !(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)) 3727 { 3728 Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0); 3729 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3730 return VERR_INVALID_PARAMETER; 3731 } 3732 if (!ppPicHlpR3) 3733 { 3734 Assert(ppPicHlpR3); 3735 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3736 return VERR_INVALID_PARAMETER; 3737 } 3691 AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION, 3692 ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION), 3693 VERR_INVALID_PARAMETER); 3694 AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER); 3695 AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER); 3696 AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION, 3697 ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION), 3698 VERR_INVALID_PARAMETER); 3699 AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER); 3700 3701 VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_WRONG_ORDER); 3702 VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT); 3738 3703 3739 3704 /* 3740 3705 * Only one PIC device. 3741 3706 */ 3742 PVM pVM = pDevIns->Internal.s.pVMR3; 3743 if (pVM->pdm.s.Pic.pDevInsR3) 3744 { 3745 AssertMsgFailed(("Only one pic device is supported!\n")); 3746 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER)); 3747 return VERR_INVALID_PARAMETER; 3748 } 3749 3750 /* 3751 * RC stuff. 3752 */ 3753 if (pPicReg->pszSetIrqRC) 3754 { 3755 int rc = pdmR3DevGetSymbolRCLazy(pDevIns, pPicReg->pszSetIrqRC, &pVM->pdm.s.Pic.pfnSetIrqRC); 3756 AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->pszRCMod, pPicReg->pszSetIrqRC, rc)); 3757 if (RT_SUCCESS(rc)) 3758 { 3759 rc = pdmR3DevGetSymbolRCLazy(pDevIns, pPicReg->pszGetInterruptRC, &pVM->pdm.s.Pic.pfnGetInterruptRC); 3760 AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->pszRCMod, pPicReg->pszGetInterruptRC, rc)); 3761 } 3762 if (RT_FAILURE(rc)) 3763 { 3764 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc)); 3765 return rc; 3766 } 3767 pVM->pdm.s.Pic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 3768 } 3769 else 3770 { 3771 pVM->pdm.s.Pic.pDevInsRC = 0; 3772 pVM->pdm.s.Pic.pfnSetIrqRC = 0; 3773 pVM->pdm.s.Pic.pfnGetInterruptRC = 0; 3774 } 3775 3776 /* 3777 * R0 stuff. 3778 */ 3779 if (pPicReg->pszSetIrqR0) 3780 { 3781 int rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pPicReg->pszSetIrqR0, &pVM->pdm.s.Pic.pfnSetIrqR0); 3782 AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->pszR0Mod, pPicReg->pszSetIrqR0, rc)); 3783 if (RT_SUCCESS(rc)) 3784 { 3785 rc = pdmR3DevGetSymbolR0Lazy(pDevIns, pPicReg->pszGetInterruptR0, &pVM->pdm.s.Pic.pfnGetInterruptR0); 3786 AssertMsgRC(rc, ("%s::%s rc=%Rrc\n", pDevIns->pReg->pszR0Mod, pPicReg->pszGetInterruptR0, rc)); 3787 } 3788 if (RT_FAILURE(rc)) 3789 { 3790 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc)); 3791 return rc; 3792 } 3793 pVM->pdm.s.Pic.pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns); 3794 Assert(pVM->pdm.s.Pic.pDevInsR0); 3795 } 3796 else 3797 { 3798 pVM->pdm.s.Pic.pfnSetIrqR0 = 0; 3799 pVM->pdm.s.Pic.pfnGetInterruptR0 = 0; 3800 pVM->pdm.s.Pic.pDevInsR0 = 0; 3801 } 3802 3803 /* 3804 * R3 stuff. 3707 AssertMsgReturn(pVM->pdm.s.Pic.pDevInsR3 == NULL, ("%s/%d: Only one PIC!\n", pDevIns->pReg->szName, pDevIns->iInstance), 3708 VERR_ALREADY_EXISTS); 3709 3710 /* 3711 * Take down the callbacks and instance. 3805 3712 */ 3806 3713 pVM->pdm.s.Pic.pDevInsR3 = pDevIns; 3807 pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrq R3;3808 pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterrupt R3;3714 pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrq; 3715 pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterrupt; 3809 3716 Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns)); 3810 3717 3811 3718 /* set the helper pointer and return. */ 3812 *ppPicHlp R3= &g_pdmR3DevPicHlp;3719 *ppPicHlp = &g_pdmR3DevPicHlp; 3813 3720 LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS)); 3814 3721 return VINF_SUCCESS; -
trunk/src/VBox/VMM/VMMR3/PDMDevMiscHlp.cpp
r81369 r81909 45 45 */ 46 46 47 /** @interface_method_impl{PDMPICHLP R3,pfnSetInterruptFF} */47 /** @interface_method_impl{PDMPICHLP,pfnSetInterruptFF} */ 48 48 static DECLCALLBACK(void) pdmR3PicHlp_SetInterruptFF(PPDMDEVINS pDevIns) 49 49 { 50 50 PDMDEV_ASSERT_DEVINS(pDevIns); 51 51 PVM pVM = pDevIns->Internal.s.pVMR3; 52 PVMCPU pVCpu = pVM->apCpusR3[0]; /* for PIC we always deliver to CPU 0, MP useAPIC */52 PVMCPU pVCpu = pVM->apCpusR3[0]; /* for PIC we always deliver to CPU 0, SMP uses APIC */ 53 53 54 54 /* IRQ state should be loaded as-is by "LoadExec". Changes can be made from LoadDone. */ … … 59 59 60 60 61 /** @interface_method_impl{PDMPICHLP R3,pfnClearInterruptFF} */61 /** @interface_method_impl{PDMPICHLP,pfnClearInterruptFF} */ 62 62 static DECLCALLBACK(void) pdmR3PicHlp_ClearInterruptFF(PPDMDEVINS pDevIns) 63 63 { 64 64 PDMDEV_ASSERT_DEVINS(pDevIns); 65 65 PVM pVM = pDevIns->Internal.s.pVMR3; 66 PVMCPU pVCpu = pVM->apCpusR3[0]; /* for PIC we always deliver to CPU 0, MP useAPIC */66 PVMCPU pVCpu = pVM->apCpusR3[0]; /* for PIC we always deliver to CPU 0, SMP uses APIC */ 67 67 68 68 /* IRQ state should be loaded as-is by "LoadExec". Changes can be made from LoadDone. */ … … 73 73 74 74 75 /** @interface_method_impl{PDMPICHLP R3,pfnLock} */75 /** @interface_method_impl{PDMPICHLP,pfnLock} */ 76 76 static DECLCALLBACK(int) pdmR3PicHlp_Lock(PPDMDEVINS pDevIns, int rc) 77 77 { … … 81 81 82 82 83 /** @interface_method_impl{PDMPICHLP R3,pfnUnlock} */83 /** @interface_method_impl{PDMPICHLP,pfnUnlock} */ 84 84 static DECLCALLBACK(void) pdmR3PicHlp_Unlock(PPDMDEVINS pDevIns) 85 85 { … … 89 89 90 90 91 /** @interface_method_impl{PDMPICHLPR3,pfnGetRCHelpers} */92 static DECLCALLBACK(PCPDMPICHLPRC) pdmR3PicHlp_GetRCHelpers(PPDMDEVINS pDevIns)93 {94 PDMDEV_ASSERT_DEVINS(pDevIns);95 PVM pVM = pDevIns->Internal.s.pVMR3;96 VM_ASSERT_EMT(pVM);97 98 RTRCPTR pRCHelpers = NIL_RTRCPTR;99 if (VM_IS_RAW_MODE_ENABLED(pVM))100 {101 int rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCPicHlp", &pRCHelpers);102 AssertReleaseRC(rc);103 AssertRelease(pRCHelpers);104 }105 106 LogFlow(("pdmR3PicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",107 pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));108 return pRCHelpers;109 }110 111 112 /** @interface_method_impl{PDMPICHLPR3,pfnGetR0Helpers} */113 static DECLCALLBACK(PCPDMPICHLPR0) pdmR3PicHlp_GetR0Helpers(PPDMDEVINS pDevIns)114 {115 PDMDEV_ASSERT_DEVINS(pDevIns);116 PVM pVM = pDevIns->Internal.s.pVMR3;117 VM_ASSERT_EMT(pVM);118 PCPDMPICHLPR0 pR0Helpers = 0;119 int rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0PicHlp", &pR0Helpers);120 AssertReleaseRC(rc);121 AssertRelease(pR0Helpers);122 LogFlow(("pdmR3PicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",123 pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));124 return pR0Helpers;125 }126 127 128 91 /** 129 92 * PIC Device Helpers. 130 93 */ 131 const PDMPICHLP R3g_pdmR3DevPicHlp =132 { 133 PDM_PICHLP R3_VERSION,94 const PDMPICHLP g_pdmR3DevPicHlp = 95 { 96 PDM_PICHLP_VERSION, 134 97 pdmR3PicHlp_SetInterruptFF, 135 98 pdmR3PicHlp_ClearInterruptFF, 136 99 pdmR3PicHlp_Lock, 137 100 pdmR3PicHlp_Unlock, 138 pdmR3PicHlp_GetRCHelpers, 139 pdmR3PicHlp_GetR0Helpers, 140 PDM_PICHLPR3_VERSION /* the end */ 101 PDM_PICHLP_VERSION /* the end */ 141 102 }; 142 103 -
trunk/src/VBox/VMM/include/PDMInternal.h
r81841 r81909 1388 1388 extern const PDMDEVHLPR3 g_pdmR3DevHlpTrusted; 1389 1389 extern const PDMDEVHLPR3 g_pdmR3DevHlpUnTrusted; 1390 extern const PDMPICHLP R3g_pdmR3DevPicHlp;1390 extern const PDMPICHLP g_pdmR3DevPicHlp; 1391 1391 extern const PDMIOAPICHLPR3 g_pdmR3DevIoApicHlp; 1392 1392 extern const PDMFWHLPR3 g_pdmR3DevFirmwareHlp;
Note:
See TracChangeset
for help on using the changeset viewer.
