KernelLand/Modules/Network/VIARhineII/rhine2.c

   1 /*
   2  * Acess2 VIA Rhine II Driver (VT6102)
   3  * - By John Hodge (thePowersGang)
   4  */
   5 #define DEBUG   1
   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 #define DESC_SIZE       16
  15 #define N_RX_DESCS      16
  16 #define RX_BUF_SIZE     1024
  17 #define N_RX_BUF_PER_PAGE       (PAGE_SIZE/RX_BUF_SIZE)
  18 #define N_RX_BUF_PAGES  ((N_RX_DESCS*RX_BUF_SIZE)/PAGE_SIZE)
  19 #define N_TX_DESCS      ((PAGE_SIZE/DESC_SIZE)-N_RX_DESCS)
  20
  21 #define CR0_BASEVAL     (CR0_STRT|CR0_TXON|CR0_RXON)
  22
  23 // === CONSTANTS ===
  24 #define VENDOR_ID       0x1106
  25 #define DEVICE_ID       0x3065
  26
  27 // === TYPES ===
  28 typedef struct sCard
  29 {
  30         Uint16  IOBase;
  31         Uint8   IRQ;
  32
  33         tSemaphore      ReadSemaphore;
  34         tSemaphore      SendSemaphore;
  35
  36         struct {
  37                 Uint32  Phys;
  38                 void    *Virt;
  39         } RXBuffers[N_RX_BUF_PAGES];
  40
  41         Uint32  DescTablePhys;
  42         void    *DescTable;
  43
  44         struct sTXDesc  *TXDescs;
  45          int    NextTX;
  46          int    nFreeTX;
  47
  48         struct sRXDesc  *NextRX;        // Most recent unread packet
  49
  50         void    *IPHandle;
  51         Uint8   MacAddr[6];
  52 }       tCard;
  53
  54 // === PROTOTYPES ===
  55  int    Rhine2_Install(char **Options);
  56 void    Rhine2_int_InitialiseCard(tCard *Card);
  57 tIPStackBuffer  *Rhine2_WaitPacket(void *Ptr);
  58  int    Rhine2_SendPacket(void *Ptr, tIPStackBuffer *Buffer);
  59 void    Rhine2_IRQHandler(int Num, void *Pt);
  60 // --- Helpers ---
  61 struct sRXDesc  *Rhine2_int_GetDescFromPhys(tCard *Card, Uint32 Addr);
  62 void    *Rhine2_int_GetBufferFromPhys(tCard *Card, Uint32 Addr);
  63 void    Rhine2_int_FreeRXDesc(void *Desc, size_t, size_t, const void*);
  64
  65 // === GLOBALS ===
  66 MODULE_DEFINE(0, VERSION, VIARhineII, Rhine2_Install, NULL, NULL);
  67 tIPStack_AdapterType    gRhine2_AdapterType = {
  68         .Name = "VIA Rhine II",
  69         .SendPacket = Rhine2_SendPacket,
  70         .WaitForPacket = Rhine2_WaitPacket,
  71 };
  72  int    giRhine2_CardCount;
  73 tCard   *gaRhine2_Cards;
  74
  75 // === CODE ===
  76 /**
  77  * \brief Initialises the driver
  78  */
  79 int Rhine2_Install(char **Options)
  80 {
  81          int    id = -1;
  82          int    i = 0;
  83 //      Uint16  base;
  84         tCard   *card;
  85
  86         giRhine2_CardCount = PCI_CountDevices(VENDOR_ID, DEVICE_ID);
  87         Log_Debug("Rhine2", "giRhine2_CardCount = %i", giRhine2_CardCount);
  88         if( giRhine2_CardCount == 0 )   return MODULE_ERR_NOTNEEDED;
  89
  90         gaRhine2_Cards = calloc( giRhine2_CardCount, sizeof(tCard) );
  91
  92         while( (id = PCI_GetDevice(VENDOR_ID, DEVICE_ID, i)) != -1 )
  93         {
  94                 card = &gaRhine2_Cards[i];
  95
  96                 LOG("BAR0 = 0x%08x", PCI_GetBAR(id, 0));
  97                 LOG("BAR1 = 0x%08x", PCI_GetBAR(id, 1));
  98                 LOG("BAR2 = 0x%08x", PCI_GetBAR(id, 2));
  99                 LOG("BAR3 = 0x%08x", PCI_GetBAR(id, 3));
 100                 LOG("BAR4 = 0x%08x", PCI_GetBAR(id, 4));
 101                 LOG("BAR5 = 0x%08x", PCI_GetBAR(id, 5));
 102
 103                 card->IOBase = PCI_GetBAR(id, 0);
 104                 if( !(card->IOBase & 1) ) {
 105                         // Oops?
 106                         Log_Warning("Rhine2", "BAR0 is not in IO space");
 107                         continue ;
 108                 }
 109                 card->IOBase &= ~1;
 110                 card->IRQ = PCI_GetIRQ( id );
 111
 112                 // Install IRQ Handler
 113                 IRQ_AddHandler(card->IRQ, Rhine2_IRQHandler, card);
 114
 115                 Rhine2_int_InitialiseCard(card);
 116
 117                 card->IPHandle = IPStack_Adapter_Add(&gRhine2_AdapterType, card, card->MacAddr);
 118
 119                 Log_Log("Rhine2", "Card %i 0x%04x, IRQ %i %02x:%02x:%02x:%02x:%02x:%02x",
 120                         i, card->IOBase, card->IRQ,
 121                         card->MacAddr[0], card->MacAddr[1], card->MacAddr[2],
 122                         card->MacAddr[3], card->MacAddr[4], card->MacAddr[5]
 123                         );
 124
 125                 i ++;
 126         }
 127
 128         return MODULE_ERR_OK;
 129 }
 130
 131 void Rhine2_int_InitialiseCard(tCard *Card)
 132 {
 133         tPAddr  phys;
 134
 135         Card->MacAddr[0] = inb(Card->IOBase + REG_PAR0);
 136         Card->MacAddr[1] = inb(Card->IOBase + REG_PAR1);
 137         Card->MacAddr[2] = inb(Card->IOBase + REG_PAR2);
 138         Card->MacAddr[3] = inb(Card->IOBase + REG_PAR3);
 139         Card->MacAddr[4] = inb(Card->IOBase + REG_PAR4);
 140         Card->MacAddr[5] = inb(Card->IOBase + REG_PAR5);
 141
 142         LOG("Resetting card");
 143         outb(Card->IOBase + REG_CR1, CR1_SFRST);
 144         // TODO: Timeout
 145         while( inb(Card->IOBase + REG_CR1) & CR1_SFRST ) ;
 146
 147         LOG("Allocaating RX buffers");
 148         // Allocate memory for things
 149         for( int i = 0; i < N_RX_BUF_PAGES; i ++ )
 150         {
 151                 Card->RXBuffers[i].Virt = (void*)MM_AllocDMA(1, 32, &phys);
 152                 Card->RXBuffers[i].Phys = phys;
 153         }
 154
 155         LOG("Allocating and filling RX/TX Descriptors");
 156         Card->DescTable = (void*)MM_AllocDMA(1, 32, &phys);
 157         Card->DescTablePhys = phys;
 158
 159         // Initialise RX Descriptors
 160         struct sRXDesc  *rxdescs = Card->DescTable;
 161         for( int i = 0; i < N_RX_DESCS; i ++ )
 162         {
 163                 rxdescs[i].RSR = 0;
 164                 rxdescs[i].BufferSize = RX_BUF_SIZE;
 165                 rxdescs[i].RXBufferStart = Card->RXBuffers[i/N_RX_BUF_PER_PAGE].Phys
 166                         + (i % N_RX_BUF_PER_PAGE) * RX_BUF_SIZE;
 167                 rxdescs[i].RDBranchAddress = Card->DescTablePhys + (i+1) * DESC_SIZE;
 168                 rxdescs[i].Length = (1 << 15);  // set OWN
 169                 LOG("RX Desc %p = {Buf:0x%8x, Next:0x%x}", rxdescs,
 170                         rxdescs[i].RXBufferStart, rxdescs[i].RDBranchAddress
 171                         );
 172         }
 173         rxdescs[ N_RX_DESCS - 1 ].RDBranchAddress = Card->DescTablePhys;
 174         Card->NextRX = &rxdescs[0];
 175
 176         Card->TXDescs = (void*)(rxdescs + N_RX_DESCS);
 177         memset(Card->TXDescs, 0, sizeof(struct sTXDesc)*N_TX_DESCS);
 178         for( int i = 0; i < N_TX_DESCS; i ++ )
 179         {
 180                 Card->TXDescs[i].TDBranchAddress = Card->DescTablePhys + (N_RX_DESCS + i + 1) * DESC_SIZE;
 181         }
 182         Card->TXDescs[N_TX_DESCS-1].TDBranchAddress = Card->DescTablePhys + N_RX_DESCS * DESC_SIZE;
 183         Card->nFreeTX = N_TX_DESCS;
 184         Card->NextTX = 0;
 185
 186         // - Initialise card state
 187         LOG("Initialising card state");
 188         outb(Card->IOBase + REG_IMR0, 0xFF);
 189         outb(Card->IOBase + REG_IMR1, 0xFF);
 190         outd(Card->IOBase + REG_CUR_RX_DESC, Card->DescTablePhys);
 191         outd(Card->IOBase + REG_CUR_TX_DESC, Card->DescTablePhys + N_RX_DESCS * DESC_SIZE);
 192
 193         outb(Card->IOBase + REG_TCR, TCR_TRSF(4));
 194
 195         LOG("RX started");
 196         outb(Card->IOBase + REG_CR0, CR0_BASEVAL);
 197         outb(Card->IOBase + REG_CR1, 0);        // Disabled TX polling only?
 198
 199         LOG("ISR state: %02x %02x", inb(Card->IOBase + REG_ISR0), inb(Card->IOBase + REG_ISR1));
 200 }
 201
 202 // --- File Functions ---
 203 tIPStackBuffer *Rhine2_WaitPacket(void *Ptr)
 204 {
 205         tCard   *card = Ptr;
 206         tIPStackBuffer  *ret;
 207         struct sRXDesc  *desc;
 208          int    nDesc;
 209
 210         ENTER("pPtr", Ptr);
 211
 212         LOG("CR0 state: %02x", inb(card->IOBase + REG_CR0));
 213         if( Semaphore_Wait( &card->ReadSemaphore, 1 ) != 1 )
 214         {
 215                 LEAVE('n');
 216                 return NULL;
 217         }
 218
 219         nDesc = 0;
 220         desc = card->NextRX;
 221         while( !(desc->Length & (1 << 15)) )
 222         {
 223 //              LOG("desc(%p) = {RSR:%04x,Length:%04x,BufferSize:%04x,RXBufferStart:%08x,RDBranchAddress:%08x}",
 224 //                      desc, desc->RSR, desc->Length, desc->BufferSize, desc->RXBufferStart, desc->RDBranchAddress);
 225                 // TODO: This kinda expensive call can be changed for an increment, but cbf
 226                 desc = Rhine2_int_GetDescFromPhys(card, desc->RDBranchAddress);
 227                 nDesc ++;
 228         }
 229
 230         LOG("%i descriptors in packet", nDesc);
 231
 232         ret = IPStack_Buffer_CreateBuffer(nDesc);
 233         desc = card->NextRX;
 234         while( !(desc->Length & (1 << 15)) )
 235         {
 236                 void    *data = Rhine2_int_GetBufferFromPhys(card, desc->RXBufferStart);
 237                 IPStack_Buffer_AppendSubBuffer(ret,
 238                         desc->Length, 0, data,
 239                         Rhine2_int_FreeRXDesc, desc
 240                         );
 241                 desc = Rhine2_int_GetDescFromPhys(card, desc->RDBranchAddress);
 242         }
 243         card->NextRX = desc;
 244
 245         LEAVE('p', ret);
 246         return ret;
 247 }
 248
 249 int Rhine2_SendPacket(void *Ptr, tIPStackBuffer *Buffer)
 250 {
 251         tCard   *card = Ptr;
 252         size_t  len;
 253         const void      *data;
 254          int    nDescs, first_desc_id;
 255         struct sTXDesc  *desc = NULL;
 256         struct sTXDesc  *first_desc = NULL;
 257         struct sTXDesc  *last_desc = NULL;
 258
 259         ENTER("pPtr pBuffer", Ptr, Buffer);
 260
 261         #if 0
 262         // Iterate buffers
 263         nDescs = 0;
 264         for( int id = -1; -1 != (id = IPStack_Buffer_GetBuffer(Buffer, id, &len, &data)); )
 265         {
 266                 if( ((tVAddr)data & (PAGE_SIZE-1)) + len > PAGE_SIZE )
 267                         nDescs ++;
 268                 nDescs ++;
 269         }
 270         if( nDescs == 0 ) {
 271                 LEAVE('i', -1);
 272                 return -1;
 273         }
 274
 275         LOG("%i descriptors needed", nDescs);
 276
 277         if( card->nFreeTX < nDescs ) {
 278                 // Oops... wait?
 279                 // TODO: Semaphore instead?
 280                 LEAVE('i', 1);
 281                 return 1;
 282         }
 283
 284         first_desc_id = card->NextTX;
 285         card->NextTX = (card->NextTX + nDescs) % N_TX_DESCS;
 286
 287         desc = card->TXDescs + first_desc_id;
 288
 289         nDescs = 0;
 290         for( int id = -1; -1 != (id = IPStack_Buffer_GetBuffer(Buffer, id, &len, &data)); )
 291         {
 292                 tPAddr  pdata = MM_GetPhysAddr( (tVAddr)data );
 293                 #if PHYS_BITS > 32
 294                 if( pdata >> 32 ) {
 295                         // TODO: re-map
 296                         Log_Warning("Rhine2", "TODO: Bounce-buffer >32 pbit buffers");
 297                 }
 298                 #endif
 299
 300                 if( (pdata & (PAGE_SIZE-1)) + len > PAGE_SIZE )
 301                 {
 302                         // Need to split into to descriptors
 303                         Log_Warning("Rhine2", "TODO: Split cross-page buffers");
 304                 }
 305
 306                 LOG("Buffer %i (%p+0x%x) placed in %p", id-1, data, len, desc);
 307
 308                 // TODO: Rhine I requires 4-byte alignment (fsck that, I don't have one)
 309
 310                 desc->TXBufferStart = pdata;
 311                 desc->BufferSize = len | (1 << 15);
 312                 // TODO: TCR
 313                 desc->TCR = 0;
 314                 if( nDescs == 0 )
 315                         desc->TSR = 0;  // OWN will be set below
 316                 else
 317                         desc->TSR = TD_TSR_OWN;
 318
 319                 nDescs ++;
 320                 if(first_desc_id + nDescs == N_TX_DESCS)
 321                         desc = card->TXDescs;
 322                 else
 323                         desc ++;
 324         }
 325         #else
 326         data = IPStack_Buffer_CompactBuffer(Buffer, &len);
 327
 328         nDescs = 1;
 329         first_desc_id = card->NextTX;
 330         card->NextTX = (card->NextTX + nDescs) % N_TX_DESCS;
 331         desc = card->TXDescs + first_desc_id;
 332
 333         desc->TXBufferStart = MM_GetPhysAddr( data );
 334         desc->BufferSize = len | (1 << 15);
 335         desc->TSR = 0;
 336         desc->TCR = 0;
 337         #endif
 338
 339         first_desc = card->TXDescs + first_desc_id;
 340         last_desc = desc;
 341
 342         first_desc->TCR |= TD_TCR_STP;
 343         last_desc->TCR |= TD_TCR_EDP|TD_TCR_IC;
 344 //      last_desc->BufferSize &= ~(1 << 15);
 345
 346         first_desc->TSR |= TD_TSR_OWN;
 347
 348         LOG("%i descriptors allocated, first = %p, last = %p", nDescs, first_desc, last_desc);
 349
 350
 351         LOG("Waiting for TX to complete");
 352         outb(card->IOBase + REG_CR0, CR0_TDMD|CR0_BASEVAL);
 353         Semaphore_Wait(&card->SendSemaphore, 1);
 354
 355         #if 1
 356         free((void*)data);
 357         #endif
 358
 359         LEAVE('i', 0);
 360         return 0;
 361 }
 362
 363 void Rhine2_IRQHandler(int Num, void *Ptr)
 364 {
 365         tCard   *card = Ptr;
 366         Uint8   isr0 = inb(card->IOBase + REG_ISR0);
 367         Uint8   isr1 = inb(card->IOBase + REG_ISR1);
 368
 369         if( isr0 == 0 ) return ;
 370
 371         LOG("ISR0 = 0x%02x, ISR1 = 0x%02x", isr0, isr1);
 372
 373         if( isr0 & ISR0_PRX )
 374         {
 375                 LOG("PRX");
 376                 Semaphore_Signal(&card->ReadSemaphore, 1);
 377         }
 378
 379         if( isr0 & ISR0_PTX )
 380         {
 381                 LOG("PTX");
 382                 Semaphore_Signal(&card->SendSemaphore, 1);
 383         }
 384
 385         if( isr0 & ISR0_TXE )
 386         {
 387                 LOG("TX Error... oops");
 388                 Semaphore_Signal(&card->SendSemaphore, 1);
 389         }
 390
 391         if( isr0 & ISR0_TU )
 392         {
 393                 LOG("Transmit buffer underflow");
 394         }
 395
 396         LOG("Acking interrupts");
 397         outb(card->IOBase + REG_ISR0, isr0);
 398         outb(card->IOBase + REG_ISR1, isr1);
 399 }
 400
 401 // --- Helpers ---
 402 struct sRXDesc *Rhine2_int_GetDescFromPhys(tCard *Card, Uint32 Addr)
 403 {
 404         if( Card->DescTablePhys > Addr )        return NULL;
 405         if( Card->DescTablePhys + PAGE_SIZE <= Addr )   return NULL;
 406         if( Addr & 15 ) return NULL;
 407         return (struct sRXDesc*)Card->DescTable + ((Addr & (PAGE_SIZE-1)) / 16);
 408 }
 409
 410 void *Rhine2_int_GetBufferFromPhys(tCard *Card, Uint32 Addr)
 411 {
 412         for( int i = 0; i < N_RX_BUF_PAGES; i ++ )
 413         {
 414                 if( Card->RXBuffers[i].Phys > Addr )    continue;
 415                 if( Card->RXBuffers[i].Phys + PAGE_SIZE <= Addr )       continue;
 416                 return Card->RXBuffers[i].Virt + (Addr & (PAGE_SIZE-1));
 417         }
 418         return NULL;
 419 }
 420
 421 void Rhine2_int_FreeRXDesc(void *Ptr, size_t u1, size_t u2, const void *u3)
 422 {
 423         struct sRXDesc  *desc = Ptr;
 424
 425         LOG("Descriptor %p returned to card", desc);
 426
 427         desc->RSR = 0;
 428         desc->Length = (1 << 15);       // Reset OWN
 429 }
 430