Modules/Network/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                 tmp = ModUtil_SetIdent(Data, "Ne2k");
 261                 LEAVE('i', tmp);
 262                 return tmp;
 263
 264         case DRV_IOCTL_VERSION:
 265                 LEAVE('x', VERSION);
 266                 return VERSION;
 267
 268         case DRV_IOCTL_LOOKUP:
 269                 tmp = ModUtil_LookupString( (char**)casIOCtls, Data );
 270                 LEAVE('i', tmp);
 271                 return tmp;
 272         }
 273
 274         // If this is the root, return
 275         if( Node == &gNe2k_DriverInfo.RootNode ) {
 276                 LEAVE('i', 0);
 277                 return 0;
 278         }
 279
 280         // Device specific settings
 281         switch( ID )
 282         {
 283         case NET_IOCTL_GETMAC:
 284                 if( !CheckMem(Data, 6) ) {
 285                         LEAVE('i', -1);
 286                         return -1;
 287                 }
 288                 memcpy( Data, ((tCard*)Node->ImplPtr)->MacAddr, 6 );
 289                 LEAVE('i', 1);
 290                 return 1;
 291         }
 292         LEAVE('i', 0);
 293         return 0;
 294 }
 295
 296 /**
 297  * \fn Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 298  * \brief Send a packet from the network card
 299  */
 300 Uint64 Ne2k_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 301 {
 302         tCard   *Card = (tCard*)Node->ImplPtr;
 303         Uint16  *buf = Buffer;
 304          int    rem = Length;
 305
 306         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 307
 308         // Sanity Check Length
 309         if(Length > TX_BUF_SIZE) {
 310                 LEAVE('i', 0);
 311                 return 0;
 312         }
 313
 314         // Make sure that the card is in page 0
 315         outb(Card->IOBase + CMD, 0|0x22);       // Page 0, Start, NoDMA
 316
 317         // Clear Remote DMA Flag
 318         outb(Card->IOBase + ISR, 0x40); // Bit 6
 319
 320         // Send Size - Remote Byte Count Register
 321         outb(Card->IOBase + TBCR0, Length & 0xFF);
 322         outb(Card->IOBase + TBCR1, Length >> 8);
 323
 324         // Send Size - Remote Byte Count Register
 325         outb(Card->IOBase + RBCR0, Length & 0xFF);
 326         outb(Card->IOBase + RBCR1, Length >> 8);
 327
 328         // Set up transfer
 329         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 330         outb(Card->IOBase + RSAR1, Ne2k_int_GetWritePage(Card, Length));        // Page Offset
 331         // Start
 332         //outb(Card->IOBase + CMD, 0|0x18|0x4|0x2);     // Page 0, Transmit Packet, TXP, Start
 333         outb(Card->IOBase + CMD, 0|0x10|0x2);   // Page 0, Remote Write, Start
 334
 335         // Send Data
 336         for(rem = Length; rem; rem -= 2)
 337                 outw(Card->IOBase + 0x10, *buf++);
 338
 339         while( inb(Card->IOBase + ISR) == 0 )   // Wait for Remote DMA Complete
 340                 ;       //Proc_Yield();
 341
 342         outb( Card->IOBase + ISR, 0x40 );       // ACK Interrupt
 343
 344         // Send Packet
 345         outb(Card->IOBase + CMD, 0|0x10|0x4|0x2);
 346
 347         // Complete DMA
 348         //outb(Card->IOBase + CMD, 0|0x20);
 349
 350         LEAVE('i', Length);
 351         return Length;
 352 }
 353
 354 /**
 355  * \fn Uint64 Ne2k_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 356  * \brief Wait for and read a packet from the network card
 357  */
 358 Uint64 Ne2k_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 359 {
 360         tCard   *Card = (tCard*)Node->ImplPtr;
 361         Uint8   page;
 362         Uint8   data[256];
 363          int    i;
 364         struct {
 365                 Uint8   Status;
 366                 Uint8   NextPacketPage;
 367                 Uint16  Length; // Little Endian
 368         }       *pktHdr;
 369
 370         ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
 371
 372         while(Card->NumWaitingPackets == 0)     Threads_Yield();
 373
 374         // Make sure that the card is in page 0
 375         outb(Card->IOBase + CMD, 0|0x22);       // Page 0, Start, NoDMA
 376
 377         // Get BOUNDARY
 378         page = Card->NextRXPage;
 379
 380         // Set up transfer
 381         outb(Card->IOBase + RBCR0, 0);
 382         outb(Card->IOBase + RBCR1, 1);  // 256-bytes
 383         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 384         outb(Card->IOBase + RSAR1, page);       // Page Number
 385
 386         outb(Card->IOBase + CMD, 0|0x08|0x2);   // Page 0, Remote Read, Start
 387
 388         // Clear Remote DMA Flag
 389         outb(Card->IOBase + ISR, 0x40); // Bit 6
 390
 391         // Read data
 392         for(i = 0; i < 128; i ++)
 393                 ((Uint16*)data)[i] = inw(Card->IOBase + 0x10);
 394
 395         pktHdr = (void*)data;
 396         //Log("Ne2k_Read: Recieved packet (%i bytes)", pktHdr->Length);
 397
 398         // Have we read all the required bytes yet?
 399         if(pktHdr->Length < 256 - 4)
 400         {
 401                 if(Length > pktHdr->Length)
 402                         Length = pktHdr->Length;
 403                 memcpy(Buffer, &data[4], Length);
 404                 page ++;
 405                 if(page == RX_LAST+1)   page = RX_FIRST;
 406         }
 407         // No? oh damn, now we need to allocate a buffer
 408         else {
 409                  int    j = 256/2;
 410                 char    *buf = malloc( (pktHdr->Length + 4 + 255) & ~255 );
 411
 412                 if(!buf) {
 413                         LEAVE('i', -1);
 414                         return -1;
 415                 }
 416
 417                 memcpy(buf, data, 256);
 418
 419                 page ++;
 420                 while(page != pktHdr->NextPacketPage)
 421                 {
 422                         if(page == RX_LAST+1)   page = RX_FIRST;
 423
 424                         outb(Card->IOBase + RBCR0, 0);
 425                         outb(Card->IOBase + RBCR1, 1);  // 256-bytes
 426                         outb(Card->IOBase + RSAR0, 0x00);       // Page Offset
 427                         outb(Card->IOBase + RSAR1, page);       // Page Number
 428                         outb(Card->IOBase + CMD, 0|0x08|0x2);   // Page 0, Remote Read, Start
 429
 430                         for(i = 0; i < 128; i ++)
 431                                 ((Uint16*)buf)[j+i] = inw(Card->IOBase + 0x10);
 432                         j += 128;
 433                         page ++;
 434                 }
 435
 436                 if(Length > pktHdr->Length)
 437                         Length = pktHdr->Length;
 438                 memcpy(Buffer, &buf[4], Length);
 439         }
 440
 441         // Write BNRY
 442         if(page == RX_FIRST)
 443                 outb( Card->IOBase + BNRY, RX_LAST );
 444         else
 445                 outb( Card->IOBase + BNRY, page-1 );
 446         // Set next RX Page and decrement the waiting list
 447         Card->NextRXPage = page;
 448         Card->NumWaitingPackets --;
 449
 450         LEAVE('i', Length);
 451         return Length;
 452 }
 453
 454 /**
 455  * \fn Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length)
 456  */
 457 Uint8 Ne2k_int_GetWritePage(tCard *Card, Uint16 Length)
 458 {
 459         Uint8   ret = Card->NextMemPage;
 460
 461         Card->NextMemPage += (Length + 0xFF) >> 8;
 462         if(Card->NextMemPage >= TX_LAST) {
 463                 Card->NextMemPage -= TX_BUF_SIZE;
 464         }
 465
 466         return ret;
 467 }
 468
 469 /**
 470  * \fn void Ne2k_IRQHandler(int IntNum)
 471  */
 472 void Ne2k_IRQHandler(int IntNum)
 473 {
 474          int    i;
 475         Uint8   byte;
 476         for( i = 0; i < giNe2k_CardCount; i++ )
 477         {
 478                 if(gpNe2k_Cards[i].IRQ == IntNum)
 479                 {
 480                         byte = inb( gpNe2k_Cards[i].IOBase + ISR );
 481
 482                         // 0: Packet recieved (no error)
 483                         if( byte & 1 )
 484                         {
 485                                 gpNe2k_Cards[i].NumWaitingPackets ++;
 486                                 if( gpNe2k_Cards[i].NumWaitingPackets > MAX_PACKET_QUEUE )
 487                                         gpNe2k_Cards[i].NumWaitingPackets = MAX_PACKET_QUEUE;
 488                         }
 489                         // 1: Packet sent (no error)
 490                         // 2: Recieved with error
 491                         // 3: Transmission Halted (Excessive Collisions)
 492                         // 4: Recieve Buffer Exhausted
 493                         // 5:
 494                         // 6: Remote DMA Complete
 495                         // 7: Reset
 496                         //LOG("Clearing interrupts on card %i (was 0x%x)\n", i, byte);
 497                         outb( gpNe2k_Cards[i].IOBase + ISR, 0xFF );     // Reset All
 498                         return ;
 499                 }
 500         }
 501         Warning("[NE2K ] Recieved Unknown IRQ %i", IntNum);
 502 }