KernelLand/Modules/Network/VirtIONet/virtio-net.c

   1 /*
   2  * Acess2 VirtIO Network Driver
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * virtio-net.c
   6  * - Driver Core
   7  */
   8 #define DEBUG   0
   9 #define VERSION VER2(1,0)
  10 #include <acess.h>
  11 #include <modules.h>
  12 #include <semaphore.h>
  13 #include <drv_pci.h>
  14 #include <IPStack/include/adapters_api.h>
  15 #include "virtio-net.h"
  16 #include <Libraries/VirtIO/include/virtio.h>
  17
  18 #define NRXBUFS 4
  19
  20 // === TYPEDEFS ===
  21 typedef struct sVirtIONet_Dev   tVirtIONet_Dev;
  22
  23 // === STRUCTURES ===
  24 struct sVirtIONet_Dev
  25 {
  26         Uint32  Features;
  27         tSemaphore      RXPacketSem;
  28         void    *RXBuffers[NRXBUFS];
  29 };
  30
  31 // === PROTOTYPES ===
  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);
  39
  40 // === GLOBALS ===
  41 MODULE_DEFINE(0, VERSION, VirtIONet, VirtIONet_Install, VirtIONet_Cleanup, "IPStack", "VirtIOCommon", NULL);
  42 tIPStack_AdapterType    gVirtIONet_AdapterType = {
  43         .Name = "VirtIONet",
  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
  48 };
  49
  50 // === CODE ===
  51 int VirtIONet_Install(char **Arguments)
  52 {
  53          int    pcidev = -1;
  54         // Find network devices
  55         while( (pcidev = PCI_GetDeviceByClass(0x020000, 0xFF0000, pcidev)) != -1 )
  56         {
  57                 Uint16  ven, dev;
  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 )
  62                         continue ;
  63                 Uint16  subsys_id;
  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);
  67                         continue ;
  68                 }
  69
  70                 Uint8   irq = PCI_GetIRQ(pcidev);
  71                 // TODO: Detect bad IRQ
  72
  73                 Uint32  iobase = PCI_GetBAR(pcidev, 0);
  74                 if( iobase == 0 ) {
  75                         // oops
  76                 }
  77
  78                 VirtIONet_AddCard(iobase & ~1, irq);
  79         }
  80         return 0;
  81 }
  82
  83 int VirtIONet_Cleanup(void)
  84 {
  85         Log_Warning("VirtIONet", "TODO: Clean up before module unload");
  86         return 0;
  87 }
  88
  89 void VirtIONet_AddCard(Uint16 IOBase, Uint IRQ)
  90 {
  91         ENTER("xMMIOBase xIRQ", IOBase, IRQ);
  92         // Should be a VirtIO Network device
  93         tVirtIO_Dev *dev = VirtIO_InitDev(
  94                 IOBase, IRQ,
  95                 VIRTIO_NET_F_MAC|VIRTIO_NET_F_STATUS|VIRTIO_NET_F_CSUM|VIRTIO_NET_F_MRG_RXBUF
  96                         |VIRTIO_F_NOTIFY_ON_EMPTY,
  97                 3,
  98                 sizeof(struct sVirtIONet_Dev)
  99                 );
 100         if( !dev ) {
 101                 // Oops?
 102         }
 103         tVirtIONet_Dev  *ndev = VirtIO_GetDataPtr(dev);
 104         Semaphore_Init(&ndev->RXPacketSem, 0, NRXBUFS, "VirtIONet", "RXSem");
 105         ndev->Features = VirtIO_GetFeatures(dev);
 106
 107         Uint8   mac[6];
 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",
 112                         IOBase, IRQ,
 113                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 114         }
 115         else {
 116                 // x[2,6,A,E] xx xx xx xx xx
 117                 mac[0] = 0x0A;
 118                 mac[1] = 0xCE;
 119                 mac[2] = 0x55;
 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",
 124                         IOBase, IRQ,
 125                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 126         }
 127
 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);
 131
 132         // Set up RX buffers
 133         for( int i = 0; i < NRXBUFS; i ++ )
 134         {
 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);
 138         }
 139
 140         // Register with IPStack
 141         LOG("Register");
 142         // TODO: Save the returned pointer to do deregister later
 143         IPStack_Adapter_Add(&gVirtIONet_AdapterType, dev, mac);
 144         LEAVE('-');
 145 }
 146
 147 int VirtIONet_RXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
 148 {
 149         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(Dev);
 150         LOG("Signalling");
 151         Semaphore_Signal(&NDev->RXPacketSem, 1);
 152         // 1: Don't pop the qdesc
 153         return 1;
 154 }
 155
 156 void VirtIONet_ReleaseRX(void *Arg, size_t HeadLen, size_t FootLen, const void *Data)
 157 {
 158         tVirtIO_Buf     *buf = Arg;
 159         tVirtIO_Dev     *dev = VirtIO_GetBufferDev(buf);
 160         // Re-add RX buffer
 161         VirtIO_ReleaseBuffer(buf);
 162         void    *bufptr = (void*)((tVAddr)Data & ~(PAGE_SIZE-1));
 163         VirtIO_ReceiveBuffer(dev, 0, PAGE_SIZE, bufptr, NULL);
 164 }
 165
 166 tIPStackBuffer *VirtIONet_WaitForPacket(void *Ptr)
 167 {
 168         tVirtIO_Dev     *VIODev = Ptr;
 169         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(VIODev);
 170
 171         if( Semaphore_Wait(&NDev->RXPacketSem, 1) != 1 ) {
 172                 return NULL;
 173         }
 174
 175         size_t  size;
 176         const void      *buf;
 177         tVirtIO_Buf     *id = VirtIO_PopBuffer(VIODev, VIRTIONET_QUEUE_RX, &size, &buf);
 178         if( id == NULL )
 179         {
 180                 // Pop failed, nothing there (possibly not error condition)
 181                 return NULL;
 182         }
 183
 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;
 187
 188         ASSERTCR(nbufs, >=, 1, NULL);
 189         ASSERTCR(size, >, dataofs, NULL);
 190
 191         tIPStackBuffer  *ret = IPStack_Buffer_CreateBuffer(nbufs);
 192         IPStack_Buffer_AppendSubBuffer(ret, 0, size-dataofs, (const char*)buf + dataofs, VirtIONet_ReleaseRX, id);
 193
 194         // TODO: This will break if descriptors end up being chained
 195
 196         for( int i = 1; i < nbufs; i ++ )
 197         {
 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);
 201         }
 202         return ret;
 203 }
 204
 205 int VirtIONet_TXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
 206 {
 207         if( Handle ) {
 208                 LOG("Unlock TX'd buffer %p", Handle);
 209                 IPStack_Buffer_UnlockBuffer(Handle);
 210         }
 211         return 0;
 212 }
 213
 214 int VirtIONet_SendPacket(void *Ptr, tIPStackBuffer *Buffer)
 215 {
 216         tVirtIO_Dev     *VIODev = Ptr;
 217         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(VIODev);
 218
 219          int    nBufs = 0;
 220         for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, NULL, NULL)) != -1; )
 221                 nBufs ++;
 222
 223         tVirtIONet_PktHdr       hdr;
 224
 225         hdr.Flags = 0;
 226         // GSO (TODO: Acess needs to support this)
 227         hdr.GSOType = 0;
 228         hdr.HeaderLen = 0;
 229         hdr.GSOSize = 0;
 230         // IP/TCP checksumming?
 231         hdr.CSumStart = 0;
 232         hdr.CSumOffset = 0;
 233
 234         hdr.NumBuffers = 0;
 235
 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);
 239         bufptrs[0] = &hdr;
 240          int    i = 1;
 241         for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, &buflens[i], &bufptrs[i])) != -1; )
 242                 i ++;
 243
 244         IPStack_Buffer_LockBuffer(Buffer);
 245         VirtIO_SendBuffers(VIODev, VIRTIONET_QUEUE_TX, nBufs+1, buflens, bufptrs, Buffer);
 246
 247         // Wait until TX completes
 248         IPStack_Buffer_LockBuffer(Buffer);
 249         IPStack_Buffer_UnlockBuffer(Buffer);
 250
 251         return 0;
 252 }
 253