2 * Acess2 VirtIO Network Driver
3 * - By John Hodge (thePowersGang)
9 #define VERSION VER2(1,0)
12 #include <semaphore.h>
14 #include <IPStack/include/adapters_api.h>
15 #include "virtio-net.h"
16 #include <Libraries/VirtIO/include/virtio.h>
21 typedef struct sVirtIONet_Dev tVirtIONet_Dev;
27 tSemaphore RXPacketSem;
28 void *RXBuffers[NRXBUFS];
32 int VirtIONet_Install(char **Arguments);
33 int VirtIONet_Cleanup(void);
34 void VirtIONet_AddCard(Uint16 IOBase, Uint IRQ);
35 int VirtIONet_RXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle);
36 tIPStackBuffer *VirtIONet_WaitForPacket(void *Ptr);
37 int VirtIONet_TXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle);
38 int VirtIONet_SendPacket(void *Ptr, tIPStackBuffer *Buffer);
41 MODULE_DEFINE(0, VERSION, VirtIONet, VirtIONet_Install, VirtIONet_Cleanup, "IPStack", "VirtIOCommon", NULL);
42 tIPStack_AdapterType gVirtIONet_AdapterType = {
44 .Type = ADAPTERTYPE_ETHERNET_1G, // TODO: Differentiate differnet wire protos and speeds
45 .Flags = ADAPTERFLAG_OFFLOAD_MAC, // TODO: IP/TCP/UDP checksum offloading
46 .SendPacket = VirtIONet_SendPacket,
47 .WaitForPacket = VirtIONet_WaitForPacket
51 int VirtIONet_Install(char **Arguments)
54 // Find network devices
55 while( (pcidev = PCI_GetDeviceByClass(0x020000, 0xFF0000, pcidev)) != -1 )
58 PCI_GetDeviceInfo(pcidev, &ven, &dev, NULL);
59 LOG("Device %i: %x/%x", pcidev, ven, dev);
60 // 0x1AF4:(0x1000-0x103F) are VirtIO devices
61 if( ven != 0x1AF4 || (dev & 0xFFC0) != 0x1000 )
64 PCI_GetDeviceSubsys(pcidev, &ven, &subsys_id);
65 if( subsys_id != 1 ) {
66 Log_Notice("VirtIONet", "Device with network PCI class but not subsys (%i!=1)", subsys_id);
70 Uint8 irq = PCI_GetIRQ(pcidev);
71 // TODO: Detect bad IRQ
73 Uint32 iobase = PCI_GetBAR(pcidev, 0);
78 VirtIONet_AddCard(iobase & ~1, irq);
83 int VirtIONet_Cleanup(void)
85 Log_Warning("VirtIONet", "TODO: Clean up before module unload");
89 void VirtIONet_AddCard(Uint16 IOBase, Uint IRQ)
91 ENTER("xMMIOBase xIRQ", IOBase, IRQ);
92 // Should be a VirtIO Network device
93 tVirtIO_Dev *dev = VirtIO_InitDev(
95 VIRTIO_NET_F_MAC|VIRTIO_NET_F_STATUS|VIRTIO_NET_F_CSUM|VIRTIO_NET_F_MRG_RXBUF
96 |VIRTIO_F_NOTIFY_ON_EMPTY,
98 sizeof(struct sVirtIONet_Dev)
103 tVirtIONet_Dev *ndev = VirtIO_GetDataPtr(dev);
104 Semaphore_Init(&ndev->RXPacketSem, 0, NRXBUFS, "VirtIONet", "RXSem");
105 ndev->Features = VirtIO_GetFeatures(dev);
108 if( ndev->Features & VIRTIO_NET_F_MAC ) {
109 for( int i = 0; i < 6; i ++ )
110 mac[i] = VirtIO_GetDevConfig(dev, 8, i);
111 Log_Log("VirtIONet", "Card %x,%i - MAC %02x:%02x:%02x:%02x:%02x:%02x",
113 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
116 // x[2,6,A,E] xx xx xx xx xx
120 mac[3] = rand() & 0xFF;
121 mac[4] = rand() & 0xFF;
122 mac[5] = rand() & 0xFF;
123 Log_Log("VirtIONet", "Card %x,%i - Random MAC %02x:%02x:%02x:%02x:%02x:%02x",
125 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
128 // NoAutoRel=1 : Keep RX buffers about until worker is done with them
129 VirtIO_SetQueueCallback(dev, 0, VirtIONet_RXQueueCallback, 1);
130 VirtIO_SetQueueCallback(dev, 1, VirtIONet_TXQueueCallback, 0);
133 for( int i = 0; i < NRXBUFS; i ++ )
135 ndev->RXBuffers[i] = MM_AllocDMA(1, -1, NULL);
136 LOG("RxBuf %i/%i: %p", i, NRXBUFS, ndev->RXBuffers[i]);
137 VirtIO_ReceiveBuffer(dev, 0, PAGE_SIZE, ndev->RXBuffers[i], NULL);
140 // Register with IPStack
142 // TODO: Save the returned pointer to do deregister later
143 IPStack_Adapter_Add(&gVirtIONet_AdapterType, dev, mac);
147 int VirtIONet_RXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
149 tVirtIONet_Dev *NDev = VirtIO_GetDataPtr(Dev);
151 Semaphore_Signal(&NDev->RXPacketSem, 1);
152 // 1: Don't pop the qdesc
156 void VirtIONet_ReleaseRX(void *Arg, size_t HeadLen, size_t FootLen, const void *Data)
158 tVirtIO_Buf *buf = Arg;
159 tVirtIO_Dev *dev = VirtIO_GetBufferDev(buf);
161 VirtIO_ReleaseBuffer(buf);
162 void *bufptr = (void*)((tVAddr)Data & ~(PAGE_SIZE-1));
163 VirtIO_ReceiveBuffer(dev, 0, PAGE_SIZE, bufptr, NULL);
166 tIPStackBuffer *VirtIONet_WaitForPacket(void *Ptr)
168 tVirtIO_Dev *VIODev = Ptr;
169 tVirtIONet_Dev *NDev = VirtIO_GetDataPtr(VIODev);
171 if( Semaphore_Wait(&NDev->RXPacketSem, 1) != 1 ) {
177 tVirtIO_Buf *id = VirtIO_PopBuffer(VIODev, VIRTIONET_QUEUE_RX, &size, &buf);
180 // Pop failed, nothing there (possibly not error condition)
184 const tVirtIONet_PktHdr *hdr = buf;
185 int nbufs = (NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? hdr->NumBuffers : 1;
186 size_t dataofs = (NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? sizeof(*hdr) : sizeof(*hdr)-2;
188 ASSERTCR(nbufs, >=, 1, NULL);
189 ASSERTCR(size, >, dataofs, NULL);
191 tIPStackBuffer *ret = IPStack_Buffer_CreateBuffer(nbufs);
192 IPStack_Buffer_AppendSubBuffer(ret, 0, size-dataofs, (const char*)buf + dataofs, VirtIONet_ReleaseRX, id);
194 // TODO: This will break if descriptors end up being chained
196 for( int i = 1; i < nbufs; i ++ )
198 while( NULL == (id = VirtIO_PopBuffer(VIODev, VIRTIONET_QUEUE_RX, &size, &buf)) )
199 Semaphore_Wait(&NDev->RXPacketSem, 1);
200 IPStack_Buffer_AppendSubBuffer(ret, 0, size, buf, VirtIONet_ReleaseRX, id);
205 int VirtIONet_TXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
208 LOG("Unlock TX'd buffer %p", Handle);
209 IPStack_Buffer_UnlockBuffer(Handle);
214 int VirtIONet_SendPacket(void *Ptr, tIPStackBuffer *Buffer)
216 tVirtIO_Dev *VIODev = Ptr;
217 tVirtIONet_Dev *NDev = VirtIO_GetDataPtr(VIODev);
220 for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, NULL, NULL)) != -1; )
223 tVirtIONet_PktHdr hdr;
226 // GSO (TODO: Acess needs to support this)
230 // IP/TCP checksumming?
236 size_t buflens[1+nBufs];
237 const void *bufptrs[1+nBufs];
238 buflens[0] = sizeof(hdr) - ((NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? 0 : 2);
241 for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, &buflens[i], &bufptrs[i])) != -1; )
244 IPStack_Buffer_LockBuffer(Buffer);
245 VirtIO_SendBuffers(VIODev, VIRTIONET_QUEUE_TX, nBufs+1, buflens, bufptrs, Buffer);
247 // Wait until TX completes
248 IPStack_Buffer_LockBuffer(Buffer);
249 IPStack_Buffer_UnlockBuffer(Buffer);