Changeset 93601 in vbox for trunk/src/VBox/Devices
- Timestamp:
- Feb 4, 2022 9:01:01 AM (3 years ago)
- svn:sync-xref-src-repo-rev:
- 149739
- Location:
- trunk/src/VBox/Devices/Network
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Devices/Network/Dev3C501.cpp
r93567 r93601 188 188 #define MAX_FRAME 1536 189 189 190 #define ELNKSTATE_2_DEVINS(pThis) ((pThis)->CTX_SUFF(pDevIns))191 #define ELNK_INSTANCE (ELNKSTATE_2_DEVINS(pThis)->iInstance)192 193 190 /* Size of the packet buffer. */ 194 191 #define ELNK_BUF_SIZE 2048u … … 323 320 /** 324 321 * EtherLink 3C501 state. 325 *326 * @extends PDMPCIDEV327 * @implements PDMIBASE328 * @implements PDMINETWORKDOWN329 * @implements PDMINETWORKCONFIG330 * @implements PDMILEDPORTS331 322 */ 332 323 typedef struct ELNKSTATE 333 324 { 334 /** Pointer to the device instance - R3. */335 PPDMDEVINSR3 pDevInsR3;336 /** Pointer to the connector of the attached network driver - R3. */337 PPDMINETWORKUPR3 pDrvR3;338 /** Pointer to the attached network driver. */339 R3PTRTYPE(PPDMIBASE) pDrvBase;340 /** LUN\#0 + status LUN: The base interface. */341 PDMIBASE IBase;342 /** LUN\#0: The network port interface. */343 PDMINETWORKDOWN INetworkDown;344 /** LUN\#0: The network config port interface. */345 PDMINETWORKCONFIG INetworkConfig;346 325 /** Restore timer. 347 326 * This is used to disconnect and reconnect the link after a restore. */ 348 327 TMTIMERHANDLE hTimerRestore; 349 350 /** Pointer to the device instance - R0. */351 PPDMDEVINSR0 pDevInsR0;352 /** Pointer to the connector of the attached network driver - R0. */353 PPDMINETWORKUPR0 pDrvR0;354 355 /** Pointer to the device instance - RC. */356 PPDMDEVINSRC pDevInsRC;357 /** Pointer to the connector of the attached network driver - RC. */358 PPDMINETWORKUPRC pDrvRC;359 328 360 329 /** Transmit signaller. */ … … 432 401 }; 433 402 403 /** Set if ELNKSTATER3::pDrv is not NULL. */ 404 bool fDriverAttached; 434 405 /** The LED. */ 435 406 PDMLED Led; … … 489 460 490 461 462 /** 463 * EtherLink state for ring-3. 464 * 465 * @implements PDMIBASE 466 * @implements PDMINETWORKDOWN 467 * @implements PDMINETWORKCONFIG 468 * @implements PDMILEDPORTS 469 */ 470 typedef struct ELNKSTATER3 471 { 472 /** Pointer to the device instance. */ 473 PPDMDEVINSR3 pDevIns; 474 /** Pointer to the connector of the attached network driver. */ 475 PPDMINETWORKUPR3 pDrv; 476 /** Pointer to the attached network driver. */ 477 R3PTRTYPE(PPDMIBASE) pDrvBase; 478 /** LUN\#0 + status LUN: The base interface. */ 479 PDMIBASE IBase; 480 /** LUN\#0: The network port interface. */ 481 PDMINETWORKDOWN INetworkDown; 482 /** LUN\#0: The network config port interface. */ 483 PDMINETWORKCONFIG INetworkConfig; 484 485 /** Status LUN: The LED ports. */ 486 PDMILEDPORTS ILeds; 487 /** Partner of ILeds. */ 488 R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector; 489 } ELNKSTATER3; 490 /** Pointer to an EtherLink state structure for ring-3. */ 491 typedef ELNKSTATER3 *PELNKSTATER3; 492 493 494 /** 495 * EtherLink state for ring-0. 496 */ 497 typedef struct ELNKSTATER0 498 { 499 /** Pointer to the connector of the attached network driver. */ 500 PPDMINETWORKUPR0 pDrv; 501 } ELNKSTATER0; 502 /** Pointer to an EtherLink state structure for ring-0. */ 503 typedef ELNKSTATER0 *PELNKSTATER0; 504 505 506 /** 507 * EtherLink state for raw-mode. 508 */ 509 typedef struct ELNKSTATERC 510 { 511 /** Pointer to the connector of the attached network driver. */ 512 PPDMINETWORKUPRC pDrv; 513 } ELNKSTATERC; 514 /** Pointer to an EtherLink state structure for raw-mode. */ 515 typedef ELNKSTATERC *PELNKSTATERC; 516 517 518 /** The EtherLink state structure for the current context. */ 519 typedef CTX_SUFF(ELNKSTATE) ELNKSTATECC; 520 /** Pointer to an EtherLink state structure for the current 521 * context. */ 522 typedef CTX_SUFF(PELNKSTATE) PELNKSTATECC; 523 524 491 525 #ifndef VBOX_DEVICE_STRUCT_TESTCASE 492 526 … … 496 530 *********************************************************************************************************************************/ 497 531 498 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, bool fOnWorkerThread);532 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread); 499 533 500 534 /** … … 505 539 DECLINLINE(bool) elnkIsLinkUp(PELNKSTATE pThis) 506 540 { 507 return pThis-> pDrvR3&& !pThis->fLinkTempDown && pThis->fLinkUp;541 return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp; 508 542 } 509 543 … … 566 600 * Update the device IRQ line based on internal state. 567 601 */ 568 static void elnkUpdateIrq(P ELNKSTATE pThis)602 static void elnkUpdateIrq(PPDMDEVINS pDevIns, PELNKSTATE pThis) 569 603 { 570 604 bool fISR = false; … … 578 612 fISR = true; 579 613 580 Log2(("#%d set irq fISR=%d\n", ELNK_INSTANCE, fISR));614 Log2(("#%d set irq fISR=%d\n", pThis->iInstance, fISR)); 581 615 582 616 /* The IRQ line typically does not change. */ 583 617 if (RT_UNLIKELY(fISR != pThis->fISR)) 584 618 { 585 Log(("#%d IRQ=%d, state=%d\n", ELNK_INSTANCE, pThis->uIsaIrq, fISR));586 PDMDevHlpISASetIrq( ELNKSTATE_2_DEVINS(pThis), pThis->uIsaIrq, fISR);619 Log(("#%d IRQ=%d, state=%d\n", pThis->iInstance, pThis->uIsaIrq, fISR)); 620 PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, fISR); 587 621 pThis->fISR = fISR; 588 622 } … … 594 628 * Perform a software reset of the NIC. 595 629 */ 596 static void elnkSoftReset(P ELNKSTATE pThis)597 { 598 LogFlow (("#%d elnkSoftReset:\n", ELNK_INSTANCE));630 static void elnkSoftReset(PPDMDEVINS pDevIns, PELNKSTATE pThis) 631 { 632 LogFlowFunc(("#%d:\n", pThis->iInstance)); 599 633 600 634 /* Clear some of the user-visible register state. */ … … 614 648 /* Clear internal interrupt state. */ 615 649 pThis->IntrStateReg = 0; 616 elnkUpdateIrq(p This);650 elnkUpdateIrq(pDevIns, pThis); 617 651 618 652 /* Note that a soft reset does not clear the packet buffer; software often … … 630 664 static DECLCALLBACK(void) elnkR3WakeupReceive(PPDMDEVINS pDevIns) 631 665 { 632 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);666 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 633 667 STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup); 634 668 if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT) … … 652 686 * Write incoming data into the packet buffer. 653 687 */ 654 static void elnkReceiveLocked(PELNKSTATE pThis, const uint8_t *src, size_t cbToRecv, bool fLoopback) 655 { 656 PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis); 688 static void elnkReceiveLocked(PPDMDEVINS pDevIns, PELNKSTATE pThis, const uint8_t *src, size_t cbToRecv, bool fLoopback) 689 { 657 690 int is_padr = 0, is_bcast = 0, is_mcast = 0; 658 691 union { … … 704 737 } 705 738 706 LogFlowFunc(("#%d: size on wire=%d, RCV ptr=%u\n", ELNK_INSTANCE, cbToRecv, pThis->uRCVBufPtr));739 LogFlowFunc(("#%d: size on wire=%d, RCV ptr=%u\n", pThis->iInstance, cbToRecv, pThis->uRCVBufPtr)); 707 740 708 741 /* … … 718 751 uint8_t *dst = pThis->abPacketBuf + pThis->uRCVBufPtr; 719 752 720 Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d), size=%d\n", ELNK_INSTANCE, cbToRecv, is_padr, is_bcast, is_mcast));753 Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d), size=%d\n", pThis->iInstance, cbToRecv, is_padr, is_bcast, is_mcast)); 721 754 722 755 /* Receive status is evaluated from scratch. The stale bit must remain set until we know better. */ … … 752 785 else 753 786 { 754 LogFunc(("#%d runt, size=%d\n", ELNK_INSTANCE, cbToRecv));787 LogFunc(("#%d runt, size=%d\n", pThis->iInstance, cbToRecv)); 755 788 RcvStatNew.runt = 1; 756 789 } … … 767 800 else 768 801 { 769 LogFunc(("#%d overflow, size=%d\n", ELNK_INSTANCE, cbToRecv));802 LogFunc(("#%d overflow, size=%d\n", pThis->iInstance, cbToRecv)); 770 803 RcvStatNew.oflow = 1; 771 804 } … … 773 806 if (fLoopback && pThis->AuxCmd.xmit_bf) 774 807 { 775 LogFunc(("#%d bad FCS\n", ELNK_INSTANCE));808 LogFunc(("#%d bad FCS\n", pThis->iInstance)); 776 809 RcvStatNew.fcs = 1; 777 810 } … … 817 850 pThis->RcvStat = RcvStatNew; 818 851 819 LogFlowFunc(("#%d: RcvCmd=%02X, RcvStat=%02X, RCVBufPtr=%u\n", ELNK_INSTANCE, pThis->RcvCmdReg, pThis->RcvStatReg, pThis->uRCVBufPtr));820 elnkUpdateIrq(p This);852 LogFlowFunc(("#%d: RcvCmd=%02X, RcvStat=%02X, RCVBufPtr=%u\n", pThis->iInstance, pThis->RcvCmdReg, pThis->RcvStatReg, pThis->uRCVBufPtr)); 853 elnkUpdateIrq(pDevIns, pThis); 821 854 } 822 855 } … … 828 861 * @returns VBox status code. VERR_TRY_AGAIN is returned if we're busy. 829 862 * 830 * @param pThis The device instance data. 863 * @param pDevIns The device instance. 864 * @param pThis The EtherLink shared instance 865 * data. 866 * @param pThisCC The EtherLink state data for the 867 * current context. 831 868 * @param fOnWorkerThread Whether we're on a worker thread or on an EMT. 832 869 */ 833 static int elnkXmitBuffer(P ELNKSTATE pThis, bool fOnWorkerThread)870 static int elnkXmitBuffer(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread) 834 871 { 835 872 RT_NOREF_PV(fOnWorkerThread); … … 839 876 * Grab the xmit lock of the driver as well as the 3C501 device state. 840 877 */ 841 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);878 PPDMINETWORKUP pDrv = pThisCC->pDrv; 842 879 if (pDrv) 843 880 { … … 846 883 return rc; 847 884 } 848 PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis);849 885 rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); 850 886 if (RT_SUCCESS(rc)) … … 854 890 * Do the transmitting. 855 891 */ 856 int rc2 = elnkAsyncTransmit(pDevIns, pThis, false /*fOnWorkerThread*/);892 int rc2 = elnkAsyncTransmit(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/); 857 893 AssertReleaseRC(rc2); 858 894 … … 879 915 static DECLCALLBACK(void) elnkR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser) 880 916 { 881 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 917 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 918 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 882 919 NOREF(pvUser); 883 920 … … 885 922 * Transmit if we can. 886 923 */ 887 elnkXmitBuffer(p This, true /*fOnWorkerThread*/);924 elnkXmitBuffer(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/); 888 925 } 889 926 #endif /* IN_RING3 */ … … 894 931 * 895 932 * @returns See PPDMINETWORKUP::pfnAllocBuf. 896 * @param pThis The device instance. 933 * @param pThis The shared state data. 934 * @param pThisCC The current context state data. 897 935 * @param cbMin The minimum buffer size. 898 936 * @param fLoopback Set if we're in loopback mode. … … 901 939 * Always set. 902 940 */ 903 DECLINLINE(int) elnkXmitAllocBuf(PELNKSTATE pThis, size_t cbMin, bool fLoopback,941 DECLINLINE(int) elnkXmitAllocBuf(PELNKSTATE pThis, PELNKSTATECC pThisCC, size_t cbMin, bool fLoopback, 904 942 PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf) 905 943 { … … 908 946 if (!fLoopback) 909 947 { 910 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);948 PPDMINETWORKUP pDrv = pThisCC->pDrv; 911 949 if (RT_LIKELY(pDrv)) 912 950 { … … 946 984 * 947 985 * @returns See PDMINETWORKUP::pfnSendBuf. 948 * @param pThis The device instance. 986 * @param pDevIns The device instance. 987 * @param pThis The shared EtherLink state data. 988 * @param pThisCC The current context state data. 949 989 * @param fLoopback Set if we're in loopback mode. 950 990 * @param pSgBuf The SG to send. … … 952 992 * if an EMT. 953 993 */ 954 DECLINLINE(int) elnkXmitSendBuf(P ELNKSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)994 DECLINLINE(int) elnkXmitSendBuf(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread) 955 995 { 956 996 int rc; … … 962 1002 pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1; 963 1003 964 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);1004 PPDMINETWORKUP pDrv = pThisCC->pDrv; 965 1005 if (RT_LIKELY(pDrv)) 966 1006 { … … 980 1020 pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1; 981 1021 982 LogFlowFunc(("#%d: loopback (%u bytes)\n", ELNK_INSTANCE, pSgBuf->cbUsed));983 elnkReceiveLocked(p This, pThis->abLoopBuf, pSgBuf->cbUsed, fLoopback);1022 LogFlowFunc(("#%d: loopback (%u bytes)\n", pThis->iInstance, pSgBuf->cbUsed)); 1023 elnkReceiveLocked(pDevIns, pThis, pThis->abLoopBuf, pSgBuf->cbUsed, fLoopback); 984 1024 pThis->Led.Actual.s.fReading = 0; 985 1025 rc = VINF_SUCCESS; … … 1004 1044 * Try to transmit a frame. 1005 1045 */ 1006 static void elnkTransmit(PELNKSTATE pThis) 1007 { 1046 static void elnkTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis) 1047 { 1048 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 1049 1008 1050 /* 1009 1051 * Transmit the packet if possible, defer it if we cannot do it … … 1011 1053 */ 1012 1054 #if defined(IN_RING0) || defined(IN_RC) 1013 if (!pThis ->CTX_SUFF(pDrv))1014 { 1015 int rc = PDMDevHlpTaskTrigger(p This->CTX_SUFF(pDevIns), pThis->hXmitTask);1055 if (!pThisCC->pDrv) 1056 { 1057 int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask); 1016 1058 AssertRC(rc); 1017 1059 } … … 1019 1061 #endif 1020 1062 { 1021 int rc = elnkXmitBuffer(p This, false /*fOnWorkerThread*/);1063 int rc = elnkXmitBuffer(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/); 1022 1064 if (rc == VERR_TRY_AGAIN) 1023 1065 rc = VINF_SUCCESS; … … 1032 1074 * @threads EMT. 1033 1075 */ 1034 static void elnkKickReceive(P ELNKSTATE pThis)1076 static void elnkKickReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis) 1035 1077 { 1036 1078 /* Some drivers (e.g. NetWare IPX shell/ODI drivers) first go to receive mode through … … 1042 1084 { 1043 1085 #ifdef IN_RING3 1044 elnkR3WakeupReceive( ELNKSTATE_2_DEVINS(pThis));1086 elnkR3WakeupReceive(pDevIns); 1045 1087 #else 1046 int rc = PDMDevHlpTaskTrigger(p This->CTX_SUFF(pDevIns), pThis->hCanRxTask);1088 int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hCanRxTask); 1047 1089 AssertRC(rc); 1048 1090 #endif … … 1057 1099 * @threads TX or EMT. 1058 1100 */ 1059 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, bool fOnWorkerThread)1101 static int elnkAsyncTransmit(PPDMDEVINS pDevIns, PELNKSTATE pThis, PELNKSTATECC pThisCC, bool fOnWorkerThread) 1060 1102 { 1061 1103 Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); … … 1067 1109 if (RT_UNLIKELY(!pThis->AuxStat.xmit_bsy)) 1068 1110 { 1069 LogFunc(("#%d: Nope, xmit disabled (fOnWorkerThread=%RTbool)\n", ELNK_INSTANCE, fOnWorkerThread));1111 LogFunc(("#%d: Nope, xmit disabled (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread)); 1070 1112 return VINF_SUCCESS; 1071 1113 } … … 1073 1115 if (RT_UNLIKELY((pThis->AuxCmd.buf_ctl != EL_BCTL_XMT_RCV) && (pThis->AuxCmd.buf_ctl != EL_BCTL_LOOPBACK))) 1074 1116 { 1075 LogFunc(("#%d: Nope, not in xmit-then-receive or loopback state (fOnWorkerThread=%RTbool)\n", ELNK_INSTANCE, fOnWorkerThread));1117 LogFunc(("#%d: Nope, not in xmit-then-receive or loopback state (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread)); 1076 1118 return VINF_SUCCESS; 1077 1119 } … … 1099 1141 */ 1100 1142 const unsigned cb = ELNK_BUF_SIZE - ELNK_GP(pThis); /* Packet size. */ 1101 Log (("#%d elnkAsyncTransmit: cb=%d\n", ELNK_INSTANCE, cb));1143 LogFunc(("#%d: cb=%d\n", pThis->iInstance, cb)); 1102 1144 1103 1145 pThis->XmitStatReg = 0; /* Clear transmit status before filling it out. */ … … 1107 1149 if (RT_LIKELY(cb <= MAX_FRAME)) 1108 1150 { 1109 rc = elnkXmitAllocBuf(pThis, cb, fLoopback, &SgLoop, &pSgBuf);1151 rc = elnkXmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf); 1110 1152 if (RT_SUCCESS(rc)) 1111 1153 { 1112 1154 elnkXmitRead(pDevIns, pThis, cb, pSgBuf); 1113 rc = elnkXmitSendBuf(p This, fLoopback, pSgBuf, fOnWorkerThread);1114 Log2 (("#%d elnkAsyncTransmit: rc=%Rrc\n", ELNK_INSTANCE, rc));1155 rc = elnkXmitSendBuf(pDevIns, pThis, pThisCC, fLoopback, pSgBuf, fOnWorkerThread); 1156 Log2Func(("#%d: rc=%Rrc\n", pThis->iInstance, rc)); 1115 1157 } 1116 1158 else if (rc == VERR_TRY_AGAIN) 1117 1159 { 1118 1160 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a); 1119 Log (("#%d elnkAsyncTransmit: rc=%Rrc\n", ELNK_INSTANCE, rc));1161 LogFunc(("#%d: rc=%Rrc\n", pThis->iInstance, rc)); 1120 1162 return VINF_SUCCESS; 1121 1163 } … … 1129 1171 /* Signal error, as this violates the Ethernet specs. */ 1130 1172 /** @todo check if the correct error is generated. */ 1131 LogRel(("3C501#%d: elnkAsyncTransmit: illegal giant frame (%u bytes) -> signalling error\n", ELNK_INSTANCE, cb));1173 LogRel(("3C501#%d: illegal giant frame (%u bytes) -> signalling error\n", pThis->iInstance, cb)); 1132 1174 } 1133 1175 } … … 1135 1177 { 1136 1178 /* Signal a transmit error pretending there was a collision. */ 1179 pThis->cLinkDownReported++; 1137 1180 pThis->XmitStat.coll = 1; 1138 1181 } … … 1140 1183 pThis->AuxStat.xmit_bsy = 0; 1141 1184 pThis->IntrState.xmit_intr = !!(pThis->XmitCmdReg & pThis->XmitStatReg); 1142 LogFlowFunc(("#%d: XmitCmd=%02X, XmitStat=%02X\n", ELNK_INSTANCE, pThis->XmitCmdReg, pThis->XmitStatReg));1185 LogFlowFunc(("#%d: XmitCmd=%02X, XmitStat=%02X\n", pThis->iInstance, pThis->XmitCmdReg, pThis->XmitStatReg)); 1143 1186 1144 1187 /* NB: After a transmit, the GP Buffer Pointer points just past 1145 1188 * the end of the packet buffer (3C501 diagnostics). 1146 1189 */ 1147 pThis->uGPBufPtr 1190 pThis->uGPBufPtr = ELNK_BUF_SIZE; 1148 1191 1149 1192 /* NB: The buffer control does *not* change to Receive and stays the way it was. */ … … 1151 1194 { 1152 1195 pThis->AuxStat.recv_bsy = 1; /* Receive Busy now set until a packet is received. */ 1153 elnkKickReceive(p This);1196 elnkKickReceive(pDevIns, pThis); 1154 1197 } 1155 1198 } while (0); /* No loop, because there isn't ever more than one packet to transmit. */ 1156 1199 1157 elnkUpdateIrq(p This);1200 elnkUpdateIrq(pDevIns, pThis); 1158 1201 1159 1202 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a); … … 1165 1208 1166 1209 1167 static int elnkCsrWrite(P ELNKSTATE pThis, uint8_t data)1210 static int elnkCsrWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint8_t data) 1168 1211 { 1169 1212 int rc = VINF_SUCCESS; … … 1187 1230 * effect and will be overwritten when the card is taken out of reset. 1188 1231 */ 1189 Log (("#%d elnkCsrWrite: Card going into reset\n", ELNK_INSTANCE));1232 LogFunc(("#%d: Card going into reset\n", pThis->iInstance)); 1190 1233 pThis->fInReset = true; 1191 1234 … … 1199 1242 { 1200 1243 /* Card is being taken out of reset. */ 1201 Log (("#%d elnkCsrWrite: Card going out of reset\n", ELNK_INSTANCE));1244 LogFunc(("#%d: Card going out of reset\n", pThis->iInstance)); 1202 1245 STAM_COUNTER_INC(&pThis->StatResets); 1203 elnkSoftReset(p This);1246 elnkSoftReset(pDevIns, pThis); 1204 1247 } 1205 1248 pThis->AuxCmd.reset = val.reset; /* Update the reset bit, if nothing else. */ … … 1217 1260 /* Start/stop DMA as requested. */ 1218 1261 pThis->fDMA = fDMAR; 1219 PDMDevHlpDMASetDREQ(p This->CTX_SUFF(pDevIns), pThis->uIsaDma, fDMAR);1262 PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, fDMAR); 1220 1263 if (fDMAR) 1221 PDMDevHlpDMASchedule(p This->CTX_SUFF(pDevIns));1222 Log(("3C501#%d: DMARQ for channel %u set to %u\n", ELNK_INSTANCE, pThis->uIsaDma, fDMAR));1264 PDMDevHlpDMASchedule(pDevIns); 1265 Log(("3C501#%d: DMARQ for channel %u set to %u\n", pThis->iInstance, pThis->uIsaDma, fDMAR)); 1223 1266 } 1224 1267 #else … … 1250 1293 #ifdef LOG_ENABLED 1251 1294 static const char *apszBuffCntrl[4] = { "System", "Xmit then Recv", "Receive", "Loopback" }; 1252 Log(("3C501#%d: Packet buffer control `%s' -> `%s'\n", ELNK_INSTANCE, apszBuffCntrl[pThis->AuxCmd.buf_ctl], apszBuffCntrl[val.buf_ctl]));1295 Log(("3C501#%d: Packet buffer control `%s' -> `%s'\n", pThis->iInstance, apszBuffCntrl[pThis->AuxCmd.buf_ctl], apszBuffCntrl[val.buf_ctl])); 1253 1296 #endif 1254 1297 if (val.buf_ctl == EL_BCTL_XMT_RCV) 1255 1298 { 1256 1299 /* Transmit, then receive. */ 1257 Log2(("3C501#%d: Transmit %u bytes\n%Rhxs\nxmit_bsy=%u\n", ELNK_INSTANCE, ELNK_BUF_SIZE - pThis->uGPBufPtr, &pThis->abPacketBuf[pThis->uGPBufPtr], pThis->AuxStat.xmit_bsy));1300 Log2(("3C501#%d: Transmit %u bytes\n%Rhxs\nxmit_bsy=%u\n", pThis->iInstance, ELNK_BUF_SIZE - pThis->uGPBufPtr, &pThis->abPacketBuf[pThis->uGPBufPtr], pThis->AuxStat.xmit_bsy)); 1258 1301 fTransmit = true; 1259 1302 pThis->AuxStat.recv_bsy = 0; … … 1290 1333 1291 1334 /* There are multiple bits that affect interrupt state. Handle them now. */ 1292 elnkUpdateIrq(p This);1335 elnkUpdateIrq(pDevIns, pThis); 1293 1336 1294 1337 /* After fully updating register state, do a transmit (including loopback) or receive. */ 1295 1338 if (fTransmit) 1296 elnkTransmit(p This);1339 elnkTransmit(pDevIns, pThis); 1297 1340 else if (fReceive) 1298 1341 { 1299 1342 pThis->AuxStat.recv_bsy = 1; /* Receive Busy now set until a packet is received. */ 1300 elnkKickReceive(p This);1343 elnkKickReceive(pDevIns, pThis); 1301 1344 } 1302 1345 … … 1304 1347 } 1305 1348 1306 static int elIoWrite(P ELNKSTATE pThis, uint32_t addr, uint32_t val)1349 static int elIoWrite(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, uint32_t val) 1307 1350 { 1308 1351 int reg = addr & 0xf; 1309 1352 int rc = VINF_SUCCESS; 1310 1353 1311 Log2 (("#%d elIoWrite: addr=%#06x val=%#04x\n", ELNK_INSTANCE, addr, val & 0xff));1354 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 1312 1355 1313 1356 switch (reg) … … 1329 1372 /* If address filter just got enabled, receive may need a kick. */ 1330 1373 if (OldRcvCmd.adr_match == EL_ADRM_DISABLED && pThis->RcvCmd.adr_match != EL_ADRM_DISABLED) 1331 elnkKickReceive(p This);1374 elnkKickReceive(pDevIns, pThis); 1332 1375 Log2(("Receive Command register set to %02X\n", pThis->RcvCmdReg)); 1333 1376 break; … … 1361 1404 1362 1405 case 0x0e: /* Auxiliary Command (CSR). */ 1363 rc = elnkCsrWrite(p This, val);1406 rc = elnkCsrWrite(pDevIns, pThis, val); 1364 1407 break; 1365 1408 … … 1380 1423 } 1381 1424 1382 static uint32_t elIoRead(P ELNKSTATE pThis, uint32_t addr, int *pRC)1425 static uint32_t elIoRead(PPDMDEVINS pDevIns, PELNKSTATE pThis, uint32_t addr, int *pRC) 1383 1426 { 1384 1427 uint32_t val = UINT32_MAX; … … 1395 1438 pThis->RcvStat.stale = 1; /* Allows further reception. */ 1396 1439 pThis->IntrState.recv_intr = 0; /* Reading clears receive interrupt. */ 1397 elnkUpdateIrq(p This);1440 elnkUpdateIrq(pDevIns, pThis); 1398 1441 break; 1399 1442 … … 1404 1447 val = pThis->XmitStatReg; 1405 1448 pThis->IntrState.xmit_intr = 0; /* Reading clears transmit interrupt. */ 1406 elnkUpdateIrq(p This);1449 elnkUpdateIrq(pDevIns, pThis); 1407 1450 break; 1408 1451 … … 1440 1483 } 1441 1484 1442 elnkUpdateIrq(p This);1443 1444 Log2 (("#%d elIoRead: addr=%#06x val=%#04x\n", ELNK_INSTANCE, addr, val & 0xff));1485 elnkUpdateIrq(pDevIns, pThis); 1486 1487 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 1445 1488 return val; 1446 1489 } … … 1453 1496 elnkIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb) 1454 1497 { 1455 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE);1498 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1456 1499 int rc = VINF_SUCCESS; 1457 1500 uint8_t u8Lo, u8Hi; … … 1463 1506 { 1464 1507 case 1: 1465 *pu32 = elIoRead(p This, Port, &rc);1508 *pu32 = elIoRead(pDevIns, pThis, Port, &rc); 1466 1509 break; 1467 1510 case 2: 1468 1511 /* Manually split word access. */ 1469 u8Lo = elIoRead(p This, Port + 0, &rc);1512 u8Lo = elIoRead(pDevIns, pThis, Port + 0, &rc); 1470 1513 Assert(RT_SUCCESS(rc)); 1471 u8Hi = elIoRead(p This, Port + 1, &rc);1514 u8Hi = elIoRead(pDevIns, pThis, Port + 1, &rc); 1472 1515 Assert(RT_SUCCESS(rc)); 1473 1516 *pu32 = RT_MAKE_U16(u8Lo, u8Hi); 1474 1517 break; 1475 1518 default: 1476 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,1519 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 1477 1520 "elnkIOPortRead: unsupported operation size: offset=%#10x cb=%u\n", 1478 1521 Port, cb); 1479 1522 } 1480 1523 1481 Log2 (("#%d elnkIOPortRead: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", ELNK_INSTANCE, Port, *pu32, cb, rc));1524 Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc)); 1482 1525 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a); 1483 1526 return rc; … … 1491 1534 elnkIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb) 1492 1535 { 1493 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1536 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1494 1537 int rc = VINF_SUCCESS; 1495 1538 STAM_PROFILE_ADV_START(&pThis->CTX_SUFF_Z(StatIOWrite), a); … … 1500 1543 { 1501 1544 case 1: 1502 rc = elIoWrite(p This, Port, RT_LOBYTE(u32));1545 rc = elIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32)); 1503 1546 break; 1504 1547 case 2: 1505 1548 /* Manually split word access. */ 1506 rc = elIoWrite(p This, Port + 0, RT_LOBYTE(u32));1549 rc = elIoWrite(pDevIns, pThis, Port + 0, RT_LOBYTE(u32)); 1507 1550 if (!RT_SUCCESS(rc)) 1508 1551 break; 1509 rc = elIoWrite(p This, Port + 1, RT_HIBYTE(u32));1552 rc = elIoWrite(pDevIns, pThis, Port + 1, RT_HIBYTE(u32)); 1510 1553 break; 1511 1554 default: 1512 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,1555 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 1513 1556 "elnkIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n", 1514 1557 Port, cb); 1515 1558 } 1516 1559 1517 Log2 (("#%d elnkIOPortWrite: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", ELNK_INSTANCE, Port, u32, cb, rc));1560 Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc)); 1518 1561 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a); 1519 1562 return rc; … … 1566 1609 * reading from the buffer. 1567 1610 */ 1568 dma_mode = PDMDevHlpDMAGetChannelMode(p This->CTX_SUFF(pDevIns), pThis->uIsaDma);1611 dma_mode = PDMDevHlpDMAGetChannelMode(pDevIns, pThis->uIsaDma); 1569 1612 dma_type = GET_MODE_XTYP(dma_mode); 1570 1613 LogFlowFunc(("dma_mode=%d, dma_type=%d, dma_pos=%u, dma_len=%u, GPBP=%u\n", dma_mode, dma_type, dma_pos, dma_len, pThis->uGPBufPtr)); … … 1575 1618 { 1576 1619 /* Write transfer type. Reading from device, writing to memory. */ 1577 rc = PDMDevHlpDMAWriteMemory(p This->CTX_SUFF(pDevIns), nchan,1620 rc = PDMDevHlpDMAWriteMemory(pDevIns, nchan, 1578 1621 &pThis->abPacketBuf[ELNK_GP(pThis)], 1579 1622 dma_pos, cbToXfer, &cbXferred); … … 1584 1627 { 1585 1628 /* Read of Verify transfer type. Reading from memory, writing to device. */ 1586 rc = PDMDevHlpDMAReadMemory(p This->CTX_SUFF(pDevIns), nchan,1629 rc = PDMDevHlpDMAReadMemory(pDevIns, nchan, 1587 1630 &pThis->abPacketBuf[ELNK_GP(pThis)], 1588 1631 dma_pos, cbToXfer, &cbXferred); … … 1597 1640 { 1598 1641 Log2(("DMA completed\n")); 1599 PDMDevHlpDMASetDREQ(p This->CTX_SUFF(pDevIns), pThis->uIsaDma, 0);1642 PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, 0); 1600 1643 pThis->IntrState.dma_intr = 1; 1601 1644 pThis->AuxStat.dma_done = 1; 1602 elnkUpdateIrq(p This);1645 elnkUpdateIrq(pDevIns, pThis); 1603 1646 } 1604 1647 else 1605 1648 { 1606 1649 Log(("DMA continuing: GPBufPtr=%u, lastpos=%u, cbXferred=%u\n", pThis->uGPBufPtr, uLastPos, cbXferred)); 1607 PDMDevHlpDMASchedule(p This->CTX_SUFF(pDevIns));1650 PDMDevHlpDMASchedule(pDevIns); 1608 1651 } 1609 1652 … … 1625 1668 { 1626 1669 RT_NOREF(pvUser); 1627 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1670 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1628 1671 int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); 1629 1672 AssertReleaseRC(rc); … … 1638 1681 { 1639 1682 LogRel(("3C501#%d: The link is back up again after the restore.\n", 1640 p DevIns->iInstance));1641 Log (("#%d elnkTimerRestore: Clearing ERR and CERR after load. cLinkDownReported=%d\n",1642 p DevIns->iInstance, pThis->cLinkDownReported));1683 pThis->iInstance)); 1684 LogFunc(("#%d: Clearing ERR and CERR after load. cLinkDownReported=%d\n", 1685 pThis->iInstance, pThis->cLinkDownReported)); 1643 1686 pThis->Led.Actual.s.fError = 0; 1644 1687 } … … 1646 1689 else 1647 1690 Log(("#%d elnkTimerRestore: cLinkDownReported=%d, wait another 1500ms...\n", 1648 p DevIns->iInstance, pThis->cLinkDownReported));1691 pThis->iInstance, pThis->cLinkDownReported)); 1649 1692 1650 1693 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 1659 1702 static DECLCALLBACK(void) elnkInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs) 1660 1703 { 1661 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1704 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1662 1705 bool fStationAddr = false; 1663 1706 bool fRecvBuffer = false; … … 1679 1722 */ 1680 1723 pHlp->pfnPrintf(pHlp, 1681 "3C501 #%d: port=%RTiop IRQ=%u DMA=%u mac-cfg=%RTmac %s%s\n",1682 p DevIns->iInstance,1724 "3C501 #%d: port=%RTiop IRQ=%u DMA=%u mac-cfg=%RTmac%s%s %s\n", 1725 pThis->iInstance, 1683 1726 pThis->IOPortBase, pThis->uIsaIrq, pThis->uIsaDma, &pThis->MacConfigured, 1684 pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " R0" : ""); 1727 pDevIns->fRCEnabled ? " RC" : "", pDevIns->fR0Enabled ? " RZ" : "", 1728 pThis->fDriverAttached ? "attached" : "unattached!"); 1685 1729 1686 1730 int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */ … … 1689 1733 pHlp->pfnPrintf(pHlp, " GP Buf Ptr : %u (masked %u)\n", pThis->uGPBufPtr, ELNK_GP(pThis)); 1690 1734 pHlp->pfnPrintf(pHlp, " RCV Buf Ptr: %u\n", pThis->uRCVBufPtr); 1691 pHlp->pfnPrintf(pHlp, " Recv Command: %02X 1692 pHlp->pfnPrintf(pHlp, " Xmit Command: %02X 1693 pHlp->pfnPrintf(pHlp, " Aux Command: %02X 1735 pHlp->pfnPrintf(pHlp, " Recv Command: %02X Recv Status: %02X\n", pThis->RcvCmdReg, pThis->RcvStatReg); 1736 pHlp->pfnPrintf(pHlp, " Xmit Command: %02X Xmit Status: %02X\n", pThis->XmitCmdReg, pThis->XmitStatReg); 1737 pHlp->pfnPrintf(pHlp, " Aux Command: %02X Aux Status: %02X\n", pThis->AuxCmdReg, pThis->AuxStatReg); 1694 1738 1695 1739 pHlp->pfnPrintf(pHlp, " Address matching: %s\n", apszAddrMatch[pThis->RcvCmd.adr_match]); 1696 1740 pHlp->pfnPrintf(pHlp, " Buffer control : %s\n", apszBuffCntrl[pThis->AuxCmd.buf_ctl]); 1697 1741 pHlp->pfnPrintf(pHlp, " Interrupt state : xmit=%u recv=%u dma=%u\n", pThis->IntrState.xmit_intr, pThis->IntrState.recv_intr, pThis->IntrState.dma_intr); 1742 if (pThis->cLinkDownReported) 1743 pHlp->pfnPrintf(pHlp, " Link down count : %d\n", pThis->cLinkDownReported); 1698 1744 1699 1745 /* Dump the station address. */ … … 1730 1776 1731 1777 1732 static void elnkR3HardReset(P ELNKSTATE pThis)1733 { 1734 LogFlow (("#%d elnkHardReset:\n", ELNK_INSTANCE));1778 static void elnkR3HardReset(PPDMDEVINS pDevIns, PELNKSTATE pThis) 1779 { 1780 LogFlowFunc(("#%d:\n", pThis->iInstance)); 1735 1781 1736 1782 /* Initialize the PROM */ … … 1747 1793 pThis->uRCVBufPtr = 0; 1748 1794 1749 elnkSoftReset(p This);1795 elnkSoftReset(pDevIns, pThis); 1750 1796 } 1751 1797 … … 1759 1805 * renegotiate any DHCP lease. 1760 1806 * 1807 * @param pDevIns The device instance. 1761 1808 * @param pThis The device instance data. 1762 1809 */ 1763 static void elnkTempLinkDown(P ELNKSTATE pThis)1810 static void elnkTempLinkDown(PPDMDEVINS pDevIns, PELNKSTATE pThis) 1764 1811 { 1765 1812 if (pThis->fLinkUp) … … 1768 1815 pThis->cLinkDownReported = 0; 1769 1816 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 1770 int rc = PDMDevHlpTimerSetMillies( ELNKSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);1817 int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay); 1771 1818 AssertRC(rc); 1772 1819 } … … 1782 1829 { 1783 1830 RT_NOREF(uPass); 1784 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1831 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1785 1832 pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured)); 1786 1833 return VINF_SSM_DONT_CALL_AGAIN; … … 1795 1842 { 1796 1843 RT_NOREF(pSSM); 1797 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1844 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1798 1845 1799 1846 int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); … … 1810 1857 static DECLCALLBACK(int) elnkSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 1811 1858 { 1812 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1859 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1813 1860 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 1814 1861 … … 1838 1885 static DECLCALLBACK(int) elnkLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 1839 1886 { 1840 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);1887 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1841 1888 RT_NOREF(pSSM); 1842 1889 … … 1855 1902 static DECLCALLBACK(int) elnkLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass) 1856 1903 { 1857 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 1858 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 1904 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 1905 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 1906 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 1859 1907 1860 1908 if ( SSM_VERSION_MAJOR_CHANGED(uVersion, ELNK_SAVEDSTATE_VERSION) … … 1887 1935 if ( memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac)) 1888 1936 && (uPass == 0 || !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) ) 1889 LogRel(("3C501#%u: The mac address differs: config=%RTmac saved=%RTmac\n", ELNK_INSTANCE, &pThis->MacConfigured, &Mac));1937 LogRel(("3C501#%u: The mac address differs: config=%RTmac saved=%RTmac\n", pThis->iInstance, &pThis->MacConfigured, &Mac)); 1890 1938 1891 1939 if (uPass == SSM_PASS_FINAL) 1892 1940 { 1893 1941 /* update promiscuous mode. */ 1894 if (pThis ->pDrvR3)1895 pThis ->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, 0 /* promiscuous enabled */);1942 if (pThisCC->pDrv) 1943 pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, 0 /* promiscuous enabled */); 1896 1944 1897 1945 /* Indicate link down to the guest OS that all network connections have 1898 1946 been lost, unless we've been teleported here. */ 1899 1947 if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) 1900 elnkTempLinkDown(p This);1948 elnkTempLinkDown(pDevIns, pThis); 1901 1949 } 1902 1950 … … 1914 1962 * 1915 1963 * @returns VBox status code. 1916 * @param p ThisThe device instance data.1917 * /1918 static int elnkCanReceive(PELNKSTATE pThis) 1919 { 1920 PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis); 1964 * @param pDevIns The device instance data. 1965 * @param pThis The shared instance data. 1966 */ 1967 static int elnkCanReceive(PPDMDEVINS pDevIns, PELNKSTATE pThis) 1968 { 1921 1969 int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); 1922 1970 AssertReleaseRC(rc); … … 1959 2007 static DECLCALLBACK(int) elnkNet_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies) 1960 2008 { 1961 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown); 1962 PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis); 1963 1964 int rc = elnkCanReceive(pThis); 2009 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown); 2010 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2011 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2012 2013 int rc = elnkCanReceive(pDevIns, pThis); 1965 2014 if (RT_SUCCESS(rc)) 1966 2015 return VINF_SUCCESS; … … 1972 2021 STAM_PROFILE_START(&pThis->StatRxOverflow, a); 1973 2022 VMSTATE enmVMState; 1974 while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(p This->CTX_SUFF(pDevIns))) == VMSTATE_RUNNING2023 while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING 1975 2024 || enmVMState == VMSTATE_RUNNING_LS)) 1976 2025 { 1977 int rc2 = elnkCanReceive(p This);2026 int rc2 = elnkCanReceive(pDevIns, pThis); 1978 2027 if (RT_SUCCESS(rc2)) 1979 2028 { … … 1981 2030 break; 1982 2031 } 1983 LogFlow (("elnkNet_WaitReceiveAvail:waiting cMillies=%u...\n", cMillies));2032 LogFlowFunc(("waiting cMillies=%u...\n", cMillies)); 1984 2033 1985 2034 /* Start the poll timer once which will remain active as long fMaybeOutOfSpace … … 2002 2051 static DECLCALLBACK(int) elnkNet_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb) 2003 2052 { 2004 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown); 2005 PPDMDEVINS pDevIns = ELNKSTATE_2_DEVINS(pThis); 2006 int rc; 2053 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown); 2054 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2055 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2056 int rc; 2007 2057 2008 2058 STAM_PROFILE_ADV_START(&pThis->StatReceive, a); … … 2012 2062 if (cb > 50) /* unqualified guess */ 2013 2063 pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1; 2014 elnkReceiveLocked(p This, (const uint8_t *)pvBuf, cb, false);2064 elnkReceiveLocked(pDevIns, pThis, (const uint8_t *)pvBuf, cb, false); 2015 2065 pThis->Led.Actual.s.fReading = 0; 2016 2066 … … 2027 2077 static DECLCALLBACK(void) elnkNet_XmitPending(PPDMINETWORKDOWN pInterface) 2028 2078 { 2029 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkDown); 2030 elnkXmitBuffer(pThis, true /*fOnWorkerThread*/); 2079 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkDown); 2080 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2081 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2082 2083 elnkXmitBuffer(pDevIns, pThis, pThisCC, true /*fOnWorkerThread*/); 2031 2084 } 2032 2085 … … 2039 2092 static DECLCALLBACK(int) elnkGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac) 2040 2093 { 2041 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig); 2094 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig); 2095 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2096 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2097 2098 LogFlowFunc(("#%d\n", pThis->iInstance)); 2042 2099 /// @todo This is broken!! We can't properly get the MAC address set by the guest 2043 2100 #if 0 … … 2055 2112 static DECLCALLBACK(PDMNETWORKLINKSTATE) elnkGetLinkState(PPDMINETWORKCONFIG pInterface) 2056 2113 { 2057 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig); 2114 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig); 2115 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2116 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2117 2058 2118 if (pThis->fLinkUp && !pThis->fLinkTempDown) 2059 2119 return PDMNETWORKLINKSTATE_UP; … … 2072 2132 static DECLCALLBACK(int) elnkSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState) 2073 2133 { 2074 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, INetworkConfig); 2075 bool fLinkUp; 2134 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, INetworkConfig); 2135 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2136 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2137 bool fLinkUp; 2076 2138 2077 2139 AssertMsgReturn(enmState > PDMNETWORKLINKSTATE_INVALID && enmState <= PDMNETWORKLINKSTATE_DOWN_RESUME, … … 2080 2142 if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME) 2081 2143 { 2082 elnkTempLinkDown(p This);2144 elnkTempLinkDown(pDevIns, pThis); 2083 2145 /* 2084 2146 * Note that we do not notify the driver about the link state change because … … 2099 2161 pThis->cLinkDownReported = 0; 2100 2162 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 2101 int rc = PDMDevHlpTimerSetMillies( ELNKSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);2163 int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay); 2102 2164 AssertRC(rc); 2103 2165 } … … 2108 2170 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 2109 2171 } 2110 Assert(!PDMDevHlpCritSectIsOwner( ELNKSTATE_2_DEVINS(pThis), &pThis->CritSect));2111 if (pThis ->pDrvR3)2112 pThis ->pDrvR3->pfnNotifyLinkChanged(pThis->pDrvR3, enmState);2172 Assert(!PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); 2173 if (pThisCC->pDrv) 2174 pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState); 2113 2175 } 2114 2176 return VINF_SUCCESS; … … 2123 2185 static DECLCALLBACK(int) elnkQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed) 2124 2186 { 2125 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, ILeds); 2187 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, ILeds); 2188 PPDMDEVINS pDevIns = pThisCC->pDevIns; 2189 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2126 2190 if (iLUN == 0) 2127 2191 { … … 2140 2204 static DECLCALLBACK(void *) elnkQueryInterface(struct PDMIBASE *pInterface, const char *pszIID) 2141 2205 { 2142 PELNKSTATE pThis = RT_FROM_MEMBER(pInterface, ELNKSTATE, IBase);2143 Assert(&pThis ->IBase == pInterface);2144 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis ->IBase);2145 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis ->INetworkDown);2146 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis ->INetworkConfig);2147 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis ->ILeds);2206 PELNKSTATECC pThisCC = RT_FROM_MEMBER(pInterface, ELNKSTATECC, IBase); 2207 Assert(&pThisCC->IBase == pInterface); 2208 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase); 2209 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown); 2210 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig); 2211 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds); 2148 2212 return NULL; 2149 2213 } … … 2155 2219 * @interface_method_impl{PDMDEVREG,pfnPowerOff} 2156 2220 */ 2157 static DECLCALLBACK(void) elnk PowerOff(PPDMDEVINS pDevIns)2221 static DECLCALLBACK(void) elnkR3PowerOff(PPDMDEVINS pDevIns) 2158 2222 { 2159 2223 /* Poke thread waiting for buffer space. */ … … 2167 2231 * One port on the network card has been disconnected from the network. 2168 2232 */ 2169 static DECLCALLBACK(void) elnkDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 2170 { 2233 static DECLCALLBACK(void) elnkR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 2234 { 2235 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2236 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 2171 2237 RT_NOREF(fFlags); 2172 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 2173 Log(("#%d elnkDetach:\n", ELNK_INSTANCE)); 2238 LogFlowFunc(("#%d:\n", pThis->iInstance)); 2174 2239 2175 2240 AssertLogRelReturnVoid(iLUN == 0); … … 2181 2246 * Zero some important members. 2182 2247 */ 2183 pThis->pDrvBase = NULL; 2184 pThis->pDrvR3 = NULL; 2185 pThis->pDrvR0 = NIL_RTR0PTR; 2186 pThis->pDrvRC = NIL_RTRCPTR; 2248 pThis->fDriverAttached = false; 2249 pThisCC->pDrvBase = NULL; 2250 pThisCC->pDrv = NULL; 2187 2251 2188 2252 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 2194 2258 * One port on the network card has been connected to a network. 2195 2259 */ 2196 static DECLCALLBACK(int) elnkAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 2197 { 2260 static DECLCALLBACK(int) elnkR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 2261 { 2262 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2263 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 2198 2264 RT_NOREF(fFlags); 2199 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 2200 LogFlow(("#%d elnkAttach:\n", ELNK_INSTANCE)); 2265 LogFlowFunc(("#%d:\n", pThis->iInstance)); 2201 2266 2202 2267 AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN); … … 2208 2273 * Attach the driver. 2209 2274 */ 2210 int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis ->IBase, &pThis->pDrvBase, "Network Port");2275 int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port"); 2211 2276 if (RT_SUCCESS(rc)) 2212 2277 { 2213 pThis ->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);2214 AssertMsgStmt(pThis ->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),2278 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP); 2279 AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"), 2215 2280 rc = VERR_PDM_MISSING_INTERFACE_BELOW); 2216 pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP); 2217 pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP); 2281 pThis->fDriverAttached = true; 2218 2282 } 2219 2283 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER … … 2222 2286 /* This should never happen because this function is not called 2223 2287 * if there is no driver to attach! */ 2224 Log(("#%d No attached driver!\n", ELNK_INSTANCE));2288 Log(("#%d: No attached driver!\n", pThis->iInstance)); 2225 2289 } 2226 2290 … … 2231 2295 */ 2232 2296 if (RT_SUCCESS(rc)) 2233 elnkTempLinkDown(p This);2297 elnkTempLinkDown(pDevIns, pThis); 2234 2298 2235 2299 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 2241 2305 * @interface_method_impl{PDMDEVREG,pfnSuspend} 2242 2306 */ 2243 static DECLCALLBACK(void) elnk Suspend(PPDMDEVINS pDevIns)2307 static DECLCALLBACK(void) elnkR3Suspend(PPDMDEVINS pDevIns) 2244 2308 { 2245 2309 /* Poke thread waiting for buffer space. */ … … 2251 2315 * @interface_method_impl{PDMDEVREG,pfnReset} 2252 2316 */ 2253 static DECLCALLBACK(void) elnkR eset(PPDMDEVINS pDevIns)2254 { 2255 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);2317 static DECLCALLBACK(void) elnkR3Reset(PPDMDEVINS pDevIns) 2318 { 2319 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2256 2320 if (pThis->fLinkTempDown) 2257 2321 { … … 2262 2326 2263 2327 /** @todo How to flush the queues? */ 2264 elnkR3HardReset(p This);2328 elnkR3HardReset(pDevIns, pThis); 2265 2329 } 2266 2330 … … 2269 2333 * @interface_method_impl{PDMDEVREG,pfnRelocate} 2270 2334 */ 2271 static DECLCALLBACK(void) elnkRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta) 2272 { 2273 RT_NOREF(offDelta); 2274 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 2275 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 2335 static DECLCALLBACK(void) elnkR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta) 2336 { 2337 PELNKSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PELNKSTATERC); 2338 pThisRC->pDrv += offDelta; 2276 2339 } 2277 2340 … … 2280 2343 * @interface_method_impl{PDMDEVREG,pfnDestruct} 2281 2344 */ 2282 static DECLCALLBACK(int) elnk Destruct(PPDMDEVINS pDevIns)2345 static DECLCALLBACK(int) elnkR3Destruct(PPDMDEVINS pDevIns) 2283 2346 { 2284 2347 PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns); 2285 PELNKSTATE pThis = PDM INS_2_DATA(pDevIns, PELNKSTATE);2348 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2286 2349 2287 2350 if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect)) … … 2299 2362 * @interface_method_impl{PDMDEVREG,pfnConstruct} 2300 2363 */ 2301 static DECLCALLBACK(int) elnk Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)2364 static DECLCALLBACK(int) elnkR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg) 2302 2365 { 2303 2366 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); 2304 PELNKSTATE pThis = PDMINS_2_DATA(pDevIns, PELNKSTATE); 2305 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 2367 PELNKSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PELNKSTATE); 2368 PELNKSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PELNKSTATECC); 2369 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 2306 2370 PPDMIBASE pBase; 2307 2371 char szTmp[128]; … … 2314 2378 pThis->hEventOutOfRxSpace = NIL_RTSEMEVENT; 2315 2379 pThis->hIoPortsIsa = NIL_IOMIOPORTHANDLE; 2380 pThisCC->pDevIns = pDevIns; 2316 2381 2317 2382 /* … … 2367 2432 * Initialize data (most of it anyway). 2368 2433 */ 2369 pThis->pDevInsR3 = pDevIns; 2370 pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns); 2371 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 2372 pThis->Led.u32Magic = PDMLED_MAGIC; 2434 pThis->Led.u32Magic = PDMLED_MAGIC; 2373 2435 /* IBase */ 2374 pThis ->IBase.pfnQueryInterface = elnkQueryInterface;2436 pThisCC->IBase.pfnQueryInterface = elnkQueryInterface; 2375 2437 /* INetworkPort */ 2376 pThis ->INetworkDown.pfnWaitReceiveAvail = elnkNet_WaitReceiveAvail;2377 pThis ->INetworkDown.pfnReceive = elnkNet_Receive;2378 pThis ->INetworkDown.pfnXmitPending = elnkNet_XmitPending;2438 pThisCC->INetworkDown.pfnWaitReceiveAvail = elnkNet_WaitReceiveAvail; 2439 pThisCC->INetworkDown.pfnReceive = elnkNet_Receive; 2440 pThisCC->INetworkDown.pfnXmitPending = elnkNet_XmitPending; 2379 2441 /* INetworkConfig */ 2380 pThis ->INetworkConfig.pfnGetMac = elnkGetMac;2381 pThis ->INetworkConfig.pfnGetLinkState = elnkGetLinkState;2382 pThis ->INetworkConfig.pfnSetLinkState = elnkSetLinkState;2442 pThisCC->INetworkConfig.pfnGetMac = elnkGetMac; 2443 pThisCC->INetworkConfig.pfnGetLinkState = elnkGetLinkState; 2444 pThisCC->INetworkConfig.pfnSetLinkState = elnkSetLinkState; 2383 2445 /* ILeds */ 2384 pThis ->ILeds.pfnQueryStatusLed = elnkQueryStatusLed;2446 pThisCC->ILeds.pfnQueryStatusLed = elnkQueryStatusLed; 2385 2447 2386 2448 /* … … 2445 2507 * Register the info item. 2446 2508 */ 2447 RTStrPrintf(szTmp, sizeof(szTmp), "elnk%d", p DevIns->iInstance);2509 RTStrPrintf(szTmp, sizeof(szTmp), "elnk%d", pThis->iInstance); 2448 2510 PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "3C501 info", elnkInfo); 2449 2511 … … 2451 2513 * Attach status driver (optional). 2452 2514 */ 2453 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis ->IBase, &pBase, "Status Port");2515 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port"); 2454 2516 if (RT_SUCCESS(rc)) 2455 2517 pThis->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS); … … 2464 2526 * Attach driver. 2465 2527 */ 2466 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis ->IBase, &pThis->pDrvBase, "Network Port");2528 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port"); 2467 2529 if (RT_SUCCESS(rc)) 2468 2530 { 2469 pThis ->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);2470 AssertMsgReturn(pThis ->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),2531 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP); 2532 AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"), 2471 2533 VERR_PDM_MISSING_INTERFACE_BELOW); 2472 pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP); 2473 pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP); 2534 pThis->fDriverAttached = true; 2474 2535 } 2475 2536 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER … … 2485 2546 * Reset the device state. (Do after attaching.) 2486 2547 */ 2487 elnkR3HardReset(p This);2548 elnkR3HardReset(pDevIns, pThis); 2488 2549 2489 2550 /* … … 2562 2623 /* .uSharedVersion = */ 42, 2563 2624 /* .cbInstanceShared = */ sizeof(ELNKSTATE), 2564 /* .cbInstanceCC = */ 0,2565 /* .cbInstanceRC = */ 0,2625 /* .cbInstanceCC = */ sizeof(ELNKSTATECC), 2626 /* .cbInstanceRC = */ sizeof(ELNKSTATERC), 2566 2627 /* .cMaxPciDevices = */ 0, 2567 2628 /* .cMaxMsixVectors = */ 0, … … 2570 2631 /* .pszRCMod = */ "VBoxDDRC.rc", 2571 2632 /* .pszR0Mod = */ "VBoxDDR0.r0", 2572 /* .pfnConstruct = */ elnk Construct,2573 /* .pfnDestruct = */ elnk Destruct,2574 /* .pfnRelocate = */ elnkR elocate,2633 /* .pfnConstruct = */ elnkR3Construct, 2634 /* .pfnDestruct = */ elnkR3Destruct, 2635 /* .pfnRelocate = */ elnkR3Relocate, 2575 2636 /* .pfnMemSetup = */ NULL, 2576 2637 /* .pfnPowerOn = */ NULL, 2577 /* .pfnReset = */ elnkR eset,2578 /* .pfnSuspend = */ elnk Suspend,2638 /* .pfnReset = */ elnkR3Reset, 2639 /* .pfnSuspend = */ elnkR3Suspend, 2579 2640 /* .pfnResume = */ NULL, 2580 /* .pfnAttach = */ elnk Attach,2581 /* .pfnDetach = */ elnk Detach,2641 /* .pfnAttach = */ elnkR3Attach, 2642 /* .pfnDetach = */ elnkR3Detach, 2582 2643 /* .pfnQueryInterface = */ NULL, 2583 2644 /* .pfnInitComplete = */ NULL, 2584 /* .pfnPowerOff = */ elnk PowerOff,2645 /* .pfnPowerOff = */ elnkR3PowerOff, 2585 2646 /* .pfnSoftReset = */ NULL, 2586 2647 /* .pfnReserved0 = */ NULL, -
trunk/src/VBox/Devices/Network/DevDP8390.cpp
r93590 r93601 355 355 /** Maximum frame size we handle */ 356 356 #define MAX_FRAME 1536 357 358 #define DPNICSTATE_2_DEVINS(pThis) ((pThis)->CTX_SUFF(pDevIns))359 #define DPNIC_INSTANCE (DPNICSTATE_2_DEVINS(pThis)->iInstance)360 357 361 358 /* Size of the local RAM. */ … … 831 828 /** 832 829 * DP8390-based card state. 833 *834 * @extends PDMPCIDEV835 * @implements PDMIBASE836 * @implements PDMINETWORKDOWN837 * @implements PDMINETWORKCONFIG838 * @implements PDMILEDPORTS839 830 */ 840 831 typedef struct DPNICSTATE 841 832 { 842 /** Pointer to the device instance - R3. */843 PPDMDEVINSR3 pDevInsR3;844 /** Pointer to the connector of the attached network driver - R3. */845 PPDMINETWORKUPR3 pDrvR3;846 /** Pointer to the attached network driver. */847 R3PTRTYPE(PPDMIBASE) pDrvBase;848 /** LUN\#0 + status LUN: The base interface. */849 PDMIBASE IBase;850 /** LUN\#0: The network port interface. */851 PDMINETWORKDOWN INetworkDown;852 /** LUN\#0: The network config port interface. */853 PDMINETWORKCONFIG INetworkConfig;854 833 /** Restore timer. 855 834 * This is used to disconnect and reconnect the link after a restore. */ 856 835 TMTIMERHANDLE hTimerRestore; 857 858 /** Pointer to the device instance - R0. */859 PPDMDEVINSR0 pDevInsR0;860 /** Receive signaller - R0. */861 PPDMINETWORKUPR0 pDrvR0;862 863 /** Pointer to the device instance - RC. */864 PPDMDEVINSRC pDevInsRC;865 /** Receive signaller - RC. */866 PPDMINETWORKUPRC pDrvRC;867 836 868 837 /** Transmit signaller. */ … … 921 890 RTMAC MacConfigured; 922 891 892 /** Set if DPNICSTATER3::pDrv is not NULL. */ 893 bool fDriverAttached; 923 894 /** The LED. */ 924 895 PDMLED Led; … … 983 954 984 955 956 /** 957 * DP8390 state for ring-3. 958 * 959 * @implements PDMIBASE 960 * @implements PDMINETWORKDOWN 961 * @implements PDMINETWORKCONFIG 962 * @implements PDMILEDPORTS 963 */ 964 typedef struct DPNICSTATER3 965 { 966 /** Pointer to the device instance. */ 967 PPDMDEVINSR3 pDevIns; 968 /** Pointer to the connector of the attached network driver. */ 969 PPDMINETWORKUPR3 pDrv; 970 /** Pointer to the attached network driver. */ 971 R3PTRTYPE(PPDMIBASE) pDrvBase; 972 /** LUN\#0 + status LUN: The base interface. */ 973 PDMIBASE IBase; 974 /** LUN\#0: The network port interface. */ 975 PDMINETWORKDOWN INetworkDown; 976 /** LUN\#0: The network config port interface. */ 977 PDMINETWORKCONFIG INetworkConfig; 978 979 /** Status LUN: The LED ports. */ 980 PDMILEDPORTS ILeds; 981 /** Partner of ILeds. */ 982 R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector; 983 } DPNICSTATER3; 984 /** Pointer to a DP8390 state structure for ring-3. */ 985 typedef DPNICSTATER3 *PDPNICSTATER3; 986 987 988 /** 989 * DP8390 state for ring-0. 990 */ 991 typedef struct DPNICSTATER0 992 { 993 /** Pointer to the connector of the attached network driver. */ 994 PPDMINETWORKUPR0 pDrv; 995 } DPNICSTATER0; 996 /** Pointer to a DP8390 state structure for ring-0. */ 997 typedef DPNICSTATER0 *PDPNICSTATER0; 998 999 1000 /** 1001 * DP8390 state for raw-mode. 1002 */ 1003 typedef struct DPNICSTATERC 1004 { 1005 /** Pointer to the connector of the attached network driver. */ 1006 PPDMINETWORKUPRC pDrv; 1007 } DPNICSTATERC; 1008 /** Pointer to a DP8390 state structure for raw-mode. */ 1009 typedef DPNICSTATERC *PDPNICSTATERC; 1010 1011 1012 /** The DP8390 state structure for the current context. */ 1013 typedef CTX_SUFF(DPNICSTATE) DPNICSTATECC; 1014 /** Pointer to a DP8390 state structure for the current 1015 * context. */ 1016 typedef CTX_SUFF(PDPNICSTATE) PDPNICSTATECC; 1017 1018 985 1019 #ifndef VBOX_DEVICE_STRUCT_TESTCASE 986 1020 … … 990 1024 *********************************************************************************************************************************/ 991 1025 992 static int dp8390CoreAsyncXmitLocked(P DPNICSTATE pThis, bool fOnWorkerThread);1026 static int dp8390CoreAsyncXmitLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PDPNICSTATECC pThisCC, bool fOnWorkerThread); 993 1027 994 1028 /** … … 999 1033 DECLINLINE(bool) dp8390IsLinkUp(PDPNICSTATE pThis) 1000 1034 { 1001 return pThis-> pDrvR3&& !pThis->fLinkTempDown && pThis->fLinkUp;1035 return pThis->fDriverAttached && !pThis->fLinkTempDown && pThis->fLinkUp; 1002 1036 } 1003 1037 … … 1184 1218 * Update the device IRQ line based on internal state. 1185 1219 */ 1186 static void dp8390CoreUpdateIrq(P DPNICSTATE pThis)1220 static void dp8390CoreUpdateIrq(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 1187 1221 { 1188 1222 bool fCoreIrqActive = false; … … 1207 1241 fNicIrqActive = (fCoreIrqActive && !pThis->ga.gacfr.nim) || (pThis->ga.streg.dtc && !pThis->ga.gacfr.tcm); 1208 1242 1209 Log2Func(("#%d set irq fNicIrqActive=%d (fCoreIrqActive=%d, fGaIrq=%d)\n", DPNIC_INSTANCE, fNicIrqActive, fCoreIrqActive, pThis->ga.fGaIrq));1243 Log2Func(("#%d set irq fNicIrqActive=%d (fCoreIrqActive=%d, fGaIrq=%d)\n", pThis->iInstance, fNicIrqActive, fCoreIrqActive, pThis->ga.fGaIrq)); 1210 1244 1211 1245 /* The IRQ line typically does not change. */ 1212 1246 if (RT_UNLIKELY(fNicIrqActive != pThis->fNicIrqActive)) 1213 1247 { 1214 LogFunc(("#%d IRQ=%d, state=%d\n", DPNIC_INSTANCE, pThis->uIsaIrq, fNicIrqActive));1248 LogFunc(("#%d IRQ=%d, state=%d\n", pThis->iInstance, pThis->uIsaIrq, fNicIrqActive)); 1215 1249 /// @todo Handle IRQ 2/9 elsewhere 1216 PDMDevHlpISASetIrq( DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq == 2 ? 9 : pThis->uIsaIrq, fNicIrqActive);1250 PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq == 2 ? 9 : pThis->uIsaIrq, fNicIrqActive); 1217 1251 pThis->fNicIrqActive = fNicIrqActive; 1218 1252 } … … 1224 1258 * Perform a software reset of the NIC. 1225 1259 */ 1226 static void dp8390CoreReset(P DPNICSTATE pThis)1227 { 1228 LogFlowFunc(("#%d:\n", DPNIC_INSTANCE));1260 static void dp8390CoreReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 1261 { 1262 LogFlowFunc(("#%d:\n", pThis->iInstance)); 1229 1263 1230 1264 /* DP8390 or DP83901A datasheet, section 11.0. */ … … 1243 1277 1244 1278 /* Make sure the IRQ line us updated. */ 1245 dp8390CoreUpdateIrq(p This);1279 dp8390CoreUpdateIrq(pDevIns, pThis); 1246 1280 } 1247 1281 1248 1282 #ifdef IN_RING3 1249 1283 1250 static DECLCALLBACK(void) dp8390 WakeupReceive(PPDMDEVINS pDevIns)1251 { 1252 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);1253 LogFlowFunc(("#%d\n", DPNIC_INSTANCE));1284 static DECLCALLBACK(void) dp8390R3WakeupReceive(PPDMDEVINS pDevIns) 1285 { 1286 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 1287 LogFlowFunc(("#%d\n", pThis->iInstance)); 1254 1288 STAM_COUNTER_INC(&pThis->StatRxOverflowWakeup); 1255 1289 if (pThis->hEventOutOfRxSpace != NIL_RTSEMEVENT) … … 1264 1298 { 1265 1299 RT_NOREF(pvUser); 1266 dp8390 WakeupReceive(pDevIns);1300 dp8390R3WakeupReceive(pDevIns); 1267 1301 } 1268 1302 … … 1276 1310 if ((RT_LOBYTE(addr) + cb) > 256) 1277 1311 { 1278 LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", DPNIC_INSTANCE, addr, cb));1312 LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", pThis->iInstance, addr, cb)); 1279 1313 cb = 256 - RT_LOBYTE(addr); 1280 1314 } … … 1292 1326 } 1293 1327 else 1294 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1328 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1295 1329 } 1296 1330 else if (pThis->uDevType == DEV_NE2000) … … 1305 1339 } 1306 1340 else 1307 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1341 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1308 1342 } 1309 1343 else if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013)) … … 1314 1348 memcpy(pDst, &pThis->abLocalRAM[addr], cb); 1315 1349 else 1316 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1350 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1317 1351 } 1318 1352 else if (pThis->uDevType == DEV_3C503) … … 1328 1362 } 1329 1363 else 1330 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1364 LogFunc(("#%d: Ignoring read at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1331 1365 } 1332 1366 else … … 1346 1380 if ((RT_LOBYTE(addr) + cb) > 256) 1347 1381 { 1348 LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", DPNIC_INSTANCE, addr, cb));1382 LogFunc(("#%d: addr=%04X, cb=%X, cb!!\n", pThis->iInstance, addr, cb)); 1349 1383 cb = 256 - RT_LOBYTE(addr); 1350 1384 } … … 1362 1396 } 1363 1397 else 1364 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1398 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1365 1399 } 1366 1400 else if (pThis->uDevType == DEV_NE2000) … … 1375 1409 } 1376 1410 else 1377 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1411 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1378 1412 } 1379 1413 else if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013)) … … 1384 1418 memcpy(&pThis->abLocalRAM[addr], pSrc, cb); 1385 1419 else 1386 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1420 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1387 1421 } 1388 1422 else if (pThis->uDevType == DEV_3C503) … … 1398 1432 } 1399 1433 else 1400 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", DPNIC_INSTANCE, addr, cb));1434 LogFunc(("#%d: Ignoring write at addr=%04X cb=%u!\n", pThis->iInstance, addr, cb)); 1401 1435 } 1402 1436 else … … 1413 1447 static void dp8390CoreReceiveBuf(PDPNICSTATE pThis, DP_RSR *pRsr, const uint8_t *src, unsigned cbLeft, bool fLast) 1414 1448 { 1415 LogFlow(("#%d: Initial CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, pThis->core.CURR, pThis->core.CLDA));1449 LogFlow(("#%d: Initial CURR=%02X00 CLDA=%04X\n", pThis->iInstance, pThis->core.CURR, pThis->core.CLDA)); 1416 1450 1417 1451 while (cbLeft) … … 1424 1458 if (cbWrite > cbLeft) 1425 1459 cbWrite = cbLeft; 1426 Log2Func(("#%d: cbLeft=%d CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, cbLeft, pThis->core.CURR, pThis->core.CLDA));1460 Log2Func(("#%d: cbLeft=%d CURR=%02X00 CLDA=%04X\n", pThis->iInstance, cbLeft, pThis->core.CURR, pThis->core.CLDA)); 1427 1461 dpLocalRAMWriteBuf(pThis, pThis->core.CLDA, cbWrite, src); 1428 1462 src += cbWrite; … … 1436 1470 if (fLast && (cbWrite == cbLeft)) 1437 1471 { 1438 Log3Func(("#%d: Round up: CLDA=%04X cbPage=%X\n", DPNIC_INSTANCE, pThis->core.CLDA, cbPage));1472 Log3Func(("#%d: Round up: CLDA=%04X cbPage=%X\n", pThis->iInstance, pThis->core.CLDA, cbPage)); 1439 1473 pThis->core.CLDA += cbPage; 1440 1474 } … … 1442 1476 pThis->core.CLDA += cbWrite; 1443 1477 1444 Log3Func(("#%d: Final CURR=%02X00 CLDA=%04X\n", DPNIC_INSTANCE, pThis->core.CURR, pThis->core.CLDA));1478 Log3Func(("#%d: Final CURR=%02X00 CLDA=%04X\n", pThis->iInstance, pThis->core.CURR, pThis->core.CLDA)); 1445 1479 /* If at end of ring, wrap around. */ 1446 1480 if (pThis->core.clda.CLDA1 == pThis->core.PSTOP) … … 1454 1488 pRsr->MPA = 1; /* Indicates to caller that receive was aborted. */ 1455 1489 STAM_COUNTER_INC(&pThis->StatDropPktNoBuffer); 1456 Log3Func(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00 -- overflow!\n", DPNIC_INSTANCE, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));1490 Log3Func(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00 -- overflow!\n", pThis->iInstance, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR)); 1457 1491 break; 1458 1492 } … … 1464 1498 * Write incoming data into the packet buffer. 1465 1499 */ 1466 static void dp8390CoreReceiveLocked(PDPNICSTATE pThis, const uint8_t *src, size_t cbToRecv) 1467 { 1468 PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis); 1500 static void dp8390CoreReceiveLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, const uint8_t *src, size_t cbToRecv) 1501 { 1469 1502 int is_padr = 0, is_bcast = 0, is_mcast = 0, is_prom = 0; 1470 1503 int mc_type = 0; … … 1509 1542 } 1510 1543 1511 LogFlowFunc(("#%d: size on wire=%d\n", DPNIC_INSTANCE, cbToRecv));1544 LogFlowFunc(("#%d: size on wire=%d\n", pThis->iInstance, cbToRecv)); 1512 1545 1513 1546 /* … … 1527 1560 1528 1561 nRSR = 0; 1529 Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), size=%d\n", DPNIC_INSTANCE, is_padr, is_bcast, is_mcast, is_prom, cbToRecv));1562 Log2Func(("#%d Packet passed address filter (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), size=%d\n", pThis->iInstance, is_padr, is_bcast, is_mcast, is_prom, cbToRecv)); 1530 1563 1531 1564 if (is_bcast || mc_type) … … 1562 1595 } 1563 1596 1564 LogFlowFunc(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00\n", DPNIC_INSTANCE, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR));1597 LogFlowFunc(("#%d: PSTART=%02X00 PSTOP=%02X00 BNRY=%02X00 CURR=%02X00\n", pThis->iInstance, pThis->core.PSTART, pThis->core.PSTOP, pThis->core.BNRY, pThis->core.CURR)); 1565 1598 1566 1599 /* All packets that passed the address filter are copied to local RAM. … … 1627 1660 1628 1661 Log2Func(("Receive completed, size=%d, CURR=%02X00, RSR=%02X, ISR=%02X\n", cbToRecv, pThis->core.CURR, pThis->core.RSR, pThis->core.ISR)); 1629 dp8390CoreUpdateIrq(p This);1662 dp8390CoreUpdateIrq(pDevIns, pThis); 1630 1663 } 1631 1664 else 1632 1665 { 1633 Log3Func(("#%d Packet did not pass address filter, size=%d\n", DPNIC_INSTANCE, cbToRecv));1666 Log3Func(("#%d Packet did not pass address filter, size=%d\n", pThis->iInstance, cbToRecv)); 1634 1667 STAM_COUNTER_INC(&pThis->StatDropPktNoMatch); 1635 1668 } … … 1644 1677 * @returns VBox status code. VERR_TRY_AGAIN is returned if we're busy. 1645 1678 * 1646 * @param pThis The device instance data. 1679 * @param pDevIns The device instance data. 1680 * @param pThis The device state data. 1647 1681 * @param fOnWorkerThread Whether we're on a worker thread or on an EMT. 1648 1682 */ 1649 static int dp8390CoreXmitPacket(PDPNICSTATE pThis, bool fOnWorkerThread) 1650 { 1683 static int dp8390CoreXmitPacket(PPDMDEVINS pDevIns, PDPNICSTATE pThis, bool fOnWorkerThread) 1684 { 1685 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 1651 1686 RT_NOREF_PV(fOnWorkerThread); 1652 1687 int rc; … … 1655 1690 * Grab the xmit lock of the driver as well as the DP8390 device state. 1656 1691 */ 1657 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);1692 PPDMINETWORKUP pDrv = pThisCC->pDrv; 1658 1693 if (pDrv) 1659 1694 { … … 1662 1697 return rc; 1663 1698 } 1664 PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis);1665 1699 rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); 1666 1700 if (RT_SUCCESS(rc)) … … 1669 1703 * Do the transmitting. 1670 1704 */ 1671 int rc2 = dp8390CoreAsyncXmitLocked(p This, false /*fOnWorkerThread*/);1705 int rc2 = dp8390CoreAsyncXmitLocked(pDevIns, pThis, pThisCC, false /*fOnWorkerThread*/); 1672 1706 AssertReleaseRC(rc2); 1673 1707 … … 1694 1728 static DECLCALLBACK(void) dpNicR3XmitTaskCallback(PPDMDEVINS pDevIns, void *pvUser) 1695 1729 { 1696 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE);1730 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 1697 1731 NOREF(pvUser); 1698 1732 … … 1700 1734 * Transmit if we can. 1701 1735 */ 1702 dp8390CoreXmitPacket(p This, true /*fOnWorkerThread*/);1736 dp8390CoreXmitPacket(pDevIns, pThis, true /*fOnWorkerThread*/); 1703 1737 } 1704 1738 … … 1711 1745 * @returns See PPDMINETWORKUP::pfnAllocBuf. 1712 1746 * @param pThis The device instance. 1747 * @param pThisCC The device state for current context. 1713 1748 * @param cbMin The minimum buffer size. 1714 1749 * @param fLoopback Set if we're in loopback mode. … … 1717 1752 * Always set. 1718 1753 */ 1719 DECLINLINE(int) dp8390XmitAllocBuf(PDPNICSTATE pThis, size_t cbMin, bool fLoopback,1754 DECLINLINE(int) dp8390XmitAllocBuf(PDPNICSTATE pThis, PDPNICSTATECC pThisCC, size_t cbMin, bool fLoopback, 1720 1755 PPDMSCATTERGATHER pSgLoop, PPPDMSCATTERGATHER ppSgBuf) 1721 1756 { … … 1724 1759 if (!fLoopback) 1725 1760 { 1726 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);1761 PPDMINETWORKUP pDrv = pThisCC->pDrv; 1727 1762 if (RT_LIKELY(pDrv)) 1728 1763 { … … 1762 1797 * 1763 1798 * @returns See PDMINETWORKUP::pfnSendBuf. 1764 * @param pThis The device instance. 1799 * @param pDevIns The device instance. 1800 * @param pThisCC The current context device state. 1765 1801 * @param fLoopback Set if we're in loopback mode. 1766 1802 * @param pSgBuf The SG to send. … … 1768 1804 * if an EMT. 1769 1805 */ 1770 DECLINLINE(int) dp8390CoreXmitSendBuf(PDPNICSTATE pThis, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread) 1771 { 1806 DECLINLINE(int) dp8390CoreXmitSendBuf(PPDMDEVINS pDevIns, PDPNICSTATECC pThisCC, bool fLoopback, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread) 1807 { 1808 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 1772 1809 int rc; 1773 1810 STAM_REL_COUNTER_ADD(&pThis->StatTransmitBytes, pSgBuf->cbUsed); … … 1778 1815 pThis->Led.Asserted.s.fWriting = pThis->Led.Actual.s.fWriting = 1; 1779 1816 1780 PPDMINETWORKUP pDrv = pThis ->CTX_SUFF(pDrv);1817 PPDMINETWORKUP pDrv = pThisCC->pDrv; 1781 1818 if (RT_LIKELY(pDrv)) 1782 1819 { … … 1806 1843 pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1; 1807 1844 1808 LogFlowFunc(("#%d: loopback (DCR=%02X LB=%u TCR=%02X RCR=%02X, %u bytes)\n", DPNIC_INSTANCE, pCore->DCR, pCore->tcr.LB, pCore->TCR, pCore->RCR, pSgBuf->cbUsed));1845 LogFlowFunc(("#%d: loopback (DCR=%02X LB=%u TCR=%02X RCR=%02X, %u bytes)\n", pThis->iInstance, pCore->DCR, pCore->tcr.LB, pCore->TCR, pCore->RCR, pSgBuf->cbUsed)); 1809 1846 for (ofs = 0; ofs < pSgBuf->cbUsed; ofs += 16) 1810 1847 Log((" %04X: %.*Rhxs\n", ofs, ofs + 16 < pSgBuf->cbUsed ? 16 : pSgBuf->cbUsed - ofs, &pThis->abLoopBuf[ofs])); … … 1886 1923 /* Receiving side checks the FCS. */ 1887 1924 fGoodFcs = !memcmp(&pktbuf[pktlen - 4], abFcs, sizeof(abFcs)); 1888 Log2Func(("#%d: Address matched (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), checking FCS (fGoodFcs=%RTbool)\n", DPNIC_INSTANCE, is_padr, is_bcast, is_mcast, is_prom, fGoodFcs));1925 Log2Func(("#%d: Address matched (is_padr=%d, is_bcast=%d, is_mcast=%d, is_prom=%d), checking FCS (fGoodFcs=%RTbool)\n", pThis->iInstance, is_padr, is_bcast, is_mcast, is_prom, fGoodFcs)); 1889 1926 1890 1927 /* Now we have to update the FIFO. Since only 8 bytes are visible … … 1899 1936 nRsr.PRX = 1; /* Weird but true, for non-matching address only! */ 1900 1937 fAddrMatched = false; 1901 Log3Func(("#%d: Address NOT matched, ignoring FCS errors.\n", DPNIC_INSTANCE));1938 Log3Func(("#%d: Address NOT matched, ignoring FCS errors.\n", pThis->iInstance)); 1902 1939 } 1903 1940 … … 1954 1991 * Reads the entire frame into the scatter gather buffer. 1955 1992 */ 1956 DECLINLINE(void) dp8390CoreXmitRead(PDPNICSTATE pThis, const unsigned uLocalAddr, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf, bool fLoopback) 1957 { 1958 unsigned uOfs = 0; 1959 Assert(PDMDevHlpCritSectIsOwner(DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect)); 1993 DECLINLINE(void) dp8390CoreXmitRead(PPDMDEVINS pDevIns, const unsigned uLocalAddr, const unsigned cbFrame, PPDMSCATTERGATHER pSgBuf, bool fLoopback) 1994 { 1995 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 1996 unsigned uOfs = 0; 1997 Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); 1960 1998 Assert(pSgBuf->cbAvailable >= cbFrame); 1961 1999 1962 2000 pSgBuf->cbUsed = cbFrame; 1963 2001 1964 LogFlowFunc(("#%d: uLocalAddr=%04X cbFrame=%d\n", DPNIC_INSTANCE, uLocalAddr, cbFrame));2002 LogFlowFunc(("#%d: uLocalAddr=%04X cbFrame=%d\n", pThis->iInstance, uLocalAddr, cbFrame)); 1965 2003 /* Have to figure out where the address is in local RAM. */ 1966 2004 if (pThis->uDevType == DEV_NE1000) … … 1976 2014 { 1977 2015 /// @todo What are we supposed to do?! 1978 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));2016 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs)); 1979 2017 } 1980 2018 } … … 1991 2029 { 1992 2030 /// @todo What are we supposed to do?! 1993 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));2031 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs)); 1994 2032 } 1995 2033 } … … 2011 2049 { 2012 2050 /// @todo What are we supposed to do?! 2013 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", DPNIC_INSTANCE, uOfs));2051 LogFunc(("#%d: uOfs=%u, don't know what to do!!\n", pThis->iInstance, uOfs)); 2014 2052 } 2015 2053 } … … 2058 2096 * Try to transmit a frame. 2059 2097 */ 2060 static void dp8390CoreStartTransmit(P DPNICSTATE pThis)2098 static void dp8390CoreStartTransmit(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 2061 2099 { 2062 2100 /* … … 2067 2105 pThis->core.NCR = 0; /* Clear collision counter. */ 2068 2106 #if defined(IN_RING0) || defined(IN_RC) 2069 if (!pThis->CTX_SUFF(pDrv)) 2070 { 2071 int rc = PDMDevHlpTaskTrigger(pThis->CTX_SUFF(pDevIns), pThis->hXmitTask); 2107 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 2108 if (!pThisCC->pDrv) 2109 { 2110 int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hXmitTask); 2072 2111 AssertRC(rc); 2073 2112 } … … 2075 2114 #endif 2076 2115 { 2077 int rc = dp8390CoreXmitPacket(p This, false /*fOnWorkerThread*/);2116 int rc = dp8390CoreXmitPacket(pDevIns, pThis, false /*fOnWorkerThread*/); 2078 2117 if (rc == VERR_TRY_AGAIN) 2079 2118 rc = VINF_SUCCESS; … … 2088 2127 * @threads EMT. 2089 2128 */ 2090 static void dp8390CoreKickReceive(P DPNICSTATE pThis)2129 static void dp8390CoreKickReceive(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 2091 2130 { 2092 2131 if (pThis->fMaybeOutOfSpace) … … 2094 2133 LogFlow(("Poking receive thread.\n")); 2095 2134 #ifdef IN_RING3 2096 dp8390 WakeupReceive(DPNICSTATE_2_DEVINS(pThis));2135 dp8390R3WakeupReceive(pDevIns); 2097 2136 #else 2098 int rc = PDMDevHlpTaskTrigger(p This->CTX_SUFF(pDevIns), pThis->hCanRxTask);2137 int rc = PDMDevHlpTaskTrigger(pDevIns, pThis->hCanRxTask); 2099 2138 AssertRC(rc); 2100 2139 #endif … … 2107 2146 * @threads TX or EMT. 2108 2147 */ 2109 static int dp8390CoreAsyncXmitLocked(P DPNICSTATE pThis, bool fOnWorkerThread)2110 { 2111 Assert(PDMDevHlpCritSectIsOwner( DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect));2148 static int dp8390CoreAsyncXmitLocked(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PDPNICSTATECC pThisCC, bool fOnWorkerThread) 2149 { 2150 Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); 2112 2151 2113 2152 /* … … 2117 2156 if (RT_UNLIKELY(!pThis->core.cr.TXP)) 2118 2157 { 2119 LogFunc(("#%d: Nope, CR.TXP is off (fOnWorkerThread=%RTbool)\n", DPNIC_INSTANCE, fOnWorkerThread));2158 LogFunc(("#%d: Nope, CR.TXP is off (fOnWorkerThread=%RTbool)\n", pThis->iInstance, fOnWorkerThread)); 2120 2159 return VINF_SUCCESS; 2121 2160 } … … 2144 2183 unsigned cb = pThis->core.TBCR; /* Packet size. */ 2145 2184 const int adr = RT_MAKE_U16(0, pThis->core.TPSR); 2146 LogFunc(("#%d: cb=%d, adr=%04X\n", DPNIC_INSTANCE, cb, adr));2185 LogFunc(("#%d: cb=%d, adr=%04X\n", pThis->iInstance, cb, adr)); 2147 2186 2148 2187 if (RT_LIKELY(dp8390IsLinkUp(pThis) || fLoopback)) … … 2157 2196 } 2158 2197 2159 rc = dp8390XmitAllocBuf(pThis, cb, fLoopback, &SgLoop, &pSgBuf);2198 rc = dp8390XmitAllocBuf(pThis, pThisCC, cb, fLoopback, &SgLoop, &pSgBuf); 2160 2199 if (RT_SUCCESS(rc)) 2161 2200 { 2162 dp8390CoreXmitRead(p This, adr, cb, pSgBuf, fLoopback);2163 rc = dp8390CoreXmitSendBuf(p This, fLoopback, pSgBuf, fOnWorkerThread);2164 Log2Func(("#%d: rc=%Rrc\n", DPNIC_INSTANCE, rc));2201 dp8390CoreXmitRead(pDevIns, adr, cb, pSgBuf, fLoopback); 2202 rc = dp8390CoreXmitSendBuf(pDevIns, pThisCC, fLoopback, pSgBuf, fOnWorkerThread); 2203 Log2Func(("#%d: rc=%Rrc\n", pThis->iInstance, rc)); 2165 2204 } 2166 2205 else if (rc == VERR_TRY_AGAIN) 2167 2206 { 2168 2207 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a); 2169 LogFunc(("#%d: rc=%Rrc\n", DPNIC_INSTANCE, rc));2208 LogFunc(("#%d: rc=%Rrc\n", pThis->iInstance, rc)); 2170 2209 return VINF_SUCCESS; 2171 2210 } … … 2186 2225 * hardware does *not* limit the packet length. 2187 2226 */ 2188 LogRel(("DPNIC#%d: Attempt to transmit illegal giant frame (%u bytes) -> signaling error\n", DPNIC_INSTANCE, cb));2227 LogRel(("DPNIC#%d: Attempt to transmit illegal giant frame (%u bytes) -> signaling error\n", pThis->iInstance, cb)); 2189 2228 pThis->core.tsr.OWC = 1; /* Pretend there was an out-of-window collision. */ 2190 2229 pThis->core.isr.TXE = 1; … … 2201 2240 pThis->core.cr.TXP = 0; 2202 2241 pThis->core.TBCR = 0; 2203 LogFlowFunc(("#%d: TSR=%02X, ISR=%02X\n", DPNIC_INSTANCE, pThis->core.TSR, pThis->core.ISR));2242 LogFlowFunc(("#%d: TSR=%02X, ISR=%02X\n", pThis->iInstance, pThis->core.TSR, pThis->core.ISR)); 2204 2243 2205 2244 } while (0); /* No loop, because there isn't ever more than one packet to transmit. */ 2206 2245 2207 dp8390CoreUpdateIrq(p This);2246 dp8390CoreUpdateIrq(pDevIns, pThis); 2208 2247 2209 2248 /* If there's anything waiting, this should be a good time to recheck. */ 2210 dp8390CoreKickReceive(p This);2249 dp8390CoreKickReceive(pDevIns, pThis); 2211 2250 2212 2251 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTransmit), a); … … 2218 2257 2219 2258 2220 static uint32_t dp8390CoreRead(P DPNICSTATE pThis, int ofs)2259 static uint32_t dp8390CoreRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis, int ofs) 2221 2260 { 2222 2261 uint8_t val; … … 2259 2298 val = pThis->core.CNTR0; 2260 2299 pThis->core.CNTR0 = 0; /* Cleared by reading. */ 2261 dp8390CoreUpdateIrq(p This);2300 dp8390CoreUpdateIrq(pDevIns, pThis); 2262 2301 return val; 2263 2302 case DPR_P0_R_CNTR1: 2264 2303 val = pThis->core.CNTR1; 2265 2304 pThis->core.CNTR1 = 0; /* Cleared by reading. */ 2266 dp8390CoreUpdateIrq(p This);2305 dp8390CoreUpdateIrq(pDevIns, pThis); 2267 2306 return val; 2268 2307 case DPR_P0_R_CNTR2: 2269 2308 val = pThis->core.CNTR2; 2270 2309 pThis->core.CNTR2 = 0; /* Cleared by reading. */ 2271 dp8390CoreUpdateIrq(p This);2310 dp8390CoreUpdateIrq(pDevIns, pThis); 2272 2311 return val; 2273 2312 default: … … 2324 2363 2325 2364 2326 static int dp8390CoreWriteCR(P DPNICSTATE pThis, uint32_t val)2365 static int dp8390CoreWriteCR(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t val) 2327 2366 { 2328 2367 union { … … 2356 2395 2357 2396 /* Unblock receive thread if necessary, possibly drop any packets. */ 2358 dp8390CoreKickReceive(p This);2397 dp8390CoreKickReceive(pDevIns, pThis); 2359 2398 } 2360 2399 if (nCr.STA && !pThis->core.cr.STA) … … 2368 2407 2369 2408 /* Unblock receive thread. */ 2370 dp8390CoreKickReceive(p This);2409 dp8390CoreKickReceive(pDevIns, pThis); 2371 2410 } 2372 2411 if (nCr.TXP && !pThis->core.cr.TXP) … … 2374 2413 /* Kick off a transmit. */ 2375 2414 pThis->core.cr.TXP = 1; /* Indicate transmit in progress. */ 2376 dp8390CoreStartTransmit(p This);2415 dp8390CoreStartTransmit(pDevIns, pThis); 2377 2416 } 2378 2417 … … 2415 2454 } 2416 2455 2417 static int dp8390CoreWrite(P DPNICSTATE pThis, int ofs, uint32_t val)2456 static int dp8390CoreWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, int ofs, uint32_t val) 2418 2457 { 2419 2458 int rc = VINF_SUCCESS; 2420 2459 bool fUpdateIRQ = false; 2421 2460 2422 Log2Func(("#%d: page=%d reg=%X val=%02X\n", DPNIC_INSTANCE, pThis->core.cr.PS, ofs, val));2461 Log2Func(("#%d: page=%d reg=%X val=%02X\n", pThis->iInstance, pThis->core.cr.PS, ofs, val)); 2423 2462 2424 2463 /* Command Register exists in all pages. */ 2425 2464 if (ofs == DPR_CR) 2426 2465 { 2427 rc = dp8390CoreWriteCR(p This, val);2466 rc = dp8390CoreWriteCR(pDevIns, pThis, val); 2428 2467 } 2429 2468 else if (pThis->core.cr.PS == 0) … … 2443 2482 pThis->core.BNRY = val; 2444 2483 /* Probably made more room in receive ring. */ 2445 dp8390CoreKickReceive(p This);2484 dp8390CoreKickReceive(pDevIns, pThis); 2446 2485 } 2447 2486 break; … … 2538 2577 2539 2578 if (fUpdateIRQ) 2540 dp8390CoreUpdateIrq(p This);2579 dp8390CoreUpdateIrq(pDevIns, pThis); 2541 2580 2542 2581 return rc; … … 2679 2718 2680 2719 2681 static int neDataPortWrite(P DPNICSTATE pThis, uint16_t val)2720 static int neDataPortWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint16_t val) 2682 2721 { 2683 2722 /* Remote Write; ignored if Remote DMA command is not 'Write'. */ … … 2713 2752 pThis->core.isr.RDC = 1; 2714 2753 pThis->core.cr.RD = 0; 2715 dp8390CoreUpdateIrq(p This);2754 dp8390CoreUpdateIrq(pDevIns, pThis); 2716 2755 } 2717 2756 } … … 2720 2759 2721 2760 2722 static uint16_t neDataPortRead(P DPNICSTATE pThis)2761 static uint16_t neDataPortRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 2723 2762 { 2724 2763 uint16_t val = 0x1234; … … 2757 2796 pThis->core.isr.RDC = 1; 2758 2797 pThis->core.cr.RD = 0; 2759 dp8390CoreUpdateIrq(p This);2798 dp8390CoreUpdateIrq(pDevIns, pThis); 2760 2799 } 2761 2800 } … … 2764 2803 2765 2804 2766 static int neResetPortWrite(P DPNICSTATE pThis)2805 static int neResetPortWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 2767 2806 { 2768 2807 LogFlowFunc(("\n")); 2769 dp8390CoreReset(p This);2808 dp8390CoreReset(pDevIns, pThis); 2770 2809 return VINF_SUCCESS; 2771 2810 } 2772 2811 2773 2812 2774 static int dpNeIoWrite(P DPNICSTATE pThis, uint32_t addr, uint32_t val)2813 static int dpNeIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val) 2775 2814 { 2776 2815 int reg = addr & 0x0f; 2777 2816 int rc = VINF_SUCCESS; 2778 2817 2779 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));2818 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 2780 2819 2781 2820 /* The NE2000 has 8 bytes of data port followed by 8 bytes of reset port. … … 2786 2825 reg >>= 1; 2787 2826 if (reg & 0x04) 2788 rc = neResetPortWrite(p This);2827 rc = neResetPortWrite(pDevIns, pThis); 2789 2828 else 2790 rc = neDataPortWrite(p This, val);2829 rc = neDataPortWrite(pDevIns, pThis, val); 2791 2830 2792 2831 return rc; … … 2794 2833 2795 2834 2796 static uint32_t neIoRead(P DPNICSTATE pThis, uint32_t addr)2835 static uint32_t neIoRead(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr) 2797 2836 { 2798 2837 uint32_t val = UINT32_MAX; … … 2808 2847 val = 0x52; /// @todo Check what really happens 2809 2848 else 2810 val = neDataPortRead(p This);2811 2812 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));2849 val = neDataPortRead(pDevIns, pThis); 2850 2851 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 2813 2852 return val; 2814 2853 } 2815 2854 2816 2855 2817 static int wdIoWrite(P DPNICSTATE pThis, uint32_t addr, uint32_t val)2856 static int wdIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val) 2818 2857 { 2819 2858 int reg = addr & 0xf; … … 2828 2867 }; 2829 2868 2830 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));2869 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 2831 2870 2832 2871 switch (reg) … … 2841 2880 if (nCtrl1.RESET) 2842 2881 { 2843 dp8390CoreReset(p This);2882 dp8390CoreReset(pDevIns, pThis); 2844 2883 pThis->CTRL1 = 0; 2845 2884 } … … 2919 2958 } 2920 2959 2921 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));2960 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 2922 2961 return val; 2923 2962 } … … 2970 3009 } 2971 3010 2972 static void elWriteIdcfr(P DPNICSTATE pThis, PEL_GA pGa, uint8_t val)3011 static void elWriteIdcfr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val) 2973 3012 { 2974 3013 uint8_t uOldIrq = pThis->uIsaIrq; … … 2981 3020 if (uOldIrq != uNewIrq) 2982 3021 { 2983 LogFunc(("#%d Switching IRQ=%d -> IRQ=%d\n", DPNIC_INSTANCE, uOldIrq, uNewIrq));3022 LogFunc(("#%d Switching IRQ=%d -> IRQ=%d\n", pThis->iInstance, uOldIrq, uNewIrq)); 2984 3023 if (pThis->fNicIrqActive) 2985 3024 { 2986 3025 /* This probably isn't supposed to happen. */ 2987 LogFunc(("#%d Moving active IRQ!\n", DPNIC_INSTANCE));3026 LogFunc(("#%d Moving active IRQ!\n", pThis->iInstance)); 2988 3027 if (uOldIrq) 2989 PDMDevHlpISASetIrq( DPNICSTATE_2_DEVINS(pThis), uOldIrq, 0);3028 PDMDevHlpISASetIrq(pDevIns, uOldIrq, 0); 2990 3029 if (uNewIrq) 2991 PDMDevHlpISASetIrq( DPNICSTATE_2_DEVINS(pThis), uNewIrq, 1);3030 PDMDevHlpISASetIrq(pDevIns, uNewIrq, 1); 2992 3031 } 2993 3032 pThis->uIsaIrq = uNewIrq; … … 2999 3038 { 3000 3039 /// @todo We can't really move the DRQ, what can we do? 3001 LogFunc(("#%d Switching DRQ=%d -> DRQ=%d\n", DPNIC_INSTANCE, uOldDrq, uNewDrq));3040 LogFunc(("#%d Switching DRQ=%d -> DRQ=%d\n", pThis->iInstance, uOldDrq, uNewDrq)); 3002 3041 pThis->uElIsaDma = uNewDrq; 3003 3042 } … … 3007 3046 3008 3047 3009 static void elWriteGacfr(P DPNICSTATE pThis, PEL_GA pGa, uint8_t val)3048 static void elWriteGacfr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val) 3010 3049 { 3011 3050 union { … … 3021 3060 if (pThis->fNicIrqActive && !nGacfr.nim) 3022 3061 { 3023 LogFunc(("#%d: Unmasking active IRQ!\n", DPNIC_INSTANCE));3024 PDMDevHlpISASetIrq( DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq, 1);3062 LogFunc(("#%d: Unmasking active IRQ!\n", pThis->iInstance)); 3063 PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 1); 3025 3064 } 3026 3065 else if (pThis->fNicIrqActive && nGacfr.nim) 3027 3066 { 3028 LogFunc(("#%d: Masking active IRQ\n", DPNIC_INSTANCE));3029 PDMDevHlpISASetIrq( DPNICSTATE_2_DEVINS(pThis), pThis->uIsaIrq, 0);3067 LogFunc(("#%d: Masking active IRQ\n", pThis->iInstance)); 3068 PDMDevHlpISASetIrq(pDevIns, pThis->uIsaIrq, 0); 3030 3069 } 3031 3070 } … … 3034 3073 if (nGacfr.rsel != pGa->gacfr.rsel) 3035 3074 { 3036 LogFunc(("#%d: rsel=%u mbs=%u\n", DPNIC_INSTANCE, nGacfr.rsel, nGacfr.mbs));3075 LogFunc(("#%d: rsel=%u mbs=%u\n", pThis->iInstance, nGacfr.rsel, nGacfr.mbs)); 3037 3076 } 3038 3077 … … 3041 3080 3042 3081 3043 static void elSoftReset(P DPNICSTATE pThis)3082 static void elSoftReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 3044 3083 { 3045 3084 PEL_GA pGa = &pThis->ga; … … 3049 3088 pGa->PSTR = pGa->PSPR = 0; 3050 3089 pGa->DQTR = 0; 3051 elWriteGacfr(p This, pGa, 0);3090 elWriteGacfr(pDevIns, pThis, pGa, 0); 3052 3091 pGa->STREG = ELNKII_GA_REV; 3053 3092 pGa->VPTR0 = pGa->VPTR1 = pGa->VPTR2 = 0; 3054 3093 pGa->DALSB = pGa->DAMSB = 0; 3055 elWriteIdcfr(p This, pGa, 0);3094 elWriteIdcfr(pDevIns, pThis, pGa, 0); 3056 3095 pGa->GACR = 0x0B; /* Low bit set = in reset state. */ 3057 3096 pGa->fGaIrq = false; 3058 3097 3059 3098 /* Reset the NIC core. */ 3060 dp8390CoreReset(p This);3061 } 3062 3063 3064 static int elWriteGacr(P DPNICSTATE pThis, PEL_GA pGa, uint8_t val)3099 dp8390CoreReset(pDevIns, pThis); 3100 } 3101 3102 3103 static int elWriteGacr(PPDMDEVINS pDevIns, PDPNICSTATE pThis, PEL_GA pGa, uint8_t val) 3065 3104 { 3066 3105 union { … … 3075 3114 /* When going out of reset, only clear the rst bit. 3C503 diagnostics checks for this. */ 3076 3115 if (nGacr.rst) 3077 elSoftReset(p This);3116 elSoftReset(pDevIns, pThis); 3078 3117 else 3079 3118 pGa->gacr.rst = 0; … … 3107 3146 { 3108 3147 #ifdef IN_RING3 3109 PDMDevHlpDMASetDREQ(p This->CTX_SUFF(pDevIns), pThis->uIsaDma, pGa->streg.dprdy);3148 PDMDevHlpDMASetDREQ(pDevIns, pThis->uIsaDma, pGa->streg.dprdy); 3110 3149 if (pGa->streg.dprdy) 3111 PDMDevHlpDMASchedule(p This->CTX_SUFF(pDevIns));3112 LogFunc(("#%d: DREQ for channel %u set to %u\n", DPNIC_INSTANCE, pThis->uIsaDma, pGa->streg.dprdy));3150 PDMDevHlpDMASchedule(pDevIns); 3151 LogFunc(("#%d: DREQ for channel %u set to %u\n", pThis->iInstance, pThis->uIsaDma, pGa->streg.dprdy)); 3113 3152 #else 3114 3153 /* Must not get here. */ … … 3180 3219 3181 3220 3182 static int elGaIoWrite(P DPNICSTATE pThis, uint32_t addr, uint32_t val)3221 static int elGaIoWrite(PPDMDEVINS pDevIns, PDPNICSTATE pThis, uint32_t addr, uint32_t val) 3183 3222 { 3184 3223 int reg = addr & 0xf; … … 3186 3225 PEL_GA pGa = &pThis->ga; 3187 3226 3188 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));3227 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 3189 3228 3190 3229 switch (reg) … … 3200 3239 break; 3201 3240 case GAR_GACFR: 3202 elWriteGacfr(p This, pGa, val);3241 elWriteGacfr(pDevIns, pThis, pGa, val); 3203 3242 break; 3204 3243 case GAR_GACR: 3205 rc = elWriteGacr(p This, pGa, val);3244 rc = elWriteGacr(pDevIns, pThis, pGa, val); 3206 3245 break; 3207 3246 case GAR_STREG: … … 3209 3248 pThis->ga.streg.dtc = 0; 3210 3249 pThis->ga.fGaIrq = false; 3211 dp8390CoreUpdateIrq(p This);3250 dp8390CoreUpdateIrq(pDevIns, pThis); 3212 3251 break; 3213 3252 case GAR_IDCFR: 3214 elWriteIdcfr(p This, pGa, val);3253 elWriteIdcfr(pDevIns, pThis, pGa, val); 3215 3254 break; 3216 3255 case GAR_DAMSB: … … 3305 3344 } 3306 3345 3307 Log2Func(("#%d: addr=%#06x val=%#04x\n", DPNIC_INSTANCE, addr, val & 0xff));3346 Log2Func(("#%d: addr=%#06x val=%#04x\n", pThis->iInstance, addr, val & 0xff)); 3308 3347 return val; 3309 3348 } … … 3316 3355 neIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb) 3317 3356 { 3318 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3357 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3319 3358 int rc = VINF_SUCCESS; 3320 3359 int reg = Port & 0xf; … … 3327 3366 { 3328 3367 case 1: 3329 *pu32 = neIoRead(p This, reg);3368 *pu32 = neIoRead(pDevIns, pThis, reg); 3330 3369 break; 3331 3370 case 2: … … 3333 3372 if (pThis->uDevType == DEV_NE1000) 3334 3373 { 3335 u8Lo = neIoRead(p This, reg);3374 u8Lo = neIoRead(pDevIns, pThis, reg); 3336 3375 if (reg < 0xf) // This logic is not entirely accurate (wraparound). 3337 u8Hi = neIoRead(p This, reg + 1);3376 u8Hi = neIoRead(pDevIns, pThis, reg + 1); 3338 3377 *pu32 = RT_MAKE_U16(u8Lo, u8Hi); 3339 3378 } 3340 3379 else 3341 *pu32 = neIoRead(p This, reg);3380 *pu32 = neIoRead(pDevIns, pThis, reg); 3342 3381 break; 3343 3382 default: 3344 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3383 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3345 3384 "neIOPortRead: unsupported operation size: offset=%#10x cb=%u\n", 3346 3385 Port, cb); 3347 3386 } 3348 3387 3349 Log2Func(("#%d: NE Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));3388 Log2Func(("#%d: NE Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc)); 3350 3389 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a); 3351 3390 return rc; … … 3359 3398 wdIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb) 3360 3399 { 3361 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3400 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3362 3401 int rc = VINF_SUCCESS; 3363 3402 int reg = Port & 0xf; … … 3380 3419 break; 3381 3420 default: 3382 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3421 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3383 3422 "wdIOPortRead: unsupported operation size: offset=%#10x cb=%u\n", 3384 3423 Port, cb); 3385 3424 } 3386 3425 3387 Log2Func(("#%d: WD Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));3426 Log2Func(("#%d: WD Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc)); 3388 3427 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a); 3389 3428 return rc; … … 3397 3436 elIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb) 3398 3437 { 3399 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3438 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3400 3439 int rc = VINF_SUCCESS; 3401 3440 int reg = Port & 0xf; … … 3418 3457 break; 3419 3458 default: 3420 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3459 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3421 3460 "elIOPortRead: unsupported operation size: offset=%#10x cb=%u\n", 3422 3461 Port, cb); 3423 3462 } 3424 3463 3425 Log2Func(("#%d: EL Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));3464 Log2Func(("#%d: EL Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc)); 3426 3465 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a); 3427 3466 return rc; … … 3435 3474 dp8390CoreIOPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb) 3436 3475 { 3437 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3476 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3438 3477 int rc = VINF_SUCCESS; 3439 3478 int reg = Port & 0xf; … … 3446 3485 { 3447 3486 case 1: 3448 *pu32 = dp8390CoreRead(p This, reg);3487 *pu32 = dp8390CoreRead(pDevIns, pThis, reg); 3449 3488 break; 3450 3489 case 2: 3451 3490 /* Manually split word access. */ 3452 u8Lo = dp8390CoreRead(p This, reg + 0);3491 u8Lo = dp8390CoreRead(pDevIns, pThis, reg + 0); 3453 3492 /* This logic is not entirely accurate. */ 3454 3493 if (reg < 0xf) 3455 u8Hi = dp8390CoreRead(p This, reg + 1);3494 u8Hi = dp8390CoreRead(pDevIns, pThis, reg + 1); 3456 3495 else 3457 3496 u8Hi = 0; … … 3459 3498 break; 3460 3499 default: 3461 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3500 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3462 3501 "dp8390CoreIOPortRead: unsupported operation size: offset=%#10x cb=%u\n", 3463 3502 Port, cb); 3464 3503 } 3465 3504 3466 Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, *pu32, cb, rc));3505 Log2Func(("#%d: Port=%RTiop *pu32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, *pu32, cb, rc)); 3467 3506 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIORead), a); 3468 3507 return rc; … … 3476 3515 neIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb) 3477 3516 { 3478 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3517 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3479 3518 int rc = VINF_SUCCESS; 3480 3519 int reg = Port & 0xf; … … 3486 3525 { 3487 3526 case 1: 3488 rc = dpNeIoWrite(p This, Port, RT_LOBYTE(u32));3527 rc = dpNeIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32)); 3489 3528 break; 3490 3529 case 2: … … 3492 3531 if (pThis->uDevType == DEV_NE2000) 3493 3532 { 3494 rc = dpNeIoWrite(p This, Port, RT_LOWORD(u32));3533 rc = dpNeIoWrite(pDevIns, pThis, Port, RT_LOWORD(u32)); 3495 3534 } 3496 3535 else 3497 3536 { 3498 rc = dpNeIoWrite(p This, reg + 0, RT_LOBYTE(u32));3537 rc = dpNeIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32)); 3499 3538 if (RT_SUCCESS(rc) && (reg < 0xf)) 3500 rc = dpNeIoWrite(p This, reg + 1, RT_HIBYTE(u32));3539 rc = dpNeIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32)); 3501 3540 } 3502 3541 break; 3503 3542 default: 3504 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3543 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3505 3544 "neIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n", 3506 3545 Port, cb); 3507 3546 } 3508 3547 3509 Log2Func(("#%d: NE Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));3548 Log2Func(("#%d: NE Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc)); 3510 3549 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a); 3511 3550 return rc; … … 3519 3558 wdIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb) 3520 3559 { 3521 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3560 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3522 3561 int rc = VINF_SUCCESS; 3523 3562 int reg = Port & 0xf; … … 3529 3568 { 3530 3569 case 1: 3531 rc = wdIoWrite(p This, Port, RT_LOBYTE(u32));3570 rc = wdIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32)); 3532 3571 break; 3533 3572 case 2: 3534 3573 /* Manually split word access. */ 3535 rc = wdIoWrite(p This, reg + 0, RT_LOBYTE(u32));3574 rc = wdIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32)); 3536 3575 if (RT_SUCCESS(rc) && (reg < 0xf)) 3537 rc = wdIoWrite(p This, reg + 1, RT_HIBYTE(u32));3576 rc = wdIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32)); 3538 3577 break; 3539 3578 default: 3540 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3579 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3541 3580 "wdIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n", 3542 3581 Port, cb); 3543 3582 } 3544 3583 3545 Log2Func(("#%d: WD Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));3584 Log2Func(("#%d: WD Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc)); 3546 3585 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a); 3547 3586 return rc; … … 3555 3594 elIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb) 3556 3595 { 3557 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3596 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3558 3597 int rc = VINF_SUCCESS; 3559 3598 int reg = Port & 0xf; … … 3565 3604 { 3566 3605 case 1: 3567 rc = elGaIoWrite(p This, Port, RT_LOBYTE(u32));3606 rc = elGaIoWrite(pDevIns, pThis, Port, RT_LOBYTE(u32)); 3568 3607 break; 3569 3608 case 2: 3570 3609 /* Manually split word access. */ 3571 rc = elGaIoWrite(p This, reg + 0, RT_LOBYTE(u32));3610 rc = elGaIoWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32)); 3572 3611 if (RT_SUCCESS(rc) && (reg < 0xf)) 3573 rc = elGaIoWrite(p This, reg + 1, RT_HIBYTE(u32));3612 rc = elGaIoWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32)); 3574 3613 break; 3575 3614 default: 3576 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3615 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3577 3616 "elIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n", 3578 3617 Port, cb); 3579 3618 } 3580 3619 3581 Log2Func(("#%d: EL Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));3620 Log2Func(("#%d: EL Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc)); 3582 3621 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a); 3583 3622 return rc; … … 3591 3630 dp8390CoreIOPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb) 3592 3631 { 3593 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3632 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3594 3633 int rc = VINF_SUCCESS; 3595 3634 int reg = Port & 0xf; … … 3601 3640 { 3602 3641 case 1: 3603 rc = dp8390CoreWrite(p This, reg, RT_LOBYTE(u32));3642 rc = dp8390CoreWrite(pDevIns, pThis, reg, RT_LOBYTE(u32)); 3604 3643 break; 3605 3644 case 2: 3606 3645 /* Manually split word access. */ 3607 rc = dp8390CoreWrite(p This, reg + 0, RT_LOBYTE(u32));3646 rc = dp8390CoreWrite(pDevIns, pThis, reg + 0, RT_LOBYTE(u32)); 3608 3647 if (!RT_SUCCESS(rc)) 3609 3648 break; 3610 rc = dp8390CoreWrite(p This, reg + 1, RT_HIBYTE(u32));3649 rc = dp8390CoreWrite(pDevIns, pThis, reg + 1, RT_HIBYTE(u32)); 3611 3650 break; 3612 3651 default: 3613 rc = PDMDevHlpDBGFStop(p This->CTX_SUFF(pDevIns), RT_SRC_POS,3652 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, 3614 3653 "dp8390CoreIOPortWrite: unsupported operation size: offset=%#10x cb=%u\n", 3615 3654 Port, cb); 3616 3655 } 3617 3656 3618 Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", DPNIC_INSTANCE, Port, u32, cb, rc));3657 Log2Func(("#%d: Port=%RTiop u32=%#RX32 cb=%d rc=%Rrc\n", pThis->iInstance, Port, u32, cb, rc)); 3619 3658 STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatIOWrite), a); 3620 3659 return rc; … … 3631 3670 dpWdMmioFill(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, uint32_t u32Item, unsigned cbItem, unsigned cItems) 3632 3671 { 3633 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3672 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3634 3673 Assert(PDMDevHlpCritSectIsOwner(pDevIns, pDevIns->CTX_SUFF(pCritSectRo))); 3635 3674 … … 3646 3685 static DECLCALLBACK(VBOXSTRICTRC) wdMemRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb) 3647 3686 { 3648 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3687 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3649 3688 uint8_t *pbData = (uint8_t *)pv; 3650 3689 NOREF(pvUser); … … 3655 3694 if (pThis->ctrl1.MEME) 3656 3695 { 3657 Log3Func(("#%d: Reading %u bytes from address %X: [%.*Rhxs]\n", p DevIns->iInstance, cb, off, cb, &pThis->abLocalRAM[off & DPNIC_MEM_MASK]));3696 Log3Func(("#%d: Reading %u bytes from address %X: [%.*Rhxs]\n", pThis->iInstance, cb, off, cb, &pThis->abLocalRAM[off & DPNIC_MEM_MASK])); 3658 3697 while (cb-- > 0) 3659 3698 *pbData++ = pThis->abLocalRAM[off++ & DPNIC_MEM_MASK]; … … 3672 3711 static DECLCALLBACK(VBOXSTRICTRC) wdMemWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb) 3673 3712 { 3674 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3713 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3675 3714 uint8_t const *pbSrc = (uint8_t const *)pv; 3676 3715 NOREF(pvUser); … … 3681 3720 if (pThis->ctrl1.MEME) 3682 3721 { 3683 Log3Func(("#%d: Writing %u bytes to address %X: [%.*Rhxs]\n", p DevIns->iInstance, cb, off, cb, pbSrc));3722 Log3Func(("#%d: Writing %u bytes to address %X: [%.*Rhxs]\n", pThis->iInstance, cb, off, cb, pbSrc)); 3684 3723 while (cb-- > 0) 3685 3724 pThis->abLocalRAM[off++ & DPNIC_MEM_MASK] = *pbSrc++; … … 3697 3736 static DECLCALLBACK(VBOXSTRICTRC) elMemRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb) 3698 3737 { 3699 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3738 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3700 3739 uint8_t *pbData = (uint8_t *)pv; 3701 3740 NOREF(pvUser); … … 3705 3744 if (pThis->ga.gacfr.rsel) 3706 3745 { 3707 Log3Func(("#%d: Reading %u bytes from address %X\n", p DevIns->iInstance, cb, off));3746 Log3Func(("#%d: Reading %u bytes from address %X\n", pThis->iInstance, cb, off)); 3708 3747 while (cb-- > 0) 3709 3748 *pbData++ = pThis->abLocalRAM[off++ & DPNIC_MEM_MASK]; … … 3711 3750 else 3712 3751 { 3713 Log3Func(("#%d: Ignoring read of %u bytes from address %X\n", p DevIns->iInstance, cb, off));3752 Log3Func(("#%d: Ignoring read of %u bytes from address %X\n", pThis->iInstance, cb, off)); 3714 3753 memset(pv, 0xff, cb); 3715 3754 } … … 3724 3763 static DECLCALLBACK(VBOXSTRICTRC) elMemWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb) 3725 3764 { 3726 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3765 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3727 3766 uint8_t const *pbSrc = (uint8_t const *)pv; 3728 3767 NOREF(pvUser); … … 3732 3771 if (pThis->ga.gacfr.rsel) 3733 3772 { 3734 Log3Func(("#%d: Writing %u bytes to address %X\n", p DevIns->iInstance, cb, off));3773 Log3Func(("#%d: Writing %u bytes to address %X\n", pThis->iInstance, cb, off)); 3735 3774 while (cb-- > 0) 3736 3775 pThis->abLocalRAM[off++ & DPNIC_MEM_MASK] = *pbSrc++; … … 3738 3777 else 3739 3778 { 3740 Log3Func(("#%d: Ignoring write of %u bytes to address %X\n", p DevIns->iInstance, cb, off));3779 Log3Func(("#%d: Ignoring write of %u bytes to address %X\n", pThis->iInstance, cb, off)); 3741 3780 } 3742 3781 return VINF_SUCCESS; … … 3878 3917 pThis->ga.streg.dtc = 1; 3879 3918 pThis->ga.fGaIrq = true; 3880 dp8390CoreUpdateIrq(p This);3919 dp8390CoreUpdateIrq(pDevIns, pThis); 3881 3920 } 3882 3921 else … … 3903 3942 { 3904 3943 RT_NOREF(pvUser); 3905 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3944 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3906 3945 int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); 3907 3946 AssertReleaseRC(rc); … … 3916 3955 { 3917 3956 LogRel(("DPNIC#%d: The link is back up again after the restore.\n", 3918 p DevIns->iInstance));3919 LogFunc(("#%d: cLinkDownReported=%d\n", p DevIns->iInstance, pThis->cLinkDownReported));3957 pThis->iInstance)); 3958 LogFunc(("#%d: cLinkDownReported=%d\n", pThis->iInstance, pThis->cLinkDownReported)); 3920 3959 pThis->Led.Actual.s.fError = 0; 3921 3960 } 3922 3961 } 3923 3962 else 3924 LogFunc(("#%d: cLinkDownReported=%d, wait another 1500ms...\n", p DevIns->iInstance, pThis->cLinkDownReported));3963 LogFunc(("#%d: cLinkDownReported=%d, wait another 1500ms...\n", pThis->iInstance, pThis->cLinkDownReported)); 3925 3964 3926 3965 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 3935 3974 static DECLCALLBACK(void) dpNicInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs) 3936 3975 { 3937 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);3976 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 3938 3977 bool fRecvBuffer = false; 3939 3978 bool fSendBuffer = false; … … 3955 3994 */ 3956 3995 pHlp->pfnPrintf(pHlp, "DPNIC #%d: %s port=%RTiop IRQ=%u", 3957 p DevIns->iInstance,3996 pThis->iInstance, 3958 3997 aszModels[pThis->uDevType], 3959 3998 pThis->IOPortBase, … … 3963 4002 if (pThis->uIsaDma) 3964 4003 pHlp->pfnPrintf(pHlp, " DMA=%u", pThis->uIsaDma); 3965 pHlp->pfnPrintf(pHlp, " mac-cfg=%RTmac %s\n",4004 pHlp->pfnPrintf(pHlp, " mac-cfg=%RTmac%s %s\n", 3966 4005 &pThis->MacConfigured, 3967 pDevIns->fR0Enabled ? "RZ" : ""); 4006 pDevIns->fR0Enabled ? " RZ" : "", 4007 pThis->fDriverAttached ? "attached" : "unattached!"); 3968 4008 3969 4009 int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_INTERNAL_ERROR); /* Take it here so we know why we're hanging... */ … … 4066 4106 if (pThis->fMaybeOutOfSpace) 4067 4107 pHlp->pfnPrintf(pHlp, " Waiting for receive space\n"); 4108 if (pThis->cLinkDownReported) 4109 pHlp->pfnPrintf(pHlp, " Link down count %d\n", pThis->cLinkDownReported); 4068 4110 4069 4111 if ((pThis->uDevType == DEV_WD8003) || (pThis->uDevType == DEV_WD8013)) … … 4151 4193 4152 4194 4153 static void dpNicR3HardReset(P DPNICSTATE pThis)4154 { 4155 LogFlowFunc(("#%d:\n", DPNIC_INSTANCE));4195 static void dpNicR3HardReset(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 4196 { 4197 LogFlowFunc(("#%d:\n", pThis->iInstance)); 4156 4198 4157 4199 /* Initialize the PROM. Covers both NE1000 and NE2000. */ … … 4223 4265 memset(&pThis->core, 0, sizeof(pThis->core)); 4224 4266 4225 dp8390CoreReset(p This);4267 dp8390CoreReset(pDevIns, pThis); 4226 4268 } 4227 4269 … … 4235 4277 * renegotiate any DHCP lease. 4236 4278 * 4237 * @param pThis The device instance data. 4238 */ 4239 static void dp8390TempLinkDown(PDPNICSTATE pThis) 4279 * @param pDevIns The device instance data. 4280 * @param pThis The device state. 4281 */ 4282 static void dp8390TempLinkDown(PPDMDEVINS pDevIns, PDPNICSTATE pThis) 4240 4283 { 4241 4284 if (pThis->fLinkUp) … … 4244 4287 pThis->cLinkDownReported = 0; 4245 4288 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 4246 int rc = PDMDevHlpTimerSetMillies( DPNICSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);4289 int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay); 4247 4290 AssertRC(rc); 4248 4291 } … … 4258 4301 { 4259 4302 RT_NOREF(uPass); 4260 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4303 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4261 4304 pDevIns->pHlpR3->pfnSSMPutMem(pSSM, &pThis->MacConfigured, sizeof(pThis->MacConfigured)); 4262 4305 return VINF_SSM_DONT_CALL_AGAIN; … … 4271 4314 { 4272 4315 RT_NOREF(pSSM); 4273 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4316 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4274 4317 4275 4318 int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_SEM_BUSY); … … 4286 4329 static DECLCALLBACK(int) dpNicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 4287 4330 { 4288 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4331 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4289 4332 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 4290 4333 … … 4359 4402 static DECLCALLBACK(int) dpNicLoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM) 4360 4403 { 4361 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4404 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4362 4405 RT_NOREF(pSSM); 4363 4406 … … 4376 4419 static DECLCALLBACK(int) dpNicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass) 4377 4420 { 4378 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE); 4379 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 4421 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4422 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 4423 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 4380 4424 4381 4425 if (SSM_VERSION_MAJOR_CHANGED(uVersion, DPNIC_SAVEDSTATE_VERSION)) … … 4452 4496 if ( memcmp(&Mac, &pThis->MacConfigured, sizeof(Mac)) 4453 4497 && (uPass == 0 || !PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) ) 4454 LogRel(("DPNIC#%u: The mac address differs: config=%RTmac saved=%RTmac\n", DPNIC_INSTANCE, &pThis->MacConfigured, &Mac));4498 LogRel(("DPNIC#%u: The mac address differs: config=%RTmac saved=%RTmac\n", pThis->iInstance, &pThis->MacConfigured, &Mac)); 4455 4499 4456 4500 if (uPass == SSM_PASS_FINAL) 4457 4501 { 4458 4502 /* update promiscuous mode. */ 4459 if (pThis ->pDrvR3)4460 pThis ->pDrvR3->pfnSetPromiscuousMode(pThis->pDrvR3, 0 /* promiscuous enabled */);4503 if (pThisCC->pDrv) 4504 pThisCC->pDrv->pfnSetPromiscuousMode(pThisCC->pDrv, 0 /* promiscuous enabled */); 4461 4505 4462 4506 /* Indicate link down to the guest OS that all network connections have 4463 4507 been lost, unless we've been teleported here. */ 4464 4508 if (!PDMDevHlpVMTeleportedAndNotFullyResumedYet(pDevIns)) 4465 dp8390TempLinkDown(p This);4509 dp8390TempLinkDown(pDevIns, pThis); 4466 4510 } 4467 4511 … … 4525 4569 free_pages = pCore->BNRY - pCore->CURR; 4526 4570 } 4527 Log2Func(("#%d: %u free pages (%u bytes)\n", DPNIC_INSTANCE, free_pages, free_pages * 256));4571 Log2Func(("#%d: %u free pages (%u bytes)\n", pThis->iInstance, free_pages, free_pages * 256)); 4528 4572 4529 4573 /* Six pages (1,536 bytes) is enough for the longest standard Ethernet frame … … 4533 4577 { 4534 4578 rc = VERR_NET_NO_BUFFER_SPACE; 4535 Log2Func(("#%d: Buffer space low, returning %Rrc!\n", DPNIC_INSTANCE, rc));4579 Log2Func(("#%d: Buffer space low, returning %Rrc!\n", pThis->iInstance, rc)); 4536 4580 } 4537 4581 } … … 4548 4592 static DECLCALLBACK(int) dpNicNet_WaitReceiveAvail(PPDMINETWORKDOWN pInterface, RTMSINTERVAL cMillies) 4549 4593 { 4550 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown); 4551 PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis); 4594 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown); 4595 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4596 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4552 4597 4553 4598 int rc = dp8390CanReceive(pDevIns, pThis); … … 4567 4612 STAM_PROFILE_START(&pThis->StatRxOverflow, a); 4568 4613 VMSTATE enmVMState; 4569 while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(p This->CTX_SUFF(pDevIns))) == VMSTATE_RUNNING4614 while (RT_LIKELY( (enmVMState = PDMDevHlpVMState(pDevIns)) == VMSTATE_RUNNING 4570 4615 || enmVMState == VMSTATE_RUNNING_LS)) 4571 4616 { … … 4597 4642 static DECLCALLBACK(int) dpNicNet_Receive(PPDMINETWORKDOWN pInterface, const void *pvBuf, size_t cb) 4598 4643 { 4599 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown); 4600 PPDMDEVINS pDevIns = DPNICSTATE_2_DEVINS(pThis); 4644 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown); 4645 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4646 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4601 4647 int rc; 4602 4648 … … 4607 4653 if (cb > 50) /* unqualified guess */ 4608 4654 pThis->Led.Asserted.s.fReading = pThis->Led.Actual.s.fReading = 1; 4609 dp8390CoreReceiveLocked(p This, (const uint8_t *)pvBuf, cb);4655 dp8390CoreReceiveLocked(pDevIns, pThis, (const uint8_t *)pvBuf, cb); 4610 4656 pThis->Led.Actual.s.fReading = 0; 4611 4657 … … 4622 4668 static DECLCALLBACK(void) dpNicNet_XmitPending(PPDMINETWORKDOWN pInterface) 4623 4669 { 4624 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkDown); 4625 dp8390CoreXmitPacket(pThis, true /*fOnWorkerThread*/); 4670 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkDown); 4671 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4672 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4673 dp8390CoreXmitPacket(pDevIns, pThis, true /*fOnWorkerThread*/); 4626 4674 } 4627 4675 … … 4634 4682 static DECLCALLBACK(int) dpNicGetMac(PPDMINETWORKCONFIG pInterface, PRTMAC pMac) 4635 4683 { 4636 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig); 4684 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig); 4685 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4686 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4687 4688 LogFlowFunc(("#%d\n", pThis->iInstance)); 4637 4689 /// @todo This is broken!! We can't properly get the MAC address set by the guest 4638 4690 #if 0 4639 memcpy(pMac, pThis-> aStationAddr, sizeof(*pMac));4691 memcpy(pMac, pThis->core.pg1.PAR, sizeof(*pMac)); 4640 4692 #else 4641 4693 memcpy(pMac, pThis->aPROM, sizeof(*pMac)); … … 4650 4702 static DECLCALLBACK(PDMNETWORKLINKSTATE) dpNicGetLinkState(PPDMINETWORKCONFIG pInterface) 4651 4703 { 4652 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig); 4704 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig); 4705 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4706 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4707 4653 4708 if (pThis->fLinkUp && !pThis->fLinkTempDown) 4654 4709 return PDMNETWORKLINKSTATE_UP; … … 4667 4722 static DECLCALLBACK(int) dpNicSetLinkState(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState) 4668 4723 { 4669 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, INetworkConfig); 4670 bool fLinkUp; 4671 4672 LogFlowFunc(("#%d\n", DPNIC_INSTANCE)); 4724 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, INetworkConfig); 4725 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4726 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4727 bool fLinkUp; 4728 4729 LogFlowFunc(("#%d\n", pThis->iInstance)); 4673 4730 AssertMsgReturn(enmState > PDMNETWORKLINKSTATE_INVALID && enmState <= PDMNETWORKLINKSTATE_DOWN_RESUME, 4674 4731 ("Invalid link state: enmState=%d\n", enmState), VERR_INVALID_PARAMETER); … … 4676 4733 if (enmState == PDMNETWORKLINKSTATE_DOWN_RESUME) 4677 4734 { 4678 dp8390TempLinkDown(p This);4735 dp8390TempLinkDown(pDevIns, pThis); 4679 4736 /* 4680 4737 * Note that we do not notify the driver about the link state change because … … 4695 4752 pThis->cLinkDownReported = 0; 4696 4753 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 4697 int rc = PDMDevHlpTimerSetMillies( DPNICSTATE_2_DEVINS(pThis), pThis->hTimerRestore, pThis->cMsLinkUpDelay);4754 int rc = PDMDevHlpTimerSetMillies(pDevIns, pThis->hTimerRestore, pThis->cMsLinkUpDelay); 4698 4755 AssertRC(rc); 4699 4756 } … … 4704 4761 pThis->Led.Asserted.s.fError = pThis->Led.Actual.s.fError = 1; 4705 4762 } 4706 Assert(!PDMDevHlpCritSectIsOwner( DPNICSTATE_2_DEVINS(pThis), &pThis->CritSect));4707 if (pThis ->pDrvR3)4708 pThis ->pDrvR3->pfnNotifyLinkChanged(pThis->pDrvR3, enmState);4763 Assert(!PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect)); 4764 if (pThisCC->pDrv) 4765 pThisCC->pDrv->pfnNotifyLinkChanged(pThisCC->pDrv, enmState); 4709 4766 } 4710 4767 return VINF_SUCCESS; … … 4719 4776 static DECLCALLBACK(int) dpNicQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed) 4720 4777 { 4721 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, ILeds); 4778 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, ILeds); 4779 PPDMDEVINS pDevIns = pThisCC->pDevIns; 4780 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4722 4781 if (iLUN == 0) 4723 4782 { … … 4736 4795 static DECLCALLBACK(void *) dpNicQueryInterface(struct PDMIBASE *pInterface, const char *pszIID) 4737 4796 { 4738 PDPNICSTATE pThis = RT_FROM_MEMBER(pInterface, DPNICSTATE, IBase);4739 Assert(&pThis ->IBase == pInterface);4740 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis ->IBase);4741 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThis ->INetworkDown);4742 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThis ->INetworkConfig);4743 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis ->ILeds);4797 PDPNICSTATECC pThisCC = RT_FROM_MEMBER(pInterface, DPNICSTATECC, IBase); 4798 Assert(&pThisCC->IBase == pInterface); 4799 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase); 4800 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKDOWN, &pThisCC->INetworkDown); 4801 PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKCONFIG, &pThisCC->INetworkConfig); 4802 PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThisCC->ILeds); 4744 4803 return NULL; 4745 4804 } … … 4751 4810 * @interface_method_impl{PDMDEVREG,pfnPowerOff} 4752 4811 */ 4753 static DECLCALLBACK(void) dpNic PowerOff(PPDMDEVINS pDevIns)4812 static DECLCALLBACK(void) dpNicR3PowerOff(PPDMDEVINS pDevIns) 4754 4813 { 4755 4814 /* Poke thread waiting for buffer space. */ 4756 dp8390 WakeupReceive(pDevIns);4815 dp8390R3WakeupReceive(pDevIns); 4757 4816 } 4758 4817 … … 4763 4822 * One port on the network card has been disconnected from the network. 4764 4823 */ 4765 static DECLCALLBACK(void) dpNicDetach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 4766 { 4824 static DECLCALLBACK(void) dpNicR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 4825 { 4826 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4827 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 4767 4828 RT_NOREF(fFlags); 4768 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE); 4769 LogFlowFunc(("#%d\n", DPNIC_INSTANCE)); 4829 LogFlowFunc(("#%d\n", pThis->iInstance)); 4770 4830 4771 4831 AssertLogRelReturnVoid(iLUN == 0); … … 4777 4837 * Zero some important members. 4778 4838 */ 4779 pThis->pDrvBase = NULL; 4780 pThis->pDrvR3 = NULL; 4781 pThis->pDrvR0 = NIL_RTR0PTR; 4782 pThis->pDrvRC = NIL_RTRCPTR; 4839 pThis->fDriverAttached = false; 4840 pThisCC->pDrvBase = NULL; 4841 pThisCC->pDrv = NULL; 4783 4842 4784 4843 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 4790 4849 * One port on the network card has been connected to a network. 4791 4850 */ 4792 static DECLCALLBACK(int) dpNicAttach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 4793 { 4851 static DECLCALLBACK(int) dpNicR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags) 4852 { 4853 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4854 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 4794 4855 RT_NOREF(fFlags); 4795 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE); 4796 LogFlowFunc(("#%d\n", DPNIC_INSTANCE)); 4856 LogFlowFunc(("#%d\n", pThis->iInstance)); 4797 4857 4798 4858 AssertLogRelReturn(iLUN == 0, VERR_PDM_NO_SUCH_LUN); … … 4804 4864 * Attach the driver. 4805 4865 */ 4806 int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis ->IBase, &pThis->pDrvBase, "Network Port");4866 int rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port"); 4807 4867 if (RT_SUCCESS(rc)) 4808 4868 { 4809 pThis ->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);4810 AssertMsgStmt(pThis ->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),4869 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP); 4870 AssertMsgStmt(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"), 4811 4871 rc = VERR_PDM_MISSING_INTERFACE_BELOW); 4812 pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP); 4813 pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP); 4872 pThis->fDriverAttached = true; 4814 4873 } 4815 4874 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER … … 4818 4877 /* This should never happen because this function is not called 4819 4878 * if there is no driver to attach! */ 4820 LogFunc(("#%d No attached driver!\n", DPNIC_INSTANCE));4879 LogFunc(("#%d No attached driver!\n", pThis->iInstance)); 4821 4880 } 4822 4881 … … 4827 4886 */ 4828 4887 if (RT_SUCCESS(rc)) 4829 dp8390TempLinkDown(p This);4888 dp8390TempLinkDown(pDevIns, pThis); 4830 4889 4831 4890 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); … … 4837 4896 * @interface_method_impl{PDMDEVREG,pfnSuspend} 4838 4897 */ 4839 static DECLCALLBACK(void) dpNic Suspend(PPDMDEVINS pDevIns)4898 static DECLCALLBACK(void) dpNicR3Suspend(PPDMDEVINS pDevIns) 4840 4899 { 4841 4900 /* Poke thread waiting for buffer space. */ 4842 dp8390 WakeupReceive(pDevIns);4901 dp8390R3WakeupReceive(pDevIns); 4843 4902 } 4844 4903 … … 4847 4906 * @interface_method_impl{PDMDEVREG,pfnReset} 4848 4907 */ 4849 static DECLCALLBACK(void) dpNicR eset(PPDMDEVINS pDevIns)4850 { 4851 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4852 LogFlowFunc(("#%d\n", DPNIC_INSTANCE));4908 static DECLCALLBACK(void) dpNicR3Reset(PPDMDEVINS pDevIns) 4909 { 4910 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4911 LogFlowFunc(("#%d\n", pThis->iInstance)); 4853 4912 if (pThis->fLinkTempDown) 4854 4913 { … … 4858 4917 } 4859 4918 4860 dpNicR3HardReset(p This);4919 dpNicR3HardReset(pDevIns, pThis); 4861 4920 } 4862 4921 … … 4865 4924 * @interface_method_impl{PDMDEVREG,pfnRelocate} 4866 4925 */ 4867 static DECLCALLBACK(void) dpNicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta) 4868 { 4869 RT_NOREF(offDelta); 4870 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE); 4871 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 4926 static DECLCALLBACK(void) dpNicR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta) 4927 { 4928 PDPNICSTATERC pThisRC = PDMINS_2_DATA_RC(pDevIns, PDPNICSTATERC); 4929 pThisRC->pDrv += offDelta; 4872 4930 } 4873 4931 … … 4876 4934 * @interface_method_impl{PDMDEVREG,pfnDestruct} 4877 4935 */ 4878 static DECLCALLBACK(int) dpNic Destruct(PPDMDEVINS pDevIns)4936 static DECLCALLBACK(int) dpNicR3Destruct(PPDMDEVINS pDevIns) 4879 4937 { 4880 4938 PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns); 4881 PDPNICSTATE pThis = PDM INS_2_DATA(pDevIns, PDPNICSTATE);4939 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4882 4940 4883 4941 if (PDMDevHlpCritSectIsInitialized(pDevIns, &pThis->CritSect)) … … 4895 4953 * @interface_method_impl{PDMDEVREG,pfnConstruct} 4896 4954 */ 4897 static DECLCALLBACK(int) dpNic Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)4955 static DECLCALLBACK(int) dpNicR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg) 4898 4956 { 4899 4957 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); 4900 PDPNICSTATE pThis = PDMINS_2_DATA(pDevIns, PDPNICSTATE); 4958 PDPNICSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDPNICSTATE); 4959 PDPNICSTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PDPNICSTATECC); 4901 4960 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3; 4902 4961 PPDMIBASE pBase; … … 4911 4970 pThis->hIoPortsNic = NIL_IOMIOPORTHANDLE; 4912 4971 pThis->hIoPortsCore = NIL_IOMIOPORTHANDLE; 4972 pThisCC->pDevIns = pDevIns; 4913 4973 4914 4974 /* … … 5026 5086 * Initialize data (most of it anyway). 5027 5087 */ 5028 pThis->pDevInsR3 = pDevIns; 5029 pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns); 5030 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns); 5031 pThis->Led.u32Magic = PDMLED_MAGIC; 5088 pThis->Led.u32Magic = PDMLED_MAGIC; 5032 5089 /* IBase */ 5033 pThis ->IBase.pfnQueryInterface = dpNicQueryInterface;5090 pThisCC->IBase.pfnQueryInterface = dpNicQueryInterface; 5034 5091 /* INetworkPort */ 5035 pThis ->INetworkDown.pfnWaitReceiveAvail = dpNicNet_WaitReceiveAvail;5036 pThis ->INetworkDown.pfnReceive = dpNicNet_Receive;5037 pThis ->INetworkDown.pfnXmitPending = dpNicNet_XmitPending;5092 pThisCC->INetworkDown.pfnWaitReceiveAvail = dpNicNet_WaitReceiveAvail; 5093 pThisCC->INetworkDown.pfnReceive = dpNicNet_Receive; 5094 pThisCC->INetworkDown.pfnXmitPending = dpNicNet_XmitPending; 5038 5095 /* INetworkConfig */ 5039 pThis ->INetworkConfig.pfnGetMac = dpNicGetMac;5040 pThis ->INetworkConfig.pfnGetLinkState = dpNicGetLinkState;5041 pThis ->INetworkConfig.pfnSetLinkState = dpNicSetLinkState;5096 pThisCC->INetworkConfig.pfnGetMac = dpNicGetMac; 5097 pThisCC->INetworkConfig.pfnGetLinkState = dpNicGetLinkState; 5098 pThisCC->INetworkConfig.pfnSetLinkState = dpNicSetLinkState; 5042 5099 /* ILeds */ 5043 pThis ->ILeds.pfnQueryStatusLed = dpNicQueryStatusLed;5100 pThisCC->ILeds.pfnQueryStatusLed = dpNicQueryStatusLed; 5044 5101 5045 5102 pThis->hIoPortsCore = NIL_IOMIOPORTHANDLE; … … 5176 5233 * Register the info item. 5177 5234 */ 5178 RTStrPrintf(szTmp, sizeof(szTmp), "dpnic%d", p DevIns->iInstance);5235 RTStrPrintf(szTmp, sizeof(szTmp), "dpnic%d", pThis->iInstance); 5179 5236 PDMDevHlpDBGFInfoRegister(pDevIns, szTmp, "dpnic info", dpNicInfo); 5180 5237 … … 5182 5239 * Attach status driver (optional). 5183 5240 */ 5184 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThis ->IBase, &pBase, "Status Port");5241 rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pThisCC->IBase, &pBase, "Status Port"); 5185 5242 if (RT_SUCCESS(rc)) 5186 pThis ->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);5243 pThisCC->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS); 5187 5244 else if ( rc != VERR_PDM_NO_ATTACHED_DRIVER 5188 5245 && rc != VERR_PDM_CFG_MISSING_DRIVER_NAME) … … 5195 5252 * Attach driver. 5196 5253 */ 5197 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis ->IBase, &pThis->pDrvBase, "Network Port");5254 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThisCC->IBase, &pThisCC->pDrvBase, "Network Port"); 5198 5255 if (RT_SUCCESS(rc)) 5199 5256 { 5200 pThis ->pDrvR3 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMINETWORKUP);5201 AssertMsgReturn(pThis ->pDrvR3, ("Failed to obtain the PDMINETWORKUP interface!\n"),5257 pThisCC->pDrv = PDMIBASE_QUERY_INTERFACE(pThisCC->pDrvBase, PDMINETWORKUP); 5258 AssertMsgReturn(pThisCC->pDrv, ("Failed to obtain the PDMINETWORKUP interface!\n"), 5202 5259 VERR_PDM_MISSING_INTERFACE_BELOW); 5203 pThis->pDrvR0 = PDMIBASER0_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASER0), PDMINETWORKUP); 5204 pThis->pDrvRC = PDMIBASERC_QUERY_INTERFACE(PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIBASERC), PDMINETWORKUP); 5260 pThis->fDriverAttached = true; 5205 5261 } 5206 5262 else if ( rc == VERR_PDM_NO_ATTACHED_DRIVER … … 5216 5272 * Reset the device state. (Do after attaching.) 5217 5273 */ 5218 dpNicR3HardReset(p This);5274 dpNicR3HardReset(pDevIns, pThis); 5219 5275 5220 5276 /* … … 5343 5399 /* .uSharedVersion = */ 42, 5344 5400 /* .cbInstanceShared = */ sizeof(DPNICSTATE), 5345 /* .cbInstanceCC = */ 0,5346 /* .cbInstanceRC = */ 0,5401 /* .cbInstanceCC = */ sizeof(DPNICSTATECC), 5402 /* .cbInstanceRC = */ sizeof(DPNICSTATERC), 5347 5403 /* .cMaxPciDevices = */ 0, 5348 5404 /* .cMaxMsixVectors = */ 0, … … 5351 5407 /* .pszRCMod = */ "VBoxDDRC.rc", 5352 5408 /* .pszR0Mod = */ "VBoxDDR0.r0", 5353 /* .pfnConstruct = */ dpNic Construct,5354 /* .pfnDestruct = */ dpNic Destruct,5355 /* .pfnRelocate = */ dpNicR elocate,5409 /* .pfnConstruct = */ dpNicR3Construct, 5410 /* .pfnDestruct = */ dpNicR3Destruct, 5411 /* .pfnRelocate = */ dpNicR3Relocate, 5356 5412 /* .pfnMemSetup = */ NULL, 5357 5413 /* .pfnPowerOn = */ NULL, 5358 /* .pfnReset = */ dpNicR eset,5359 /* .pfnSuspend = */ dpNic Suspend,5414 /* .pfnReset = */ dpNicR3Reset, 5415 /* .pfnSuspend = */ dpNicR3Suspend, 5360 5416 /* .pfnResume = */ NULL, 5361 /* .pfnAttach = */ dpNic Attach,5362 /* .pfnDetach = */ dpNic Detach,5417 /* .pfnAttach = */ dpNicR3Attach, 5418 /* .pfnDetach = */ dpNicR3Detach, 5363 5419 /* .pfnQueryInterface = */ NULL, 5364 5420 /* .pfnInitComplete = */ NULL, 5365 /* .pfnPowerOff = */ dpNic PowerOff,5421 /* .pfnPowerOff = */ dpNicR3PowerOff, 5366 5422 /* .pfnSoftReset = */ NULL, 5367 5423 /* .pfnReserved0 = */ NULL,
Note:
See TracChangeset
for help on using the changeset viewer.