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   1
   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, 1, "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                 VirtIO_ReceiveBuffer(dev, 0, PAGE_SIZE, ndev->RXBuffers[i], NULL);
 137         }
 138
 139         // Register with IPStack
 140         // TODO: Save the returned pointer to do deregister later
 141         IPStack_Adapter_Add(&gVirtIONet_AdapterType, dev, mac);
 142         LEAVE('-');
 143 }
 144
 145 int VirtIONet_RXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
 146 {
 147         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(Dev);
 148         Semaphore_Signal(&NDev->RXPacketSem, 1);
 149         // 1: Don't pop the qdesc
 150         return 1;
 151 }
 152
 153 void VirtIONet_ReleaseRX(void *Arg, size_t HeadLen, size_t FootLen, const void *Data)
 154 {
 155         tVirtIO_Buf     *buf = Arg;
 156         tVirtIO_Dev     *dev = VirtIO_GetBufferDev(buf);
 157         // Re-add RX buffer
 158         VirtIO_ReleaseBuffer(buf);
 159         void    *bufptr = (void*)((tVAddr)Data & ~(PAGE_SIZE-1));
 160         VirtIO_ReceiveBuffer(dev, 0, PAGE_SIZE, bufptr, NULL);
 161 }
 162
 163 tIPStackBuffer *VirtIONet_WaitForPacket(void *Ptr)
 164 {
 165         tVirtIO_Dev     *VIODev = Ptr;
 166         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(VIODev);
 167
 168         if( Semaphore_Wait(&NDev->RXPacketSem, 1) != 1 ) {
 169                 return NULL;
 170         }
 171
 172         size_t  size;
 173         const void      *buf;
 174         tVirtIO_Buf     *id = VirtIO_PopBuffer(VIODev, VIRTIONET_QUEUE_RX, &size, &buf);
 175         if( id == NULL )
 176         {
 177                 // Pop failed, nothing there (possibly not error condition)
 178                 return NULL;
 179         }
 180
 181         const tVirtIONet_PktHdr *hdr = buf;
 182          int    nbufs = (NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? hdr->NumBuffers : 1;
 183         size_t  dataofs = (NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? sizeof(*hdr) : sizeof(*hdr)-2;
 184
 185         ASSERTCR(nbufs, >=, 1, NULL);
 186         ASSERTCR(size, >, dataofs, NULL);
 187
 188         tIPStackBuffer  *ret = IPStack_Buffer_CreateBuffer(nbufs);
 189         IPStack_Buffer_AppendSubBuffer(ret, 0, size-dataofs, (const char*)buf + dataofs, VirtIONet_ReleaseRX, id);
 190
 191         // TODO: This will break if descriptors end up being chained
 192
 193         for( int i = 1; i < nbufs; i ++ )
 194         {
 195                 while( NULL == (id = VirtIO_PopBuffer(VIODev, VIRTIONET_QUEUE_RX, &size, &buf)) )
 196                         Semaphore_Wait(&NDev->RXPacketSem, 1);
 197                 IPStack_Buffer_AppendSubBuffer(ret, 0, size, buf, VirtIONet_ReleaseRX, id);
 198         }
 199         return ret;
 200 }
 201
 202 int VirtIONet_TXQueueCallback(tVirtIO_Dev *Dev, int ID, size_t UsedBytes, void *Handle)
 203 {
 204         if( Handle ) {
 205                 LOG("Unlock TX'd buffer %p", Handle);
 206                 IPStack_Buffer_UnlockBuffer(Handle);
 207         }
 208         return 0;
 209 }
 210
 211 int VirtIONet_SendPacket(void *Ptr, tIPStackBuffer *Buffer)
 212 {
 213         tVirtIO_Dev     *VIODev = Ptr;
 214         tVirtIONet_Dev  *NDev = VirtIO_GetDataPtr(VIODev);
 215
 216          int    nBufs = 0;
 217         for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, NULL, NULL)) != -1; )
 218                 nBufs ++;
 219
 220         tVirtIONet_PktHdr       hdr;
 221
 222         hdr.Flags = 0;
 223         // GSO (TODO: Acess needs to support this)
 224         hdr.GSOType = 0;
 225         hdr.HeaderLen = 0;
 226         hdr.GSOSize = 0;
 227         // IP/TCP checksumming?
 228         hdr.CSumStart = 0;
 229         hdr.CSumOffset = 0;
 230
 231         hdr.NumBuffers = 0;
 232
 233         size_t  buflens[1+nBufs];
 234         const void      *bufptrs[1+nBufs];
 235         buflens[0] = sizeof(hdr) - ((NDev->Features & VIRTIO_NET_F_MRG_RXBUF) ? 0 : 2);
 236         bufptrs[0] = &hdr;
 237          int    i = 1;
 238         for( int idx = -1; (idx = IPStack_Buffer_GetBuffer(Buffer, idx, &buflens[i], &bufptrs[i])) != -1; )
 239                 i ++;
 240
 241         IPStack_Buffer_LockBuffer(Buffer);
 242         VirtIO_SendBuffers(VIODev, VIRTIONET_QUEUE_TX, nBufs+1, buflens, bufptrs, Buffer);
 243
 244         // Wait until TX completes
 245         IPStack_Buffer_LockBuffer(Buffer);
 246         IPStack_Buffer_UnlockBuffer(Buffer);
 247
 248         return 0;
 249 }
 250