Modules/NE2000/ne2000.c

   1 /* Acess2
   2  * NE2000 Driver
   3  *
   4  * See: ~/Sources/bochs/bochs.../iodev/ne2k.cc
   5  */
   6 #define DEBUG   0
   7 #define VERSION ((0<<8)|50)
   8 #include <acess.h>
   9 #include <modules.h>
  10 #include <fs_devfs.h>
  11 #include <drv_pci.h>
  12 #include <tpl_drv_network.h>
  13
  14 // === CONSTANTS ===
  15 #define MEM_START       0x40
  16 #define MEM_END         0xC0
  17 #define RX_FIRST        (MEM_START)
  18 #define RX_LAST         (MEM_START+RX_BUF_SIZE-1)
  19 #define RX_BUF_SIZE     0x40
  20 #define TX_FIRST        (MEM_START+RX_BUF_SIZE)
  21 #define TX_LAST         (MEM_END)
  22 #define TX_BUF_SIZE     0x40
  23 #define MAX_PACKET_QUEUE        10
  24
  25 static const struct {
  26         Uint16  Vendor;
  27         Uint16  Device;
  28 } csaCOMPAT_DEVICES[] = {
  29         {0x10EC, 0x8029},       // Realtek 8029
  30         {0x10EC, 0x8129}        // Realtek 8129
  31 };
  32 #define NUM_COMPAT_DEVICES      (sizeof(csaCOMPAT_DEVICES)/sizeof(csaCOMPAT_DEVICES[0]))
  33
  34 enum eNe2k_Page0Read {
  35         CMD = 0,        //!< the master command register
  36         CLDA0,          //!< Current Local DMA Address 0
  37         CLDA1,          //!< Current Local DMA Address 1
  38         BNRY,           //!< Boundary Pointer (for ringbuffer)
  39         TSR,            //!< Transmit Status Register
  40         NCR,            //!< collisions counter
  41         FIFO,           //!< (for what purpose ??)
  42         ISR,            //!< Interrupt Status Register
  43         CRDA0,          //!< Current Remote DMA Address 0
  44         CRDA1,          //!< Current Remote DMA Address 1
  45         RSR = 0xC       //!< Receive Status Register
  46 };
  47
  48 enum eNe2k_Page0Write {
  49         PSTART = 1,     //!< page start (init only)
  50         PSTOP,          //!< page stop  (init only)
  51         TPSR = 4,       //!< transmit page start address
  52         TBCR0,          //!< transmit byte count (low)
  53         TBCR1,          //!< transmit byte count (high)
  54         RSAR0 = 8,      //!< remote start address (lo)
  55         RSAR1,  //!< remote start address (hi)
  56         RBCR0,  //!< remote byte count (lo)
  57         RBCR1,  //!< remote byte count (hi)
  58         RCR,    //!< receive config register
  59         TCR,    //!< transmit config register
  60         DCR,    //!< data config register    (init)
  61         IMR             //!< interrupt mask register (init)
  62 };
  63
  64 enum eNe2k_Page1Read {
  65         CURR = 7        //!< current page
  66 };
  67
  68 // === TYPES ===
  69 typedef struct sNe2k_Card {
  70         Uint16  IOBase; //!< IO Port Address from PCI
  71         Uint8   IRQ;    //!< IRQ Assigned from PCI
  72
  73          int    NumWaitingPackets;
  74          int    NextRXPage;
  75
  76          int    NextMemPage;    //!< Next Card Memory page to use
  77
  78         Uint8   Buffer[RX_BUF_SIZE];
  79
  80         char    Name[2];        // "0"
  81         tVFS_Node       Node;
  82         Uint8   MacAddr[6];
  83 } tCard;
  84
  85 // === PROTOTYPES ===
  86  int    Ne2k_Install(char **Arguments);
  87 char    *Ne2k_ReadDir(tVFS_Node *Node, int Pos);
  88 tVFS_Node       *Ne2k_FindDir(tVFS_Node *Node, char *Name);
  89  int    Ne2k_IOCtl(tVFS_Node *Node, int ID, void *Data);
  90 Uint64  Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  91 Uint64  Ne2k_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  92 Uint8   Ne2k_int_GetWritePage(tCard *Card, Uint16 Length);
  93 void    Ne2k_IRQHandler(int IntNum);
  94
  95 // === GLOBALS ===
  96 MODULE_DEFINE(0, VERSION, Ne2k, Ne2k_Install, NULL, NULL);
  97 tDevFS_Driver   gNe2k_DriverInfo = {
  98         NULL, "ne2k",
  99         {
 100         .NumACLs = 1,
 101         .ACLs = &gVFS_ACL_EveryoneRX,
 102         .Flags = VFS_FFLAG_DIRECTORY,
 103         .ReadDir = Ne2k_ReadDir,
 104         .FindDir = Ne2k_FindDir,
 105         .IOCtl = Ne2k_IOCtl
 106         }
 107 };
 108 Uint16  gNe2k_BaseAddress;
 109  int    giNe2k_CardCount = 0;
 110 tCard   *gpNe2k_Cards = NULL;
 111
 112 // === CODE ===
 113 /**
 114  * \fn int Ne2k_Install(char **Options)
 115  * \brief Installs the NE2000 Driver
 116  */
 117 int Ne2k_Install(char **Options)
 118 {
 119          int    i, j, k;
 120          int    count, id, base;
 121
 122         // --- Scan PCI Bus ---
 123         // Count Cards
 124         giNe2k_CardCount = 0;
 125         for( i = 0; i < NUM_COMPAT_DEVICES; i ++ )
 126         {
 127                 giNe2k_CardCount += PCI_CountDevices( csaCOMPAT_DEVICES[i].Vendor, csaCOMPAT_DEVICES[i].Device, 0 );
 128         }
 129
 130         // Enumerate Cards
 131         k = 0;
 132         gpNe2k_Cards = calloc( giNe2k_CardCount, sizeof(tCard) );
 133
 134         for( i = 0; i < NUM_COMPAT_DEVICES; i ++ )
 135         {
 136                 count = PCI_CountDevices( csaCOMPAT_DEVICES[i].Vendor, csaCOMPAT_DEVICES[i].Device, 0 );
 137                 for( j = 0; j < count; j ++,k ++ )
 138                 {
 139                         id = PCI_GetDevice( csaCOMPAT_DEVICES[i].Vendor, csaCOMPAT_DEVICES[i].Device, 0, j );
 140                         // Create Structure
 141                         base = PCI_AssignPort( id, 0, 0x20 );
 142                         gpNe2k_Cards[ k ].IOBase = base;
 143                         gpNe2k_Cards[ k ].IRQ = PCI_GetIRQ( id );
 144                         gpNe2k_Cards[ k ].NextMemPage = 64;
 145                         gpNe2k_Cards[ k ].NextRXPage = RX_FIRST;
 146
 147                         // Install IRQ Handler
 148                         IRQ_AddHandler(gpNe2k_Cards[ k ].IRQ, Ne2k_IRQHandler);
 149
 150                         // Reset Card
 151                         outb( base + 0x1F, inb(base + 0x1F) );
 152                         while( (inb( base+ISR ) & 0x80) == 0 );
 153                         outb( base + ISR, 0x80 );
 154
 155                         // Initialise Card
 156                         outb( base + CMD, 0x40|0x21 );  // Page 1, No DMA, Stop
 157                         outb( base + CURR, RX_FIRST );  // Current RX page
 158                         outb( base + CMD, 0x21 );       // No DMA and Stop
 159                         outb( base + DCR, 0x49 );       // Set WORD mode
 160                         outb( base + IMR, 0x00 );
 161                         outb( base + ISR, 0xFF );
 162                         outb( base + RCR, 0x20 );       // Reciever to Monitor
 163                         outb( base + TCR, 0x02 );       // Transmitter OFF (TCR.LB = 1, Internal Loopback)
 164                         outb( base + RBCR0, 6*4 );      // Remote Byte Count
 165                         outb( base + RBCR1, 0 );
 166                         outb( base + RSAR0, 0 );        // Clear Source Address
 167                         outb( base + RSAR1, 0 );
 168                         outb( base + CMD, 0x0A );       // Remote Read, Start
 169
 170                         // Read MAC Address
 171                         gpNe2k_Cards[ k ].MacAddr[0] = inb(base+0x10);//        inb(base+0x10);
 172                         gpNe2k_Cards[ k ].MacAddr[1] = inb(base+0x10);//        inb(base+0x10);
 173                         gpNe2k_Cards[ k ].MacAddr[2] = inb(base+0x10);//        inb(base+0x10);
 174                         gpNe2k_Cards[ k ].MacAddr[3] = inb(base+0x10);//        inb(base+0x10);
 175                         gpNe2k_Cards[ k ].MacAddr[4] = inb(base+0x10);//        inb(base+0x10);
 176                         gpNe2k_Cards[ k ].MacAddr[5] = inb(base+0x10);//        inb(base+0x10);
 177
 178                         outb( base+PSTART, RX_FIRST);   // Set Receive Start
 179                         outb( base+BNRY, RX_LAST-1);    // Set Boundary Page
 180                         outb( base+PSTOP, RX_LAST);     // Set Stop Page
 181                         outb( base+ISR, 0xFF ); // Clear all ints
 182                         outb( base+CMD, 0x22 ); // No DMA, Start
 183                         outb( base+IMR, 0x3F ); // Set Interupt Mask
 184                         outb( base+RCR, 0x0F ); // Set WRAP and allow all packet matches
 185                         outb( base+TCR, 0x00 ); // Set Normal Transmitter mode
 186                         outb( base+TPSR, 0x40); // Set Transmit Start
 187                         // Set MAC Address
 188                         /*
 189                         Ne2k_WriteReg(base, MAC0, gpNe2k_Cards[ k ].MacAddr[0]);
 190                         Ne2k_WriteReg(base, MAC1, gpNe2k_Cards[ k ].MacAddr[1]);
 191                         Ne2k_WriteReg(base, MAC2, gpNe2k_Cards[ k ].MacAddr[2]);
 192                         Ne2k_WriteReg(base, MAC3, gpNe2k_Cards[ k ].MacAddr[3]);
 193                         Ne2k_WriteReg(base, MAC4, gpNe2k_Cards[ k ].MacAddr[4]);
 194                         Ne2k_WriteReg(base, MAC5, gpNe2k_Cards[ k ].MacAddr[5]);
 195                         */
 196
 197                         Log("[NE2K]: Card #%i: IRQ=%i, IOBase=0x%x",
 198                                 k, gpNe2k_Cards[ k ].IRQ, gpNe2k_Cards[ k ].IOBase);
 199                         Log("MAC Address %x:%x:%x:%x:%x:%x",
 200                                 gpNe2k_Cards[ k ].MacAddr[0], gpNe2k_Cards[ k ].MacAddr[1],
 201                                 gpNe2k_Cards[ k ].MacAddr[2], gpNe2k_Cards[ k ].MacAddr[3],
 202                                 gpNe2k_Cards[ k ].MacAddr[4], gpNe2k_Cards[ k ].MacAddr[5]
 203                                 );
 204
 205                         // Set VFS Node
 206                         gpNe2k_Cards[ k ].Name[0] = '0'+k;
 207                         gpNe2k_Cards[ k ].Name[1] = '\0';
 208                         gpNe2k_Cards[ k ].Node.ImplPtr = &gpNe2k_Cards[ k ];
 209                         gpNe2k_Cards[ k ].Node.NumACLs = 0;     // Root Only
 210                         gpNe2k_Cards[ k ].Node.CTime = now();
 211                         gpNe2k_Cards[ k ].Node.Write = Ne2k_Write;
 212                         gpNe2k_Cards[ k ].Node.Read = Ne2k_Read;
 213                         gpNe2k_Cards[ k ].Node.IOCtl = Ne2k_IOCtl;
 214                 }
 215         }
 216
 217         gNe2k_DriverInfo.RootNode.Size = giNe2k_CardCount;
 218         DevFS_AddDevice( &gNe2k_DriverInfo );
 219         return 1;
 220 }
 221
 222 /**
 223  * \fn char *Ne2k_ReadDir(tVFS_Node *Node, int Pos)
 224  */
 225 char *Ne2k_ReadDir(tVFS_Node *Node, int Pos)
 226 {
 227         char    ret[2];
 228         if(Pos < 0 || Pos >= giNe2k_CardCount)  return NULL;
 229         ret[0] = '0'+Pos;
 230         ret[1] = '\0';
 231         return strdup(ret);
 232 }
 233
 234 /**
 235  * \fn tVFS_Node *Ne2k_FindDir(tVFS_Node *Node, char *Name)
 236  */
 237 tVFS_Node *Ne2k_FindDir(tVFS_Node *Node, char *Name)
 238 {
 239         if(Name[0] == '\0' || Name[1] != '\0')  return NULL;
 240
 241         return &gpNe2k_Cards[ Name[0]-'0' ].Node;
 242 }
 243
 244 static const char *casIOCtls[] = { DRV_IOCTLNAMES, DRV_NETWORK_IOCTLNAMES, NULL };
 245 /**
 246  * \fn int Ne2k_IOCtl(tVFS_Node *Node, int ID, void *Data)
 247  * \brief IOCtl calls for a network device
 248  */
 249 int Ne2k_IOCtl(tVFS_Node *Node, int ID, void *Data)
 250 {
 251          int    tmp;
 252         ENTER("pNode iID pData", Node, ID, Data);
 253         switch( ID )
 254         {
 255         case DRV_IOCTL_TYPE:
 256                 LEAVE('i', DRV_TYPE_NETWORK);
 257                 return DRV_TYPE_NETWORK;
 258
 259         case DRV_IOCTL_IDENT:
 260                 if(!CheckMem(Data, 4)) {
 261                         LEAVE('i', -1);
 262                         return -1;
 263                 }
 264                 memcpy(Data, "NE2K", 4);
 265                 LEAVE('i', 1);
 266                 return 1;
 267
 268         case DRV_IOCTL_VERSION:
 269                 LEAVE('x', VERSION);
 270                 return VERSION;
 271
 272         case DRV_IOCTL_LOOKUP:
 273                 if( !CheckString(Data) ) {
 274                         LEAVE('i', -1);
 275                         return -1;
 276                 }
 277                 tmp = LookupString( (char**)casIOCtls, Data );
 278                 LEAVE('i', tmp);
 279                 return tmp;
 280         }
 281
 282         // If this is the root, return
 283         if( Node == &gNe2k_DriverInfo.RootNode ) {
 284                 LEAVE('i', 0);
 285                 return 0;
 286         }
 287
 288         // Device specific settings
 289         switch( ID )
 290         {
 291         case NET_IOCTL_GETMAC:
 292                 if( !CheckMem(Data, 6) ) {
 293                         LEAVE('i', -1);
 294                         return -1;
 295                 }
 296                 memcpy( Data, ((tCard*)Node->ImplPtr)->MacAddr, 6 );
 297                 LEAVE('i', 1);
 298                 return 1;
 299         }
 300         LEAVE('i', 0);
 301         return 0;
 302 }
 303
 304 /**
 305  * \fn Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 306  * \brief Send a packet from the network card
 307  */
 308 Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 309 {
 310         tCard   *Card = (tCard*)Node->ImplPtr;
 311         Uint16  *buf = Buffer;
 312          int    rem = Length;
 313
 314         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 315
 316         // Sanity Check Length
 317         if(Length > TX_BUF_SIZE) {
 318                 LEAVE('i', 0);
 319                 return 0;
 320         }
 321
 322         // Make sure that the card is in page 0
 323         outb(Card->IOBase + CMD, 0|0x22);       // Page 0, Start, NoDMA
 324
 325         // Clear Remote DMA Flag
 326         outb(Card->IOBase + ISR, 0x40); // Bit 6
 327
 328         // Send Size - Remote Byte Count Register
 329         outb(Card->IOBase + TBCR0, Length & 0xFF);
 330         outb(Card->IOBase + TBCR1, Length >> 8);
 331
 332         // Send Size - Remote Byte Count Register
 333         outb(Card->IOBase + RBCR0, Length & 0xFF);
 334         outb(Card->IOBase + RBCR1, Length >> 8);
 335
 336         // Set up transfer
 337         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 338         outb(Card->IOBase + RSAR1, Ne2k_int_GetWritePage(Card, Length));        // Page Offset
 339         // Start
 340         //outb(Card->IOBase + CMD, 0|0x18|0x4|0x2);     // Page 0, Transmit Packet, TXP, Start
 341         outb(Card->IOBase + CMD, 0|0x10|0x2);   // Page 0, Remote Write, Start
 342
 343         // Send Data
 344         for(rem = Length; rem; rem -= 2)
 345                 outw(Card->IOBase + 0x10, *buf++);
 346
 347         while( inb(Card->IOBase + ISR) == 0 )   // Wait for Remote DMA Complete
 348                 ;       //Proc_Yield();
 349
 350         outb( Card->IOBase + ISR, 0x40 );       // ACK Interrupt
 351
 352         // Send Packet
 353         outb(Card->IOBase + CMD, 0|0x10|0x4|0x2);
 354
 355         // Complete DMA
 356         //outb(Card->IOBase + CMD, 0|0x20);
 357
 358         LEAVE('i', Length);
 359         return Length;
 360 }
 361
 362 /**
 363  * \fn Uint64 Ne2k_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 364  * \brief Wait for and read a packet from the network card
 365  */
 366 Uint64 Ne2k_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 367 {
 368         tCard   *Card = (tCard*)Node->ImplPtr;
 369         Uint8   page;
 370         Uint8   data[256];
 371          int    i;
 372         struct {
 373                 Uint8   Status;
 374                 Uint8   NextPacketPage;
 375                 Uint16  Length; // Little Endian
 376         }       *pktHdr;
 377
 378         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 379
 380         while(Card->NumWaitingPackets == 0)     Threads_Yield();
 381
 382         // Make sure that the card is in page 0
 383         outb(Card->IOBase + CMD, 0|0x22);       // Page 0, Start, NoDMA
 384
 385         // Get BOUNDARY
 386         page = Card->NextRXPage;
 387
 388         // Set up transfer
 389         outb(Card->IOBase + RBCR0, 0);
 390         outb(Card->IOBase + RBCR1, 1);  // 256-bytes
 391         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 392         outb(Card->IOBase + RSAR1, page);       // Page Number
 393
 394         outb(Card->IOBase + CMD, 0|0x08|0x2);   // Page 0, Remote Read, Start
 395
 396         // Clear Remote DMA Flag
 397         outb(Card->IOBase + ISR, 0x40); // Bit 6
 398
 399         // Read data
 400         for(i = 0; i < 128; i ++)
 401                 ((Uint16*)data)[i] = inw(Card->IOBase + 0x10);
 402
 403         pktHdr = (void*)data;
 404         //Log("Ne2k_Read: Recieved packet (%i bytes)", pktHdr->Length);
 405
 406         // Have we read all the required bytes yet?
 407         if(pktHdr->Length < 256 - 4)
 408         {
 409                 if(Length > pktHdr->Length)
 410                         Length = pktHdr->Length;
 411                 memcpy(Buffer, &data[4], Length);
 412                 page ++;
 413                 if(page == RX_LAST+1)   page = RX_FIRST;
 414         }
 415         // No? oh damn, now we need to allocate a buffer
 416         else {
 417                  int    j = 256/2;
 418                 char    *buf = malloc( (pktHdr->Length + 4 + 255) & ~255 );
 419
 420                 if(!buf) {
 421                         LEAVE('i', -1);
 422                         return -1;
 423                 }
 424
 425                 memcpy(buf, data, 256);
 426
 427                 page ++;
 428                 while(page != pktHdr->NextPacketPage)
 429                 {
 430                         if(page == RX_LAST+1)   page = RX_FIRST;
 431
 432                         outb(Card->IOBase + RBCR0, 0);
 433                         outb(Card->IOBase + RBCR1, 1);  // 256-bytes
 434                         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 435                         outb(Card->IOBase + RSAR1, page);       // Page Number
 436                         outb(Card->IOBase + CMD, 0|0x08|0x2);   // Page 0, Remote Read, Start
 437
 438                         for(i = 0; i < 128; i ++)
 439                                 ((Uint16*)buf)[j+i] = inw(Card->IOBase + 0x10);
 440                         j += 128;
 441                         page ++;
 442                 }
 443
 444                 if(Length > pktHdr->Length)
 445                         Length = pktHdr->Length;
 446                 memcpy(Buffer, &buf[4], Length);
 447         }
 448
 449         // Write BNRY
 450         if(page == RX_FIRST)
 451                 outb( Card->IOBase + BNRY, RX_LAST );
 452         else
 453                 outb( Card->IOBase + BNRY, page-1 );
 454         // Set next RX Page and decrement the waiting list
 455         Card->NextRXPage = page;
 456         Card->NumWaitingPackets --;
 457
 458         LEAVE('i', Length);
 459         return Length;
 460 }
 461
 462 /**
 463  * \fn Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length)
 464  */
 465 Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length)
 466 {
 467         Uint8   ret = Card->NextMemPage;
 468
 469         Card->NextMemPage += (Length + 0xFF) >> 8;
 470         if(Card->NextMemPage >= TX_LAST) {
 471                 Card->NextMemPage -= TX_BUF_SIZE;
 472         }
 473
 474         return ret;
 475 }
 476
 477 /**
 478  * \fn void Ne2k_IRQHandler(int IntNum)
 479  */
 480 void Ne2k_IRQHandler(int IntNum)
 481 {
 482          int    i;
 483         Uint8   byte;
 484         for( i = 0; i < giNe2k_CardCount; i++ )
 485         {
 486                 if(gpNe2k_Cards[i].IRQ == IntNum)
 487                 {
 488                         byte = inb( gpNe2k_Cards[i].IOBase + ISR );
 489
 490                         // 0: Packet recieved (no error)
 491                         if( byte & 1 )
 492                         {
 493                                 gpNe2k_Cards[i].NumWaitingPackets ++;
 494                                 if( gpNe2k_Cards[i].NumWaitingPackets > MAX_PACKET_QUEUE )
 495                                         gpNe2k_Cards[i].NumWaitingPackets = MAX_PACKET_QUEUE;
 496                         }
 497                         // 1: Packet sent (no error)
 498                         // 2: Recieved with error
 499                         // 3: Transmission Halted (Excessive Collisions)
 500                         // 4: Recieve Buffer Exhausted
 501                         // 5:
 502                         // 6: Remote DMA Complete
 503                         // 7: Reset
 504                         //LOG("Clearing interrupts on card %i (was 0x%x)\n", i, byte);
 505                         outb( gpNe2k_Cards[i].IOBase + ISR, 0xFF );     // Reset All
 506                         return ;
 507                 }
 508         }
 509         Warning("[NE2K ] Recieved Unknown IRQ %i", IntNum);
 510 }