KernelLand/Modules/Network/VIARhineII/rhine2.c

   1 /*
   2  * Acess2 VIA Rhine II Driver (VT6102)
   3  * - By John Hodge (thePowersGang)
   4  */
   5 #define DEBUG   0
   6 #define VERSION ((0<<8)|10)
   7 #include <acess.h>
   8 #include <modules.h>
   9 #include <drv_pci.h>
  10 #include <semaphore.h>
  11 #include "rhine2_hw.h"
  12 #include <IPStack/include/adapters_api.h>
  13
  14 // === CONSTANTS ===
  15 #define VENDOR_ID       0x1106
  16 #define DEVICE_ID       0x3065
  17
  18 // === TYPES ===
  19 typedef struct sCard
  20 {
  21         Uint16  IOBase;
  22         Uint8   IRQ;
  23
  24         tSemaphore      ReadSemaphore;
  25
  26         Uint32  RXBuffersPhys;
  27         void    *RXBuffers;
  28
  29         Uint32  DescTablePhys;
  30         void    *DescTable;
  31
  32         struct sTXDesc  *FirstTX;
  33         struct sTXDesc  *LastTX;        // Most recent unsent packet
  34
  35         struct sRXDesc  *FirstRX;       // Most recent unread packet
  36         struct sRXDesc  *LastRX;        // End of RX descriptor queue
  37
  38         void    *IPHandle;
  39         Uint8   MacAddr[6];
  40 }       tCard;
  41
  42 // === PROTOTYPES ===
  43  int    Rhine2_Install(char **Options);
  44 tIPStackBuffer  *Rhine2_WaitPacket(void *Ptr);
  45  int    Rhine2_SendPacket(void *Ptr, tIPStackBuffer *Buffer);
  46 void    Rhine2_IRQHandler(int Num);
  47 // --- Helpers ---
  48 struct sRXDesc  *Rhine2_int_GetDescFromPhys(tCard *Card, Uint32 Addr);
  49 void    *Rhine2_int_GetBufferFromPhys(tCard *Card, Uint32 Addr);
  50 void    Rhine2_int_FreeRXDesc(void *Desc, size_t, size_t, const void*);
  51 struct sTXDesc  *Rhine2_int_AllocTXDesc(tCard *Card);
  52 // --- IO ---
  53 void    _WriteDWord(tCard *Card, int Offset, Uint32 Value);
  54
  55 // === GLOBALS ===
  56 MODULE_DEFINE(0, VERSION, VIARhineII, Rhine2_Install, NULL, NULL);
  57 tIPStack_AdapterType    gRhine2_AdapterType = {
  58         .Name = "VIA Rhine II",
  59         .SendPacket = Rhine2_SendPacket,
  60         .WaitForPacket = Rhine2_WaitPacket,
  61 };
  62  int    giRhine2_CardCount;
  63 tCard   *gaRhine2_Cards;
  64
  65 // === CODE ===
  66 /**
  67  * \brief Initialises the driver
  68  */
  69 int Rhine2_Install(char **Options)
  70 {
  71          int    id = -1;
  72          int    i = 0;
  73 //      Uint16  base;
  74         tCard   *card;
  75
  76         giRhine2_CardCount = PCI_CountDevices(VENDOR_ID, DEVICE_ID);
  77         Log_Debug("Rhine2", "%i cards", giRhine2_CardCount);
  78
  79         if( giRhine2_CardCount == 0 )   return MODULE_ERR_NOTNEEDED;
  80
  81         gaRhine2_Cards = calloc( giRhine2_CardCount, sizeof(tCard) );
  82
  83         while( (id = PCI_GetDevice(VENDOR_ID, DEVICE_ID, i)) != -1 )
  84         {
  85                 card = &gaRhine2_Cards[i];
  86
  87                 LOG("BAR0 = 0x%08x", PCI_GetBAR(id, 0));
  88                 LOG("BAR1 = 0x%08x", PCI_GetBAR(id, 1));
  89                 LOG("BAR2 = 0x%08x", PCI_GetBAR(id, 2));
  90                 LOG("BAR3 = 0x%08x", PCI_GetBAR(id, 3));
  91                 LOG("BAR4 = 0x%08x", PCI_GetBAR(id, 4));
  92                 LOG("BAR5 = 0x%08x", PCI_GetBAR(id, 5));
  93
  94 //              card->IOBase = base;
  95                 card->IRQ = PCI_GetIRQ( id );
  96
  97                 // Install IRQ Handler
  98 //              IRQ_AddHandler(card->IRQ, Rhine2_IRQHandler);
  99
 100
 101
 102 //              Log_Log("PCnet3", "Card %i 0x%04x, IRQ %i %02x:%02x:%02x:%02x:%02x:%02x",
 103 //                      i, card->IOBase, card->IRQ,
 104 //                      card->MacAddr[0], card->MacAddr[1], card->MacAddr[2],
 105 //                      card->MacAddr[3], card->MacAddr[4], card->MacAddr[5]
 106 //                      );
 107
 108                 i ++;
 109         }
 110
 111         return MODULE_ERR_OK;
 112 }
 113
 114 // --- File Functions ---
 115 tIPStackBuffer *Rhine2_WaitPacket(void *Ptr)
 116 {
 117         tCard   *card = Ptr;
 118         tIPStackBuffer  *ret;
 119         struct sRXDesc  *desc;
 120          int    nDesc;
 121
 122         ENTER("pPtr", Ptr);
 123
 124         if( Semaphore_Wait( &card->ReadSemaphore, 1 ) != 1 )
 125         {
 126                 LEAVE('n');
 127                 return NULL;
 128         }
 129
 130         nDesc = 0;
 131         desc = card->FirstRX;
 132         while( desc->BufferSize & (1 << 15) )
 133         {
 134                 desc = Rhine2_int_GetDescFromPhys(card, desc->RDBranchAddress);
 135                 nDesc ++;
 136         }
 137
 138         LOG("%i descriptors in packet", nDesc);
 139
 140         ret = IPStack_Buffer_CreateBuffer(nDesc);
 141         desc = card->FirstRX;
 142         while( desc->BufferSize & (1 << 15) )
 143         {
 144                 void    *data = Rhine2_int_GetBufferFromPhys(card, desc->RXBufferStart);
 145                 IPStack_Buffer_AppendSubBuffer(ret,
 146                         desc->Length, 0, data,
 147                         Rhine2_int_FreeRXDesc, desc
 148                         );
 149                 desc = Rhine2_int_GetDescFromPhys(card, desc->RDBranchAddress);
 150         }
 151         card->FirstRX = desc;
 152
 153         LEAVE('p', ret);
 154         return ret;
 155 }
 156
 157 int Rhine2_SendPacket(void *Ptr, tIPStackBuffer *Buffer)
 158 {
 159         tCard   *card = Ptr;
 160         size_t  len;
 161         const void      *data;
 162         struct sTXDesc  *first_desc = NULL;
 163         struct sTXDesc  *last_desc = NULL;
 164
 165         ENTER("pPtr pBuffer", Ptr, Buffer);
 166
 167         // Iterate buffers
 168         for( int id = -1; -1 != (id = IPStack_Buffer_GetBuffer(Buffer, id, &len, &data)); )
 169         {
 170                 tPAddr  pdata = MM_GetPhysAddr( (tVAddr)data );
 171                 struct sTXDesc  *desc;
 172                 #if PHYS_BITS > 32
 173                 if( pdata >> 32 ) {
 174                         // TODO: re-map
 175                 }
 176                 #endif
 177
 178                 desc = Rhine2_int_AllocTXDesc(card);
 179                 if(!last_desc)
 180                         first_desc = desc;
 181                 else
 182                         last_desc->TDBranchAddress = MM_GetPhysAddr( (tVAddr)desc );
 183
 184                 desc->TXBufferStart = pdata;
 185                 desc->BufferSize = len;
 186                 // TODO: TCR
 187                 desc->TCR = 0;
 188                 desc->TDBranchAddress = 0;
 189
 190                 last_desc = desc;
 191         }
 192
 193         if( !first_desc ) {
 194                 LEAVE('i', -1);
 195                 return -1;
 196         }
 197
 198         first_desc->TCR |= TD_TCR_STP;
 199         last_desc->TCR |= TD_TCR_EDP;
 200
 201         if( card->LastTX )
 202                 card->LastTX->TDBranchAddress = MM_GetPhysAddr( (tVAddr)first_desc );
 203         else {
 204                 card->FirstTX = first_desc;
 205                 card->LastTX = first_desc;
 206                 _WriteDWord(card, REG_CUR_TX_DESC, MM_GetPhysAddr( (tVAddr)first_desc ));
 207         }
 208
 209         // TODO: Wait until the packet has sent, then clean up
 210
 211         return 0;
 212 }
 213
 214 void Rhine2_IRQHandler(int Num)
 215 {
 216
 217 }
 218
 219 // --- Helpers ---
 220 struct sRXDesc *Rhine2_int_GetDescFromPhys(tCard *Card, Uint32 Addr)
 221 {
 222         return NULL;
 223 }
 224
 225 void *Rhine2_int_GetBufferFromPhys(tCard *Card, Uint32 Addr)
 226 {
 227         return NULL;
 228 }
 229
 230 void Rhine2_int_FreeRXDesc(void *Desc, size_t u1, size_t u2, const void *u3)
 231 {
 232
 233 }
 234
 235 struct sTXDesc *Rhine2_int_AllocTXDesc(tCard *Card)
 236 {
 237         return NULL;
 238 }
 239
 240 // --- IO ---
 241 void _WriteDWord(tCard *Card, int Offset, Uint32 Value)
 242 {
 243
 244 }