Virtio.cpp revision 7c324fdbe6f4ff55fd17bb0c8c5fba58e1ad02f3
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/* $Id$ */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/** @file
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Virtio - Virtio Common Functions (VRing, VQueue, Virtio PCI)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/*
c90d31f80888da118a5d230aabab08ad5c23c00dvboxsync * Copyright (C) 2009-2012 Oracle Corporation
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * available from http://www.virtualbox.org. This file is free software;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * you can redistribute it and/or modify it under the terms of the GNU
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * General Public License (GPL) as published by the Free Software
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/*******************************************************************************
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync* Header Files *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync*******************************************************************************/
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#define LOG_GROUP LOG_GROUP_DEV_VIRTIO
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <iprt/param.h>
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync#include <iprt/uuid.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include <VBox/vmm/pdmdev.h>
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#include "Virtio.h"
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#define INSTANCE(pState) pState->szInstance
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#define IFACE_TO_STATE(pIface, ifaceName) ((VPCISTATE *)((char*)pIface - RT_OFFSETOF(VPCISTATE, ifaceName)))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#ifdef LOG_ENABLED
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync# define QUEUENAME(s, q) (q->pcszName)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#endif /* DEBUG */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
28626a5957b49791b505bf66131448a847043763vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync
ae6cc8f82ba26e3940022ea7d26078bec3d2a05fvboxsync#ifndef VBOX_DEVICE_STRUCT_TESTCASE
2f827df539da232220444c27f2b207a707a045b0vboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsync//RT_C_DECLS_BEGIN
2f827df539da232220444c27f2b207a707a045b0vboxsync//RT_C_DECLS_END
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncstatic void vqueueReset(PVQUEUE pQueue)
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync{
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync pQueue->VRing.addrDescriptors = 0;
9b0ba1d4360299b4e6ee23c946feb5a4f16c6d00vboxsync pQueue->VRing.addrAvail = 0;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pQueue->VRing.addrUsed = 0;
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync pQueue->uNextAvailIndex = 0;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pQueue->uNextUsedIndex = 0;
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync pQueue->uPageNumber = 0;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync}
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsync
7cca5a9aeb06913531b982bf772508d09b4c2f0bvboxsyncstatic void vqueueInit(PVQUEUE pQueue, uint32_t uPageNumber)
2f827df539da232220444c27f2b207a707a045b0vboxsync{
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync pQueue->VRing.addrDescriptors = (uint64_t)uPageNumber << PAGE_SHIFT;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pQueue->VRing.addrAvail = pQueue->VRing.addrDescriptors
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync + sizeof(VRINGDESC) * pQueue->VRing.uSize;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pQueue->VRing.addrUsed = RT_ALIGN(
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync pQueue->VRing.addrAvail + RT_OFFSETOF(VRINGAVAIL, auRing[pQueue->VRing.uSize]),
2f827df539da232220444c27f2b207a707a045b0vboxsync PAGE_SIZE); /* The used ring must start from the next page. */
2f827df539da232220444c27f2b207a707a045b0vboxsync pQueue->uNextAvailIndex = 0;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pQueue->uNextUsedIndex = 0;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// void vqueueElemFree(PVQUEUEELEM pElem)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync// {
69485a2b3107976ff92a4f3db3ea862e25544059vboxsync// }
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncvoid vringReadDesc(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex, PVRINGDESC pDesc)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync //Log(("%s vringReadDesc: ring=%p idx=%u\n", INSTANCE(pState), pVRing, uIndex));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pVRing->addrDescriptors + sizeof(VRINGDESC) * (uIndex % pVRing->uSize),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pDesc, sizeof(VRINGDESC));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncuint16_t vringReadAvail(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync uint16_t tmp;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pVRing->addrAvail + RT_OFFSETOF(VRINGAVAIL, auRing[uIndex % pVRing->uSize]),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync &tmp, sizeof(tmp));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync return tmp;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncuint16_t vringReadAvailFlags(PVPCISTATE pState, PVRING pVRing)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync uint16_t tmp;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pVRing->addrAvail + RT_OFFSETOF(VRINGAVAIL, uFlags),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync &tmp, sizeof(tmp));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync return tmp;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsyncvoid vringSetNotification(PVPCISTATE pState, PVRING pVRing, bool fEnabled)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync{
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync uint16_t tmp;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uFlags),
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync &tmp, sizeof(tmp));
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync if (fEnabled)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync tmp &= ~ VRINGUSED_F_NO_NOTIFY;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync else
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync tmp |= VRINGUSED_F_NO_NOTIFY;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uFlags),
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync &tmp, sizeof(tmp));
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync}
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsyncbool vqueueSkip(PVPCISTATE pState, PVQUEUE pQueue)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (vqueueIsEmpty(pState, pQueue))
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync return false;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
7f9e93577d96c7f2a6977229c1baab57d5ec94e4vboxsync Log2(("%s vqueueSkip: %s avail_idx=%u\n", INSTANCE(pState),
2f827df539da232220444c27f2b207a707a045b0vboxsync QUEUENAME(pState, pQueue), pQueue->uNextAvailIndex));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pQueue->uNextAvailIndex++;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync return true;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsyncbool vqueueGet(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, bool fRemove)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (vqueueIsEmpty(pState, pQueue))
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync return false;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pElem->nIn = pElem->nOut = 0;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync Log2(("%s vqueueGet: %s avail_idx=%u\n", INSTANCE(pState),
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync QUEUENAME(pState, pQueue), pQueue->uNextAvailIndex));
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync VRINGDESC desc;
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync uint16_t idx = vringReadAvail(pState, &pQueue->VRing, pQueue->uNextAvailIndex);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync if (fRemove)
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync pQueue->uNextAvailIndex++;
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync pElem->uIndex = idx;
5b0adfbdd9550a026f5d6209743504562f791f97vboxsync do
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync {
f2e1f71feb5d4ec79d46defcd71de0763234b1e2vboxsync VQUEUESEG *pSeg;
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync
f2e1f71feb5d4ec79d46defcd71de0763234b1e2vboxsync vringReadDesc(pState, &pQueue->VRing, idx, &desc);
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync if (desc.u16Flags & VRINGDESC_F_WRITE)
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync {
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync Log2(("%s vqueueGet: %s IN seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pState),
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync QUEUENAME(pState, pQueue), pElem->nIn, idx, desc.u64Addr, desc.uLen));
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync pSeg = &pElem->aSegsIn[pElem->nIn++];
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync }
2cb52dd865592ea8e27b588beb22898d189646b1vboxsync else
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Log2(("%s vqueueGet: %s OUT seg=%u desc_idx=%u addr=%p cb=%u\n", INSTANCE(pState),
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync QUEUENAME(pState, pQueue), pElem->nOut, idx, desc.u64Addr, desc.uLen));
581bb0c43dececce2fbba05cfb77d9a59c88a078vboxsync pSeg = &pElem->aSegsOut[pElem->nOut++];
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pSeg->addr = desc.u64Addr;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pSeg->cb = desc.uLen;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pSeg->pv = NULL;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync idx = desc.u16Next;
2f827df539da232220444c27f2b207a707a045b0vboxsync } while (desc.u16Flags & VRINGDESC_F_NEXT);
2f827df539da232220444c27f2b207a707a045b0vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Log2(("%s vqueueGet: %s head_desc_idx=%u nIn=%u nOut=%u\n", INSTANCE(pState),
2f827df539da232220444c27f2b207a707a045b0vboxsync QUEUENAME(pState, pQueue), pElem->uIndex, pElem->nIn, pElem->nOut));
2f827df539da232220444c27f2b207a707a045b0vboxsync return true;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2cb52dd865592ea8e27b588beb22898d189646b1vboxsyncuint16_t vringReadUsedIndex(PVPCISTATE pState, PVRING pVRing)
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync{
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync uint16_t tmp;
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uIndex),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync &tmp, sizeof(tmp));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync return tmp;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsyncvoid vringWriteUsedIndex(PVPCISTATE pState, PVRING pVRing, uint16_t u16Value)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uIndex),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync &u16Value, sizeof(u16Value));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsyncvoid vringWriteUsedElem(PVPCISTATE pState, PVRING pVRing, uint32_t uIndex, uint32_t uId, uint32_t uLen)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync VRINGUSEDELEM elem;
2f827df539da232220444c27f2b207a707a045b0vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync elem.uId = uId;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync elem.uLen = uLen;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, aRing[uIndex % pVRing->uSize]),
2f827df539da232220444c27f2b207a707a045b0vboxsync &elem, sizeof(elem));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncvoid vqueuePut(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t uLen, uint32_t uReserved)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync unsigned int i, uOffset, cbReserved = uReserved;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Log2(("%s vqueuePut: %s desc_idx=%u acb=%u\n", INSTANCE(pState),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync QUEUENAME(pState, pQueue), pElem->uIndex, uLen));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync for (i = uOffset = 0; i < pElem->nIn && uOffset < uLen - uReserved; i++)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync uint32_t cbSegLen = RT_MIN(uLen - cbReserved - uOffset, pElem->aSegsIn[i].cb - cbReserved);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (pElem->aSegsIn[i].pv)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Log2(("%s vqueuePut: %s used_idx=%u seg=%u addr=%p pv=%p cb=%u acb=%u\n", INSTANCE(pState),
523f2a6676210ab8601d3fdb2fdabe7dcdea7d4cvboxsync QUEUENAME(pState, pQueue), pQueue->uNextUsedIndex, i, pElem->aSegsIn[i].addr, pElem->aSegsIn[i].pv, pElem->aSegsIn[i].cb, cbSegLen));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns), pElem->aSegsIn[i].addr + cbReserved,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync pElem->aSegsIn[i].pv, cbSegLen);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync cbReserved = 0;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync uOffset += cbSegLen;
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync }
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync Assert((uReserved + uOffset) == uLen || pElem->nIn == 0);
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync Log2(("%s vqueuePut: %s used_idx=%u guest_used_idx=%u id=%u len=%u\n", INSTANCE(pState),
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync QUEUENAME(pState, pQueue), pQueue->uNextUsedIndex, vringReadUsedIndex(pState, &pQueue->VRing), pElem->uIndex, uLen));
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync vringWriteUsedElem(pState, &pQueue->VRing, pQueue->uNextUsedIndex++, pElem->uIndex, uLen);
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync}
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsyncvoid vqueueNotify(PVPCISTATE pState, PVQUEUE pQueue)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync LogFlow(("%s vqueueNotify: %s availFlags=%x guestFeatures=%x vqueue is %sempty\n",
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync INSTANCE(pState), QUEUENAME(pState, pQueue),
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync vringReadAvailFlags(pState, &pQueue->VRing),
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->uGuestFeatures, vqueueIsEmpty(pState, pQueue)?"":"not "));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (!(vringReadAvailFlags(pState, &pQueue->VRing) & VRINGAVAIL_F_NO_INTERRUPT)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync || ((pState->uGuestFeatures & VPCI_F_NOTIFY_ON_EMPTY) && vqueueIsEmpty(pState, pQueue)))
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync int rc = vpciRaiseInterrupt(pState, VERR_INTERNAL_ERROR, VPCI_ISR_QUEUE);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (RT_FAILURE(rc))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Log(("%s vqueueNotify: Failed to raise an interrupt (%Rrc).\n", INSTANCE(pState), rc));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync else
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync STAM_COUNTER_INC(&pState->StatIntsSkipped);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync }
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
515bedd29819574258817b27cd304587d407810fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
2f827df539da232220444c27f2b207a707a045b0vboxsyncvoid vqueueSync(PVPCISTATE pState, PVQUEUE pQueue)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Log2(("%s vqueueSync: %s old_used_idx=%u new_used_idx=%u\n", INSTANCE(pState),
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync QUEUENAME(pState, pQueue), vringReadUsedIndex(pState, &pQueue->VRing), pQueue->uNextUsedIndex));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync vringWriteUsedIndex(pState, &pQueue->VRing, pQueue->uNextUsedIndex);
2f827df539da232220444c27f2b207a707a045b0vboxsync vqueueNotify(pState, pQueue);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync}
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsyncvoid vpciReset(PVPCISTATE pState)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync{
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pState->uGuestFeatures = 0;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pState->uQueueSelector = 0;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pState->uStatus = 0;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pState->uISR = 0;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync for (unsigned i = 0; i < pState->nQueues; i++)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync vqueueReset(&pState->Queues[i]);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync}
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync/**
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync * Raise interrupt.
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param pState The device state structure.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param rcBusy Status code to return when the critical section is busy.
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync * @param u8IntCause Interrupt cause bit mask to set in PCI ISR port.
c90d31f80888da118a5d230aabab08ad5c23c00dvboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncint vpciRaiseInterrupt(VPCISTATE *pState, int rcBusy, uint8_t u8IntCause)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync // int rc = vpciCsEnter(pState, rcBusy);
3adea7c30ebc76f2e5975ad9052a40c174f588f3vboxsync // if (RT_UNLIKELY(rc != VINF_SUCCESS))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // return rc;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync STAM_COUNTER_INC(&pState->StatIntsRaised);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync LogFlow(("%s vpciRaiseInterrupt: u8IntCause=%x\n",
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync INSTANCE(pState), u8IntCause));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync pState->uISR |= u8IntCause;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync PDMDevHlpPCISetIrq(pState->CTX_SUFF(pDevIns), 0, 1);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync // vpciCsLeave(pState);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync return VINF_SUCCESS;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync/**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Lower interrupt.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param pState The device state structure.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncstatic void vpciLowerInterrupt(VPCISTATE *pState)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync LogFlow(("%s vpciLowerInterrupt\n", INSTANCE(pState)));
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync PDMDevHlpPCISetIrq(pState->CTX_SUFF(pDevIns), 0, 0);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync}
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncDECLINLINE(uint32_t) vpciGetHostFeatures(PVPCISTATE pState,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync PFNGETHOSTFEATURES pfnGetHostFeatures)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync return pfnGetHostFeatures(pState)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync | VPCI_F_NOTIFY_ON_EMPTY;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync}
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync/**
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * Port I/O Handler for IN operations.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @returns VBox status code.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param pDevIns The device instance.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param pvUser Pointer to the device state structure.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param Port Port number used for the IN operation.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @param pu32 Where to store the result.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param cb Number of bytes read.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * @thread EMT
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsyncint vpciIOPortIn(PPDMDEVINS pDevIns,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync void *pvUser,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync RTIOPORT Port,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync uint32_t *pu32,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync unsigned cb,
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync PFNGETHOSTFEATURES pfnGetHostFeatures,
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync PFNGETCONFIG pfnGetConfig)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync{
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync VPCISTATE *pState = PDMINS_2_DATA(pDevIns, VPCISTATE *);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync int rc = VINF_SUCCESS;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync STAM_PROFILE_ADV_START(&pState->CTXSUFF(StatIORead), a);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /*
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * We probably do not need to enter critical section when reading registers
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * as the most of them are either constant or being changed during
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * initialization only, the exception being ISR which can be raced by all
75e8721fd1fe3ee8c1dd3e8404381def8ae5ca53vboxsync * threads but I see no big harm in it. It also happens to be the most read
75e8721fd1fe3ee8c1dd3e8404381def8ae5ca53vboxsync * register as it gets read in interrupt handler. By dropping cs protection
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * here we gain the ability to deliver RX packets to the guest while TX is
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync * holding cs transmitting queued packets.
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync rc = vpciCsEnter(pState, VINF_IOM_R3_IOPORT_READ);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync if (RT_UNLIKELY(rc != VINF_SUCCESS))
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync {
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync STAM_PROFILE_ADV_STOP(&pState->CTXSUFF(StatIORead), a);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync return rc;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }*/
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Port -= pState->IOPortBase;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync switch (Port)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_HOST_FEATURES:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync /* Tell the guest what features we support. */
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *pu32 = vpciGetHostFeatures(pState, pfnGetHostFeatures)
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync | VPCI_F_BAD_FEATURE;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_GUEST_FEATURES:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *pu32 = pState->uGuestFeatures;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_QUEUE_PFN:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *pu32 = pState->Queues[pState->uQueueSelector].uPageNumber;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_QUEUE_NUM:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Assert(cb == 2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *(uint16_t*)pu32 = pState->Queues[pState->uQueueSelector].VRing.uSize;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync case VPCI_QUEUE_SEL:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Assert(cb == 2);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *(uint16_t*)pu32 = pState->uQueueSelector;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_STATUS:
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync Assert(cb == 1);
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync *(uint8_t*)pu32 = pState->uStatus;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync break;
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync case VPCI_ISR:
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Assert(cb == 1);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *(uint8_t*)pu32 = pState->uISR;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync pState->uISR = 0; /* read clears all interrupts */
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync vpciLowerInterrupt(pState);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync break;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync default:
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync if (Port >= VPCI_CONFIG)
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync rc = pfnGetConfig(pState, Port - VPCI_CONFIG, cb, pu32);
2f827df539da232220444c27f2b207a707a045b0vboxsync else
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync {
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync *pu32 = 0xFFFFFFFF;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "%s vpciIOPortIn: no valid port at offset port=%RTiop cb=%08x\n",
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync INSTANCE(pState), Port, cb);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync break;
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync }
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync Log3(("%s vpciIOPortIn: At %RTiop in %0*x\n", INSTANCE(pState), Port, cb*2, *pu32));
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync STAM_PROFILE_ADV_STOP(&pState->CTXSUFF(StatIORead), a);
2f827df539da232220444c27f2b207a707a045b0vboxsync //vpciCsLeave(pState);
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync return rc;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
f46e7db81f80ea09725c6cc048fa0cad86573dc2vboxsync
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync/**
56f538fa476fdbd9cc3d60438083a3f0d5f3ff7fvboxsync * Port I/O Handler for OUT operations.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync *
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @returns VBox status code.
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync *
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @param pDevIns The device instance.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @param pvUser User argument.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @param Port Port number used for the IN operation.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @param u32 The value to output.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @param cb The value size in bytes.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @todo r=bird: Use a callback table instead of passing 6 function pointers
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * for potential operations with each I/O port write.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * @thread EMT
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync */
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsyncint vpciIOPortOut(PPDMDEVINS pDevIns,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync void *pvUser,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync RTIOPORT Port,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync uint32_t u32,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync unsigned cb,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNGETHOSTMINIMALFEATURES pfnGetHostMinimalFeatures,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNGETHOSTFEATURES pfnGetHostFeatures,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNSETHOSTFEATURES pfnSetHostFeatures,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNRESET pfnReset,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNREADY pfnReady,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync PFNSETCONFIG pfnSetConfig)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync{
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync VPCISTATE *pState = PDMINS_2_DATA(pDevIns, VPCISTATE *);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync int rc = VINF_SUCCESS;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync bool fHasBecomeReady;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync STAM_PROFILE_ADV_START(&pState->CTXSUFF(StatIOWrite), a);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync Port -= pState->IOPortBase;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Log3(("%s virtioIOPortOut: At %RTiop out %0*x\n", INSTANCE(pState), Port, cb*2, u32));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync switch (Port)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync case VPCI_GUEST_FEATURES:
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync /* Check if the guest negotiates properly, fall back to basics if it does not. */
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync if (VPCI_F_BAD_FEATURE & u32)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Log(("%s WARNING! Guest failed to negotiate properly (guest=%x)\n",
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync INSTANCE(pState), u32));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pState->uGuestFeatures = pfnGetHostMinimalFeatures(pState);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync /* The guest may potentially desire features we don't support! */
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync else if (~vpciGetHostFeatures(pState, pfnGetHostFeatures) & u32)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync {
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync Log(("%s Guest asked for features host does not support! (host=%x guest=%x)\n",
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync INSTANCE(pState),
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync vpciGetHostFeatures(pState, pfnGetHostFeatures), u32));
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pState->uGuestFeatures =
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync vpciGetHostFeatures(pState, pfnGetHostFeatures);
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync }
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync else
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pState->uGuestFeatures = u32;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pfnSetHostFeatures(pState, pState->uGuestFeatures);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync break;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync case VPCI_QUEUE_PFN:
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync /*
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * The guest is responsible for allocating the pages for queues,
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * here it provides us with the page number of descriptor table.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * Note that we provide the size of the queue to the guest via
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync * VIRTIO_PCI_QUEUE_NUM.
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync */
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pState->Queues[pState->uQueueSelector].uPageNumber = u32;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync if (u32)
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync vqueueInit(&pState->Queues[pState->uQueueSelector], u32);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync else
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync rc = pfnReset(pState);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync break;
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync case VPCI_QUEUE_SEL:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Assert(cb == 2);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync u32 &= 0xFFFF;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (u32 < pState->nQueues)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->uQueueSelector = u32;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync else
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Log3(("%s vpciIOPortOut: Invalid queue selector %08x\n", INSTANCE(pState), u32));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync break;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync case VPCI_QUEUE_NOTIFY:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync#ifdef IN_RING3
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync Assert(cb == 2);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync u32 &= 0xFFFF;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync if (u32 < pState->nQueues)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (pState->Queues[u32].VRing.addrDescriptors)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync {
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync // rc = vpciCsEnter(pState, VERR_SEM_BUSY);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync // if (RT_LIKELY(rc == VINF_SUCCESS))
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync // {
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync pState->Queues[u32].pfnCallback(pState, &pState->Queues[u32]);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync // vpciCsLeave(pState);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync // }
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync else
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync Log(("%s The queue (#%d) being notified has not been initialized.\n",
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync INSTANCE(pState), u32));
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync else
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync Log(("%s Invalid queue number (%d)\n", INSTANCE(pState), u32));
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync#else
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = VINF_IOM_R3_IOPORT_WRITE;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync#endif
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync break;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync case VPCI_STATUS:
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Assert(cb == 1);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync u32 &= 0xFF;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync fHasBecomeReady = !(pState->uStatus & VPCI_STATUS_DRV_OK) && (u32 & VPCI_STATUS_DRV_OK);
4bb5cfa1f4d9e95d7d34b5d6ede18d9f4d433bc6vboxsync pState->uStatus = u32;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync /* Writing 0 to the status port triggers device reset. */
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync if (u32 == 0)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync rc = pfnReset(pState);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync else if (fHasBecomeReady)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync pfnReady(pState);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync break;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync default:
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync if (Port >= VPCI_CONFIG)
7753dc7a3bcd14c9ec9d969cbc1a0155b0673c06vboxsync rc = pfnSetConfig(pState, Port - VPCI_CONFIG, cb, &u32);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync else
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "%s vpciIOPortOut: no valid port at offset Port=%RTiop cb=%08x\n",
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync INSTANCE(pState), Port, cb);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync break;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync }
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync STAM_PROFILE_ADV_STOP(&pState->CTXSUFF(StatIOWrite), a);
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync return rc;
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync}
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync#ifdef IN_RING3
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync/**
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @interface_method_impl{PDMIBASE,pfnQueryInterface}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsyncvoid *vpciQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync{
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync VPCISTATE *pThis = IFACE_TO_STATE(pInterface, IBase);
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync Assert(&pThis->IBase == pInterface);
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDPORTS, &pThis->ILeds);
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync return NULL;
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync}
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync/**
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * Gets the pointer to the status LED of a unit.
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync *
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * @returns VBox status code.
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * @param pInterface Pointer to the interface structure.
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * @param iLUN The unit which status LED we desire.
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * @param ppLed Where to store the LED pointer.
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync * @thread EMT
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync */
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsyncstatic DECLCALLBACK(int) vpciQueryStatusLed(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed)
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync{
1313e5cbe01a41e7ccb1499d2d73c455a2495955vboxsync VPCISTATE *pState = IFACE_TO_STATE(pInterface, ILeds);
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync int rc = VERR_PDM_LUN_NOT_FOUND;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (iLUN == 0)
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync {
a2410ed6c0ce63f29ac7132882e4e46d921f239dvboxsync *ppLed = &pState->led;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync rc = VINF_SUCCESS;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync }
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync return rc;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/**
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * Turns on/off the write status LED.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync *
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @returns VBox status code.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @param pState Pointer to the device state structure.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @param fOn New LED state.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync */
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsyncvoid vpciSetWriteLed(PVPCISTATE pState, bool fOn)
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync{
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync LogFlow(("%s vpciSetWriteLed: %s\n", INSTANCE(pState), fOn?"on":"off"));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (fOn)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->led.Asserted.s.fWriting = pState->led.Actual.s.fWriting = 1;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync else
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->led.Actual.s.fWriting = fOn;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/**
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * Turns on/off the read status LED.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync *
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @returns VBox status code.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @param pState Pointer to the device state structure.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync * @param fOn New LED state.
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsync */
6f045c8e519b0f50a4c2eb2906e5f5e2c4679fa8vboxsyncvoid vpciSetReadLed(PVPCISTATE pState, bool fOn)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync LogFlow(("%s vpciSetReadLed: %s\n", INSTANCE(pState), fOn?"on":"off"));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync if (fOn)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->led.Asserted.s.fReading = pState->led.Actual.s.fReading = 1;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync else
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync pState->led.Actual.s.fReading = fOn;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/**
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Sets 8-bit register in PCI configuration space.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param refPciDev The PCI device.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param uOffset The register offset.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param u16Value The value to store in the register.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @thread EMT
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync */
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsyncDECLINLINE(void) vpciCfgSetU8(PCIDEVICE& refPciDev, uint32_t uOffset, uint8_t u8Value)
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync{
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync Assert(uOffset < sizeof(refPciDev.config));
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync refPciDev.config[uOffset] = u8Value;
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync}
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync/**
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * Sets 16-bit register in PCI configuration space.
b6517c5cc3b7a38889416706905a3cf2fd010785vboxsync * @param refPciDev The PCI device.
* @param uOffset The register offset.
* @param u16Value The value to store in the register.
* @thread EMT
*/
DECLINLINE(void) vpciCfgSetU16(PCIDEVICE& refPciDev, uint32_t uOffset, uint16_t u16Value)
{
Assert(uOffset+sizeof(u16Value) <= sizeof(refPciDev.config));
*(uint16_t*)&refPciDev.config[uOffset] = u16Value;
}
/**
* Sets 32-bit register in PCI configuration space.
* @param refPciDev The PCI device.
* @param uOffset The register offset.
* @param u32Value The value to store in the register.
* @thread EMT
*/
DECLINLINE(void) vpciCfgSetU32(PCIDEVICE& refPciDev, uint32_t uOffset, uint32_t u32Value)
{
Assert(uOffset+sizeof(u32Value) <= sizeof(refPciDev.config));
*(uint32_t*)&refPciDev.config[uOffset] = u32Value;
}
#ifdef DEBUG
static void vpciDumpState(PVPCISTATE pState, const char *pcszCaller)
{
Log2(("vpciDumpState: (called from %s)\n"
" uGuestFeatures = 0x%08x\n"
" uQueueSelector = 0x%04x\n"
" uStatus = 0x%02x\n"
" uISR = 0x%02x\n",
pcszCaller,
pState->uGuestFeatures,
pState->uQueueSelector,
pState->uStatus,
pState->uISR));
for (unsigned i = 0; i < pState->nQueues; i++)
Log2((" %s queue:\n"
" VRing.uSize = %u\n"
" VRing.addrDescriptors = %p\n"
" VRing.addrAvail = %p\n"
" VRing.addrUsed = %p\n"
" uNextAvailIndex = %u\n"
" uNextUsedIndex = %u\n"
" uPageNumber = %x\n",
pState->Queues[i].pcszName,
pState->Queues[i].VRing.uSize,
pState->Queues[i].VRing.addrDescriptors,
pState->Queues[i].VRing.addrAvail,
pState->Queues[i].VRing.addrUsed,
pState->Queues[i].uNextAvailIndex,
pState->Queues[i].uNextUsedIndex,
pState->Queues[i].uPageNumber));
}
#else
# define vpciDumpState(x, s) do {} while (0)
#endif
/**
* Saves the state of device.
*
* @returns VBox status code.
* @param pDevIns The device instance.
* @param pSSM The handle to the saved state.
*/
int vpciSaveExec(PVPCISTATE pState, PSSMHANDLE pSSM)
{
int rc;
vpciDumpState(pState, "vpciSaveExec");
rc = SSMR3PutU32(pSSM, pState->uGuestFeatures);
AssertRCReturn(rc, rc);
rc = SSMR3PutU16(pSSM, pState->uQueueSelector);
AssertRCReturn(rc, rc);
rc = SSMR3PutU8( pSSM, pState->uStatus);
AssertRCReturn(rc, rc);
rc = SSMR3PutU8( pSSM, pState->uISR);
AssertRCReturn(rc, rc);
/* Save queue states */
rc = SSMR3PutU32(pSSM, pState->nQueues);
AssertRCReturn(rc, rc);
for (unsigned i = 0; i < pState->nQueues; i++)
{
rc = SSMR3PutU16(pSSM, pState->Queues[i].VRing.uSize);
AssertRCReturn(rc, rc);
rc = SSMR3PutU32(pSSM, pState->Queues[i].uPageNumber);
AssertRCReturn(rc, rc);
rc = SSMR3PutU16(pSSM, pState->Queues[i].uNextAvailIndex);
AssertRCReturn(rc, rc);
rc = SSMR3PutU16(pSSM, pState->Queues[i].uNextUsedIndex);
AssertRCReturn(rc, rc);
}
return VINF_SUCCESS;
}
/**
* Loads a saved device state.
*
* @returns VBox status code.
* @param pDevIns The device instance.
* @param pSSM The handle to the saved state.
* @param uVersion The data unit version number.
* @param uPass The data pass.
*/
int vpciLoadExec(PVPCISTATE pState, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass, uint32_t nQueues)
{
int rc;
if (uPass == SSM_PASS_FINAL)
{
/* Restore state data */
rc = SSMR3GetU32(pSSM, &pState->uGuestFeatures);
AssertRCReturn(rc, rc);
rc = SSMR3GetU16(pSSM, &pState->uQueueSelector);
AssertRCReturn(rc, rc);
rc = SSMR3GetU8( pSSM, &pState->uStatus);
AssertRCReturn(rc, rc);
rc = SSMR3GetU8( pSSM, &pState->uISR);
AssertRCReturn(rc, rc);
/* Restore queues */
if (uVersion > VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1)
{
rc = SSMR3GetU32(pSSM, &pState->nQueues);
AssertRCReturn(rc, rc);
}
else
pState->nQueues = nQueues;
for (unsigned i = 0; i < pState->nQueues; i++)
{
rc = SSMR3GetU16(pSSM, &pState->Queues[i].VRing.uSize);
AssertRCReturn(rc, rc);
rc = SSMR3GetU32(pSSM, &pState->Queues[i].uPageNumber);
AssertRCReturn(rc, rc);
if (pState->Queues[i].uPageNumber)
vqueueInit(&pState->Queues[i], pState->Queues[i].uPageNumber);
rc = SSMR3GetU16(pSSM, &pState->Queues[i].uNextAvailIndex);
AssertRCReturn(rc, rc);
rc = SSMR3GetU16(pSSM, &pState->Queues[i].uNextUsedIndex);
AssertRCReturn(rc, rc);
}
}
vpciDumpState(pState, "vpciLoadExec");
return VINF_SUCCESS;
}
/**
* Set PCI configuration space registers.
*
* @param pci Reference to PCI device structure.
* @param uSubsystemId PCI Subsystem Id
* @param uClass Class of PCI device (network, etc)
* @thread EMT
*/
static DECLCALLBACK(void) vpciConfigure(PCIDEVICE& pci,
uint16_t uSubsystemId,
uint16_t uClass)
{
/* Configure PCI Device, assume 32-bit mode ******************************/
PCIDevSetVendorId(&pci, DEVICE_PCI_VENDOR_ID);
PCIDevSetDeviceId(&pci, DEVICE_PCI_DEVICE_ID);
vpciCfgSetU16(pci, VBOX_PCI_SUBSYSTEM_VENDOR_ID, DEVICE_PCI_SUBSYSTEM_VENDOR_ID);
vpciCfgSetU16(pci, VBOX_PCI_SUBSYSTEM_ID, uSubsystemId);
/* ABI version, must be equal 0 as of 2.6.30 kernel. */
vpciCfgSetU8( pci, VBOX_PCI_REVISION_ID, 0x00);
/* Ethernet adapter */
vpciCfgSetU8( pci, VBOX_PCI_CLASS_PROG, 0x00);
vpciCfgSetU16(pci, VBOX_PCI_CLASS_DEVICE, uClass);
/* Interrupt Pin: INTA# */
vpciCfgSetU8( pci, VBOX_PCI_INTERRUPT_PIN, 0x01);
#ifdef VBOX_WITH_MSI_DEVICES
PCIDevSetCapabilityList (&pci, 0x80);
PCIDevSetStatus (&pci, VBOX_PCI_STATUS_CAP_LIST);
#endif
}
/* WARNING! This function must never be used in multithreaded context! */
static const char *vpciCounter(const char *pszDevFmt,
const char *pszCounter)
{
static char g_szCounterName[80];
RTStrPrintf(g_szCounterName, sizeof(g_szCounterName),
"/Devices/%s/%s", pszDevFmt, pszCounter);
return g_szCounterName;
}
// TODO: header
DECLCALLBACK(int) vpciConstruct(PPDMDEVINS pDevIns, VPCISTATE *pState,
int iInstance, const char *pcszNameFmt,
uint16_t uSubsystemId, uint16_t uClass,
uint32_t nQueues)
{
/* Init handles and log related stuff. */
RTStrPrintf(pState->szInstance, sizeof(pState->szInstance),
pcszNameFmt, iInstance);
pState->pDevInsR3 = pDevIns;
pState->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
pState->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
pState->led.u32Magic = PDMLED_MAGIC;
pState->ILeds.pfnQueryStatusLed = vpciQueryStatusLed;
/* Initialize critical section. */
int rc = PDMDevHlpCritSectInit(pDevIns, &pState->cs, RT_SRC_POS, "%s", pState->szInstance);
if (RT_FAILURE(rc))
return rc;
/* Set PCI config registers */
vpciConfigure(pState->pciDevice, uSubsystemId, uClass);
/* Register PCI device */
rc = PDMDevHlpPCIRegister(pDevIns, &pState->pciDevice);
if (RT_FAILURE(rc))
return rc;
#ifdef VBOX_WITH_MSI_DEVICES
#if 0
{
PDMMSIREG aMsiReg;
RT_ZERO(aMsiReg);
aMsiReg.cMsixVectors = 1;
aMsiReg.iMsixCapOffset = 0x80;
aMsiReg.iMsixNextOffset = 0x0;
aMsiReg.iMsixBar = 0;
rc = PDMDevHlpPCIRegisterMsi(pDevIns, &aMsiReg);
if (RT_FAILURE (rc))
PCIDevSetCapabilityList(&pState->pciDevice, 0x0);
}
#endif
#endif
/* Status driver */
PPDMIBASE pBase;
rc = PDMDevHlpDriverAttach(pDevIns, PDM_STATUS_LUN, &pState->IBase, &pBase, "Status Port");
if (RT_FAILURE(rc))
return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach the status LUN"));
pState->pLedsConnector = PDMIBASE_QUERY_INTERFACE(pBase, PDMILEDCONNECTORS);
pState->nQueues = nQueues;
#if defined(VBOX_WITH_STATISTICS)
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOReadGC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in GC", vpciCounter(pcszNameFmt, "IO/ReadGC"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOReadHC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO reads in HC", vpciCounter(pcszNameFmt, "IO/ReadHC"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOWriteGC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in GC", vpciCounter(pcszNameFmt, "IO/WriteGC"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIOWriteHC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling IO writes in HC", vpciCounter(pcszNameFmt, "IO/WriteHC"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIntsRaised, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of raised interrupts", vpciCounter(pcszNameFmt, "Interrupts/Raised"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatIntsSkipped, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of skipped interrupts", vpciCounter(pcszNameFmt, "Interrupts/Skipped"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatCsGC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in GC", vpciCounter(pcszNameFmt, "Cs/CsGC"), iInstance);
PDMDevHlpSTAMRegisterF(pDevIns, &pState->StatCsHC, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling CS wait in HC", vpciCounter(pcszNameFmt, "Cs/CsHC"), iInstance);
#endif /* VBOX_WITH_STATISTICS */
return rc;
}
/**
* Destruct PCI-related part of device.
*
* We need to free non-VM resources only.
*
* @returns VBox status.
* @param pState The device state structure.
*/
int vpciDestruct(VPCISTATE* pState)
{
Log(("%s Destroying PCI instance\n", INSTANCE(pState)));
if (PDMCritSectIsInitialized(&pState->cs))
PDMR3CritSectDelete(&pState->cs);
return VINF_SUCCESS;
}
/**
* Device relocation callback.
*
* When this callback is called the device instance data, and if the
* device have a GC component, is being relocated, or/and the selectors
* have been changed. The device must use the chance to perform the
* necessary pointer relocations and data updates.
*
* Before the GC code is executed the first time, this function will be
* called with a 0 delta so GC pointer calculations can be one in one place.
*
* @param pDevIns Pointer to the device instance.
* @param offDelta The relocation delta relative to the old location.
*
* @remark A relocation CANNOT fail.
*/
void vpciRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
{
VPCISTATE* pState = PDMINS_2_DATA(pDevIns, VPCISTATE*);
pState->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
// TBD
}
PVQUEUE vpciAddQueue(VPCISTATE* pState, unsigned uSize,
void (*pfnCallback)(void *pvState, PVQUEUE pQueue),
const char *pcszName)
{
PVQUEUE pQueue = NULL;
/* Find an empty queue slot */
for (unsigned i = 0; i < pState->nQueues; i++)
{
if (pState->Queues[i].VRing.uSize == 0)
{
pQueue = &pState->Queues[i];
break;
}
}
if (!pQueue)
{
Log(("%s Too many queues being added, no empty slots available!\n", INSTANCE(pState)));
}
else
{
pQueue->VRing.uSize = uSize;
pQueue->VRing.addrDescriptors = 0;
pQueue->uPageNumber = 0;
pQueue->pfnCallback = pfnCallback;
pQueue->pcszName = pcszName;
}
return pQueue;
}
#endif /* IN_RING3 */
#endif /* VBOX_DEVICE_STRUCT_TESTCASE */