workbench/devs/networks/via-rhine/unit.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful, but
  12     WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14     General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19     MA 02111-1307, USA.
  20 */
  21
  22 #include <exec/types.h>
  23 #include <exec/resident.h>
  24 #include <exec/io.h>
  25 #include <exec/ports.h>
  26 #include <exec/errors.h>
  27
  28 #include <aros/io.h>
  29
  30 #include <devices/sana2.h>
  31 #include <devices/sana2specialstats.h>
  32 #include <devices/newstyle.h>
  33 #include <devices/timer.h>
  34
  35 #include <utility/utility.h>
  36 #include <utility/tagitem.h>
  37 #include <utility/hooks.h>
  38
  39 #include <proto/exec.h>
  40 #include <proto/dos.h>
  41 #include <proto/battclock.h>
  42 #include <proto/oop.h>
  43 #include <proto/timer.h>
  44 #include <proto/utility.h>
  45
  46 #include <stdlib.h>
  47 #include <stdio.h>
  48
  49 #include "via-rhine.h"
  50 #include "unit.h"
  51 #include LC_LIBDEFS_FILE
  52
  53 /*
  54  * Report incoming events to all hyphotetical event receivers
  55  */
  56 VOID ReportEvents(struct VIARHINEBase *VIARHINEDeviceBase, struct VIARHINEUnit *unit, ULONG events)
  57 {
  58     struct IOSana2Req *request, *tail, *next_request;
  59     struct List *list;
  60
  61     list = &unit->rhineu_request_ports[EVENT_QUEUE]->mp_MsgList;
  62     next_request = (APTR)list->lh_Head;
  63     tail = (APTR)&list->lh_Tail;
  64
  65     /* Go through list of event listeners. If send messages to receivers if event found */
  66     Disable();
  67     while(next_request != tail)
  68     {
  69         request = next_request;
  70         next_request = (APTR)request->ios2_Req.io_Message.mn_Node.ln_Succ;
  71
  72         if((request->ios2_WireError&events) != 0)
  73         {
  74             request->ios2_WireError = events;
  75             Remove((APTR)request);
  76             ReplyMsg((APTR)request);
  77         }
  78     }
  79     Enable();
  80
  81     return;
  82 }
  83
  84 struct TypeStats *FindTypeStats(struct VIARHINEBase *VIARHINEDeviceBase, struct VIARHINEUnit *unit,
  85                     struct MinList *list, ULONG packet_type)
  86 {
  87     struct TypeStats *stats, *tail;
  88     BOOL found = FALSE;
  89
  90     stats = (APTR)list->mlh_Head;
  91     tail = (APTR)&list->mlh_Tail;
  92
  93     while(stats != tail && !found)
  94     {
  95         if(stats->packet_type == packet_type)
  96             found = TRUE;
  97         else
  98             stats = (APTR)stats->node.mln_Succ;
  99     }
 100
 101     if(!found)
 102         stats = NULL;
 103
 104     return stats;
 105 }
 106
 107 void FlushUnit(LIBBASETYPEPTR LIBBASE, struct VIARHINEUnit *unit, UBYTE last_queue, BYTE error)
 108 {
 109     struct IORequest *request;
 110     UBYTE i;
 111     struct Opener *opener, *tail;
 112
 113 D(bug("%s unit.FlushUnit\n", unit->rhineu_name));
 114
 115     /* Abort queued operations */
 116
 117     for (i=0; i <= last_queue; i++)
 118     {
 119         while ((request = (APTR)GetMsg(unit->rhineu_request_ports[i])) != NULL)
 120         {
 121             request->io_Error = IOERR_ABORTED;
 122             ReplyMsg((struct Message *)request);
 123         }
 124     }
 125
 126     opener = (APTR)unit->rhineu_Openers.mlh_Head;
 127     tail = (APTR)&unit->rhineu_Openers.mlh_Tail;
 128
 129     /* Flush every opener's read queue */
 130
 131     while(opener != tail)
 132     {
 133         while ((request = (APTR)GetMsg(&opener->read_port)) != NULL)
 134         {
 135             request->io_Error = error;
 136             ReplyMsg((struct Message *)request);
 137         }
 138         opener = (struct Opener *)opener->node.mln_Succ;
 139     }
 140 }
 141
 142 /*
 143  * Interrupt handler called whenever RTL8139 NIC interface generates interrupt.
 144  * It's duty is to iterate throgh RX queue searching for new packets.
 145  *
 146  * Please note, that allthough multicast support could be done on interface
 147  * basis, it is done in this function as result of quick integration of both
 148  * the forcedeth driver (IFF_ALLMULTI flag) and etherling3 driver (AddressMatch
 149  * filter function).
 150  */
 151 AROS_UFH3(void, VIARHINE_RX_IntF,
 152     AROS_UFHA(struct VIARHINEUnit *,  unit, A1),
 153     AROS_UFHA(APTR,             dummy, A5),
 154     AROS_UFHA(struct ExecBase *,SysBase, A6))
 155 {
 156     AROS_USERFUNC_INIT
 157
 158     struct VIARHINEBase *VIARHINEDeviceBase = unit->rhineu_device;
 159     struct fe_priv *np = unit->rhineu_fe_priv;
 160     UWORD Flags;
 161     struct TypeStats *tracker;
 162     ULONG packet_type;
 163     struct Opener *opener, *opener_tail;
 164     struct IOSana2Req *request, *request_tail;
 165     BOOL accepted, is_orphan;
 166
 167     UBYTE *base = (UBYTE*) unit->rhineu_BaseMem;
 168
 169         int count = 0;
 170
 171 D(bug("%s: VIARHINE_RX_IntF() !!!!\n", unit->rhineu_name));
 172
 173     /* Endless loop, with break from inside */
 174     for(;;)
 175     {
 176         int i, len=0;
 177         struct eth_frame *frame;
 178
 179         if (count >= RX_RING_SIZE)
 180             break;      /* we scanned the whole ring - do not continue */
 181
 182         /* Get the in-queue number */
 183         i = np->cur_rx % RX_RING_SIZE;
 184
 185         /* Do we own the packet or the chipset? */
 186         if (np->rx_desc[i].rx_status & DescOwn)
 187         {
 188 //D(bug("%s: VIARHINE_RX_IntF: buffer %d owned by chipset\n", unit->rhineu_name, i));
 189             //goto next_pkt;     // still owned by hardware,
 190                         break;
 191         }
 192
 193                 if (np->rx_desc[i].rx_status & RxErr)
 194         {
 195 D(bug("%s: VIARHINE_RX_IntF: buffer %d has recieve error! skipping..\n", unit->rhineu_name, i));
 196             goto next_pkt;       // still owned by hardware,
 197         }
 198
 199                 if (!(np->rx_desc[i].rx_status & RxWholePkt))
 200         {
 201 D(bug("%s: VIARHINE_RX_IntF: buffer %d has recieved oversized packet! skipping..\n", unit->rhineu_name, i));
 202             goto next_pkt;       // still owned by hardware,
 203         }
 204
 205                 if (np->rx_desc[i].rx_status & RxOK)
 206         {
 207 D(bug("%s: VIARHINE_RX_IntF: packet in buffer %d was successfully recieved.\n", unit->rhineu_name, i));
 208         }
 209
 210 D(bug("%s: VIARHINE_RX_IntF: buffer %d @ %x is for us\n", unit->rhineu_name, i, np->rx_desc[i].addr));
 211         /* the packet is for us - get it */
 212
 213         /* got a valid packet - forward it to the network core */
 214         frame = (struct eth_frame *)np->rx_desc[i].addr;
 215         is_orphan = TRUE;
 216
 217         /* Dump contents of frame if DEBUG enabled */
 218 #ifdef DEBUG
 219                 {
 220                 int j;
 221                     for (j=0; j<64; j++) {
 222                         if ((j%16) == 0)
 223                             D(bug("\n%03x:", j));
 224                         D(bug(" %02x", ((unsigned char*)frame)[j]));
 225                     }
 226                     D(bug("\n"));
 227                 }
 228 #endif
 229
 230         /* Check for address validity */
 231         if(AddressFilter(LIBBASE, unit, frame->eth_packet_dest))
 232         {
 233             /* Packet is addressed to this driver */
 234                         len = (np->rx_desc[i].rx_status >> 16)-4;
 235
 236             packet_type = AROS_BE2WORD(frame->eth_packet_type);
 237 D(bug("%s: VIARHINE_RX_IntF: Packet IP accepted with type = %d, len = %d, desc_length = %d\n", unit->rhineu_name, packet_type, len, np->rx_desc[i].desc_length));
 238
 239             opener = (APTR)unit->rhineu_Openers.mlh_Head;
 240             opener_tail = (APTR)&unit->rhineu_Openers.mlh_Tail;
 241
 242             /* Offer packet to every opener */
 243             while(opener != opener_tail)
 244             {
 245                request = (APTR)opener->read_port.mp_MsgList.lh_Head;
 246                request_tail = (APTR)&opener->read_port.mp_MsgList.lh_Tail;
 247                accepted = FALSE;
 248
 249                /* Offer packet to each request until it's accepted */
 250                while((request != request_tail) && !accepted)
 251                {
 252                   if((request->ios2_PacketType == packet_type)
 253                      || ((request->ios2_PacketType <= ETH_MTU)
 254                           && (packet_type <= ETH_MTU)))
 255                   {
 256 D(bug("%s: VIARHINE_RX_IntF: copy packet for opener ..\n", unit->rhineu_name));
 257                      CopyPacket(LIBBASE, unit, request, len, packet_type, frame);
 258                      accepted = TRUE;
 259                   }
 260                   request =
 261                      (struct IOSana2Req *)request->ios2_Req.io_Message.mn_Node.ln_Succ;
 262                }
 263                if(accepted)
 264                   is_orphan = FALSE;
 265
 266                opener = (APTR)opener->node.mln_Succ;
 267             }
 268
 269             /* If packet was unwanted, give it to S2_READORPHAN request */
 270             if(is_orphan)
 271             {
 272                 unit->rhineu_stats.UnknownTypesReceived++;
 273
 274                 if(!IsMsgPortEmpty(unit->rhineu_request_ports[ADOPT_QUEUE]))
 275                 {
 276                     CopyPacket(LIBBASE, unit,
 277                         (APTR)unit->rhineu_request_ports[ADOPT_QUEUE]->
 278                         mp_MsgList.lh_Head, len, packet_type, frame);
 279 D(bug("%s: VIARHINE_RX_IntF: packet copied to orphan queue\n", unit->rhineu_name));
 280                 }
 281             }
 282                         np->rx_desc[i].desc_length =  MAX_FRAME_SIZE; //Set the buffer size back to max (before enabling it)
 283                         np->rx_desc[i].rx_status =  DescOwn;
 284
 285                         WORDOUT(base, CmdRxDemand | np->cmd);
 286
 287             /* Update remaining statistics */
 288
 289             tracker =
 290                 FindTypeStats(LIBBASE, unit, &unit->rhineu_type_trackers, packet_type);
 291
 292             if(tracker != NULL)
 293             {
 294                 tracker->stats.PacketsReceived++;
 295                 tracker->stats.BytesReceived += len;
 296             }
 297         }
 298
 299         unit->rhineu_stats.PacketsReceived++;
 300 //        ((struct rx_ring_desc *)np->ring_addr)[i].BufferStatus = AROS_WORD2LE((1 << 8)|(1 << 9)|(1 << 15)); // Mark packet as available again
 301
 302 next_pkt:
 303         np->cur_rx++;
 304                 count++;
 305     }
 306
 307     AROS_USERFUNC_EXIT
 308 }
 309
 310 /*
 311  * Interrupt generated by Cause() to push new packets into the NIC interface
 312  */
 313 AROS_UFH3(void, VIARHINE_TX_IntF,
 314     AROS_UFHA(struct VIARHINEUnit *,  unit, A1),
 315     AROS_UFHA(APTR,             dummy, A5),
 316     AROS_UFHA(struct ExecBase *,SysBase, A6))
 317 {
 318     AROS_USERFUNC_INIT
 319
 320     struct fe_priv *np = unit->rhineu_fe_priv;
 321     struct VIARHINEBase *VIARHINEDeviceBase = unit->rhineu_device;
 322     int nr, try_count=1;
 323     BOOL proceed = FALSE; /* Fails by default */
 324
 325 D(bug("%s: VIARHINE_TX_IntF()\n", unit->rhineu_name));
 326
 327     /* send packet only if there is free space on tx queue. Otherwise do nothing */
 328     if (!netif_queue_stopped(unit))
 329     {
 330         UWORD packet_size, data_size;
 331         struct IOSana2Req *request;
 332         struct Opener *opener;
 333         UBYTE *buffer;
 334         ULONG wire_error=0;
 335         BYTE error;
 336         struct MsgPort *port;
 337         struct TypeStats *tracker;
 338
 339         proceed = TRUE; /* Success by default */
 340                 UBYTE *base = (UBYTE*) unit->rhineu_BaseMem;
 341         port = unit->rhineu_request_ports[WRITE_QUEUE];
 342
 343         /* Still no error and there are packets to be sent? */
 344         while(proceed && (!IsMsgPortEmpty(port)))
 345         {
 346 rhine_nexttx:
 347                         if (try_count >= (TX_BUFFERS * 3))
 348                         {
 349 #warning "TODO: We should probably report that we couldnt send the packet here.."
 350 D(bug("%s: VIARHINE_TX_IntF: Send FAILED! no free Tx buffer(s)\n", unit->rhineu_name));
 351                                 break;
 352                         }
 353
 354             nr = np->tx_current % TX_BUFFERS;
 355                         np->tx_current++;
 356
 357                         if (np->tx_desc[nr].tx_status & DescOwn)
 358                         {
 359 D(bug("%s: VIARHINE_TX_IntF: Buffer %d in use!\n", unit->rhineu_name, nr));
 360                                 try_count++;
 361                                 goto rhine_nexttx;
 362                         }
 363
 364                    request = (APTR)port->mp_MsgList.lh_Head;
 365                    data_size = packet_size = request->ios2_DataLength;
 366
 367                    opener = (APTR)request->ios2_BufferManagement;
 368
 369                    if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
 370                    {
 371                           packet_size += ETH_PACKET_DATA;
 372                           CopyMem(request->ios2_DstAddr, &((struct eth_frame *)np->tx_desc[nr].addr)->eth_packet_dest, ETH_ADDRESSSIZE);
 373                           CopyMem(unit->rhineu_dev_addr, &((struct eth_frame *)np->tx_desc[nr].addr)->eth_packet_source, ETH_ADDRESSSIZE);
 374                           ((struct eth_frame *)np->tx_desc[nr].addr)->eth_packet_type = AROS_WORD2BE(request->ios2_PacketType);
 375
 376                           buffer = (UBYTE *)&((struct eth_frame *)np->tx_desc[nr].addr)->eth_packet_data;
 377                    }
 378                    else
 379                           buffer = (UBYTE *)np->tx_desc[nr].addr;
 380
 381                    if (!opener->tx_function(buffer, request->ios2_Data, data_size))
 382                    {
 383                           error = S2ERR_NO_RESOURCES;
 384                           wire_error = S2WERR_BUFF_ERROR;
 385                           ReportEvents(LIBBASE, unit,
 386                                  S2EVENT_ERROR | S2EVENT_SOFTWARE | S2EVENT_BUFF
 387                                  | S2EVENT_TX);
 388                    }
 389
 390                    /* Now the packet is already in TX buffer, update flags for NIC */
 391 D(bug("%s: VIARHINE_TX_IntF: packet %d  @ %x [type = %d] queued for transmission.", unit->rhineu_name, nr, np->tx_desc[nr].addr, ((struct eth_frame *)np->tx_desc[nr].addr)->eth_packet_type));
 392                           Disable();
 393                           /* DEBUG? Dump frame if so */
 394 #ifdef DEBUG
 395                           {
 396                           int j;
 397                                    for (j=0; j<64; j++) {
 398                                           if ((j%16) == 0)
 399                                                   D(bug("\n%03x:", j));
 400                                           D(bug(" %02x", ((unsigned char*)np->tx_desc[nr].addr)[j]));
 401                                  }
 402                                   D(bug("\n"));
 403                           }
 404 #endif
 405                           Enable();
 406
 407                           /* Set the ring details for the packet .. */
 408                           np->tx_desc[nr].tx_status = DescOwn;
 409                           np->tx_desc[nr].desc_length = 0x00e08000 | packet_size;
 410                           WORDOUT(base + VIAR_ChipCmd, CmdTxDemand | np->cmd);
 411 D(bug("%s: VIARHINE_TX_IntF: Packet Queued.\n", unit->rhineu_name));
 412
 413                    /* Reply packet */
 414
 415                    request->ios2_Req.io_Error = error;
 416                    request->ios2_WireError = wire_error;
 417                    Disable();
 418                    Remove((APTR)request);
 419                    Enable();
 420                    ReplyMsg((APTR)request);
 421
 422                    /* Update statistics */
 423
 424                    if(error == 0)
 425                    {
 426                            tracker = FindTypeStats(LIBBASE, unit, &unit->rhineu_type_trackers,
 427                                    request->ios2_PacketType);
 428                            if(tracker != NULL)
 429                            {
 430                                    tracker->stats.PacketsSent++;
 431                                    tracker->stats.BytesSent += packet_size;
 432                            }
 433                    }
 434         }
 435     }
 436
 437     /* Was there success? Enable incomming of new packets */
 438     if(proceed)
 439         unit->rhineu_request_ports[WRITE_QUEUE]->mp_Flags = PA_SOFTINT;
 440     else
 441         unit->rhineu_request_ports[WRITE_QUEUE]->mp_Flags = PA_IGNORE;
 442
 443     AROS_USERFUNC_EXIT
 444 }
 445
 446 /*
 447  * Handle timeouts and other strange cases
 448  */
 449 static void VIARHINE_TimeoutHandlerF(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw)
 450 {
 451     struct VIARHINEUnit *dev = (struct VIARHINEUnit *) irq->h_Data;
 452     struct timeval time;
 453     struct Device *TimerBase = dev->rhineu_TimerSlowReq->tr_node.io_Device;
 454
 455     GetSysTime(&time);
 456 //D(bug("%s: VIARHINE_TimeoutHandlerF()\n", dev->rhineu_name));
 457
 458     /*
 459      * If timeout timer is expected, and time elapsed - regenerate the
 460      * interrupt handler
 461      */
 462     if (dev->rhineu_toutNEED && (CmpTime(&time, &dev->rhineu_toutPOLL ) < 0))
 463     {
 464         dev->rhineu_toutNEED = FALSE;
 465         //Cause(&dev->rhineu_tx_end_int);
 466     }
 467 }
 468
 469 /*
 470  * The interrupt handler - schedules code execution to proper handlers
 471  */
 472 static void VIARHINE_IntHandlerF(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw)
 473 {
 474     struct VIARHINEUnit *dev = (struct VIARHINEUnit *) irq->h_Data;
 475     struct VIARHINEBase *VIARHINEDeviceBase = dev->rhineu_device;
 476     struct fe_priv *np = dev->rhineu_fe_priv;
 477     UBYTE *base = (UBYTE*) dev->rhineu_BaseMem;
 478     ULONG events;
 479     int i, link_changed, interrupt_work = 20;
 480     struct Device *TimerBase = dev->rhineu_TimerSlowReq->tr_node.io_Device;
 481     struct timeval time;
 482
 483 D(bug("%s: VIARHINE_IntHandlerF()!!!!!!!\n", dev->rhineu_name));
 484
 485     while (1)
 486     {
 487                 int status = WORDIN(base + VIAR_IntrStatus);
 488                 WORDOUT(base + VIAR_IntrStatus, status & 0xffff); // Aknowledge All Interrupt SOurces ASAP.
 489
 490                 if (!(status & (IntrRxDone | IntrRxErr | IntrRxEmpty | IntrRxOverflow| IntrRxDropped | IntrTxDone | IntrTxAbort | IntrTxUnderrun | IntrPCIErr | IntrStatsMax | IntrLinkChange | IntrMIIChange)))
 491                 {
 492 D(bug("%s: VIARHINE_IntHandlerF: No Signals for us!\n", dev->rhineu_name));
 493                         break;
 494                 }
 495
 496                 if ( status & (IntrRxErr | IntrRxDropped | IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf )) // Chipset has Reported a Recieve problem
 497                 {
 498 D(bug("%s: VIARHINE_IntHandlerF: Packet Reception Problem detected!\n", dev->rhineu_name));
 499                         WORDOUT(base, CmdRxDemand | np->cmd);
 500                         ReportEvents(LIBBASE, dev, S2EVENT_ERROR | S2EVENT_HARDWARE | S2EVENT_RX);
 501                         dev->rhineu_stats.BadData++;
 502                 }
 503                 else if ( status & IntrRxDone ) // Chipset has Recieved packet(s)
 504                 {
 505 D(bug("%s: VIARHINE_IntHandlerF: Packet Reception Attempt detected!\n", dev->rhineu_name));
 506                         Cause(&dev->rhineu_rx_int);
 507                 }
 508
 509                 if ( status & IntrTxAbort ) // Chipset has Aborted Packet Transmition
 510                 {
 511 D(bug("%s: VIARHINE_IntHandlerF: Chipset has Aborted Packet Transmition!\n", dev->rhineu_name));
 512                         WORDOUT(base, CmdTxDemand | np->cmd);
 513                         ReportEvents(LIBBASE, dev, S2EVENT_ERROR | S2EVENT_HARDWARE | S2EVENT_TX);
 514                 }
 515
 516                 if ( status & IntrTxUnderrun ) // Chipset Reports Tx Underrun
 517                 {
 518 D(bug("%s: VIARHINE_IntHandlerF: Chipset Reports Tx Underrun!\n", dev->rhineu_name));
 519                         if (np->tx_thresh < 0xe0) BYTEOUT(base + VIAR_TxConfig, np->tx_thresh += 0x20);
 520                         WORDOUT(base, CmdTxDemand | np->cmd);
 521                         ReportEvents(LIBBASE, dev, S2EVENT_ERROR | S2EVENT_HARDWARE | S2EVENT_TX);
 522                 }
 523
 524                 if ( status & IntrTxDone ) // Chipset has Sent packet(s)
 525                 {
 526 D(bug("%s: VIARHINE_IntHandlerF: Packet Transmision detected!\n", dev->rhineu_name));
 527                         dev->rhineu_stats.PacketsSent++;
 528                 }
 529
 530                 if (--interrupt_work < 0)
 531                 {
 532 D(bug("%s: VIARHINE_IntHandlerF: MAX interrupt work reached.\n", dev->rhineu_name));
 533                         break;
 534                 }
 535     }
 536
 537    return;
 538 }
 539
 540 VOID CopyPacket(struct VIARHINEBase *VIARHINEDeviceBase, struct VIARHINEUnit *unit,
 541     struct IOSana2Req *request, UWORD packet_size, UWORD packet_type,
 542     struct eth_frame *buffer)
 543 {
 544     struct Opener *opener;
 545     BOOL filtered = FALSE;
 546     UBYTE *ptr;
 547
 548 D(bug("%s: CopyPacket(packet @ %x, len = %d)\n", unit->rhineu_name, buffer, packet_size));
 549
 550     /* Set multicast and broadcast flags */
 551
 552     request->ios2_Req.io_Flags &= ~(SANA2IOF_BCAST | SANA2IOF_MCAST);
 553     if((*((ULONG *)(buffer->eth_packet_dest)) == 0xffffffff) &&
 554        (*((UWORD *)(buffer->eth_packet_dest + 4)) == 0xffff))
 555     {
 556        request->ios2_Req.io_Flags |= SANA2IOF_BCAST;
 557 D(bug("%s: CopyPacket: BROADCAST Flag set\n", unit->rhineu_name));
 558     }
 559     else if((buffer->eth_packet_dest[0] & 0x1) != 0)
 560     {
 561        request->ios2_Req.io_Flags |= SANA2IOF_MCAST;
 562 D(bug("%s: CopyPacket: MULTICAST Flag set\n", unit->rhineu_name));
 563     }
 564
 565     /* Set source and destination addresses and packet type */
 566     CopyMem(buffer->eth_packet_source, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 567     CopyMem(buffer->eth_packet_dest, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 568     request->ios2_PacketType = packet_type;
 569
 570     /* Adjust for cooked packet request */
 571
 572     if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
 573     {
 574         packet_size -= ETH_PACKET_DATA;
 575         ptr = (UBYTE*)&buffer->eth_packet_data[0];
 576     }
 577     else
 578     {
 579         ptr = (UBYTE*)buffer;
 580     }
 581
 582     request->ios2_DataLength = packet_size;
 583
 584 D(bug("%s: CopyPacket: packet @ %x (%d bytes)\n", unit->rhineu_name, ptr, packet_size));
 585
 586     /* Filter packet */
 587
 588     opener = request->ios2_BufferManagement;
 589     if((request->ios2_Req.io_Command == CMD_READ) &&
 590         (opener->filter_hook != NULL))
 591         if(!CallHookPkt(opener->filter_hook, request, ptr))
 592         {
 593 D(bug("%s: CopyPacket: packet filtered\n", unit->rhineu_name));
 594             filtered = TRUE;
 595         }
 596
 597     if(!filtered)
 598     {
 599         /* Copy packet into opener's buffer and reply packet */
 600 D(bug("%s: CopyPacket: opener recieve packet .. ", unit->rhineu_name));
 601         if(!opener->rx_function(request->ios2_Data, ptr, packet_size))
 602         {
 603 D(bug("ERROR occured!!\n"));
 604             request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 605             request->ios2_WireError = S2WERR_BUFF_ERROR;
 606             ReportEvents(LIBBASE, unit, S2EVENT_ERROR | S2EVENT_SOFTWARE | S2EVENT_BUFF | S2EVENT_RX);
 607         }
 608         else
 609         {
 610 D(bug("SUCCESS!!\n"));
 611         }
 612         Disable();
 613         Remove((APTR)request);
 614         Enable();
 615         ReplyMsg((APTR)request);
 616 D(bug("%s: CopyPacket: opener notified.\n", unit->rhineu_name));
 617     }
 618 }
 619
 620 BOOL AddressFilter(struct VIARHINEBase *VIARHINEDeviceBase, struct VIARHINEUnit *unit, UBYTE *address)
 621 {
 622     struct AddressRange *range, *tail;
 623     BOOL accept = TRUE;
 624     ULONG address_left;
 625     UWORD address_right;
 626
 627     /* Check whether address is unicast/broadcast or multicast */
 628
 629     address_left = AROS_BE2LONG(*((ULONG *)address));
 630     address_right = AROS_BE2WORD(*((UWORD *)(address + 4)));
 631
 632     if((address_left & 0x01000000) != 0 &&
 633         !(address_left == 0xffffffff && address_right == 0xffff))
 634     {
 635         /* Check if this multicast address is wanted */
 636
 637         range = (APTR)unit->rhineu_multicast_ranges.mlh_Head;
 638         tail = (APTR)&unit->rhineu_multicast_ranges.mlh_Tail;
 639         accept = FALSE;
 640
 641         while((range != tail) && !accept)
 642         {
 643             if((address_left > range->lower_bound_left ||
 644                 (address_left == range->lower_bound_left &&
 645                 address_right >= range->lower_bound_right)) &&
 646                 (address_left < range->upper_bound_left ||
 647                 (address_left == range->upper_bound_left &&
 648                 address_right <= range->upper_bound_right)))
 649                 accept = TRUE;
 650             range = (APTR)range->node.mln_Succ;
 651         }
 652
 653         if(!accept)
 654             unit->rhineu_special_stats[S2SS_ETHERNET_BADMULTICAST & 0xffff]++;
 655     }
 656     return accept;
 657 }
 658
 659 /*
 660  * Unit process
 661  */
 662 AROS_UFH3(void, VIARHINE_Schedular,
 663     AROS_UFHA(STRPTR,              argPtr, A0),
 664     AROS_UFHA(ULONG,               argSize, D0),
 665     AROS_UFHA(struct ExecBase *,   SysBase, A6))
 666 {
 667     AROS_USERFUNC_INIT
 668
 669     struct VIARHINEUnit *dev = FindTask(NULL)->tc_UserData;
 670     LIBBASETYPEPTR LIBBASE = dev->rhineu_device;
 671     APTR BattClockBase;
 672     struct MsgPort *reply_port, *input;
 673
 674 D(bug("%s VIARHINE_Schedular()\n", dev->rhineu_name));
 675 D(bug("%s VIARHINE_Schedular: Setting device up\n", dev->rhineu_name));
 676
 677     reply_port = CreateMsgPort();
 678     input = CreateMsgPort();
 679
 680     dev->rhineu_input_port = input;
 681
 682     /* Randomize the generator with current time */
 683     BattClockBase =  OpenResource("battclock.resource");
 684     srandom(ReadBattClock());
 685
 686     dev->rhineu_TimerSlowPort = CreateMsgPort();
 687
 688     if (dev->rhineu_TimerSlowPort)
 689     {
 690         dev->rhineu_TimerSlowReq = (struct timerequest *)
 691             CreateIORequest((struct MsgPort *)dev->rhineu_TimerSlowPort, sizeof(struct timerequest));
 692
 693         if (dev->rhineu_TimerSlowReq)
 694         {
 695             if (!OpenDevice("timer.device", UNIT_VBLANK,
 696                 (struct IORequest *)dev->rhineu_TimerSlowReq, 0))
 697             {
 698                 struct Message *msg = AllocVec(sizeof(struct Message), MEMF_PUBLIC|MEMF_CLEAR);
 699                 ULONG sigset;
 700
 701 D(bug("%s VIARHINE_Schedular: Got VBLANK unit of timer.device\n", dev->rhineu_name));
 702
 703                 dev->initialize(dev);
 704
 705                 msg->mn_ReplyPort = reply_port;
 706                 msg->mn_Length = sizeof(struct Message);
 707
 708 D(bug("%s VIARHINE_Schedular: Setup complete. Sending handshake\n", dev->rhineu_name));
 709                 PutMsg(LIBBASE->rhineb_syncport, msg);
 710                 WaitPort(reply_port);
 711                 GetMsg(reply_port);
 712
 713                 FreeVec(msg);
 714
 715 D(bug("%s VIARHINE_Schedular: entering forever loop ... \n", dev->rhineu_name));
 716
 717                 dev->rhineu_signal_0 = AllocSignal(-1);
 718                 dev->rhineu_signal_1 = AllocSignal(-1);
 719                 dev->rhineu_signal_2 = AllocSignal(-1);
 720                 dev->rhineu_signal_3 = AllocSignal(-1);
 721
 722                 sigset = 1 << input->mp_SigBit  |
 723                          1 << dev->rhineu_signal_0  |
 724                          1 << dev->rhineu_signal_1  |
 725                          1 << dev->rhineu_signal_2  |
 726                          1 << dev->rhineu_signal_3;
 727                 for(;;)
 728                 {
 729                     ULONG recvd = Wait(sigset);
 730                     if (recvd & dev->rhineu_signal_0)
 731                     {
 732                         /*
 733                          * Shutdown process. Driver should close everything
 734                          * already and waits for our process to complete. Free
 735                          * memory allocared here and kindly return.
 736                          */
 737                         dev->deinitialize(dev);
 738                         CloseDevice((struct IORequest *)dev->rhineu_TimerSlowReq);
 739                         DeleteIORequest((struct IORequest *)dev->rhineu_TimerSlowReq);
 740                         DeleteMsgPort(dev->rhineu_TimerSlowPort);
 741                         DeleteMsgPort(input);
 742                         DeleteMsgPort(reply_port);
 743
 744 D(bug("%s VIARHINE_Schedular: Process shutdown.\n", dev->rhineu_name));
 745                         return;
 746                     }
 747                     else if (recvd & (1 << input->mp_SigBit))
 748                     {
 749                         struct IOSana2Req *io;
 750
 751                         /* Handle incoming transactions */
 752                         while ((io = (struct IOSana2Req *)GetMsg(input))!= NULL);
 753                         {
 754 D(bug("%s VIARHINE_Schedular: Handle incomming transaction.\n", dev->rhineu_name));
 755                             ObtainSemaphore(&dev->rhineu_unit_lock);
 756                             handle_request(LIBBASE, io);
 757                         }
 758                     }
 759                     else
 760                     {
 761 D(bug("%s VIARHINE_Schedular: Handle incomming signal.\n", dev->rhineu_name));
 762                         /* Handle incoming signals */
 763                     }
 764                 }
 765             }
 766         }
 767     }
 768
 769     AROS_USERFUNC_EXIT
 770 }
 771
 772 /*
 773  * Create new RTL8139 ethernet device unit
 774  */
 775 struct VIARHINEUnit *CreateUnit(struct VIARHINEBase *VIARHINEDeviceBase, OOP_Object *pciDevice, ULONG CardCapabilities, char * CardName)
 776 {
 777     BOOL success = TRUE;
 778     int i;
 779
 780 D(bug("[VIA-RHINE] CreateUnit()\n"));
 781
 782     struct VIARHINEUnit *unit = AllocMem(sizeof(struct VIARHINEUnit), MEMF_PUBLIC | MEMF_CLEAR);
 783
 784     if (unit != NULL)
 785     {
 786         IPTR        DeviceID, base, len;
 787         OOP_Object  *driver;
 788
 789 D(bug("[VIA-RHINE] CreateUnit: Unit allocated @ %x\n", unit));
 790
 791         OOP_GetAttr(pciDevice, aHidd_PCIDevice_ProductID, &DeviceID);
 792         OOP_GetAttr(pciDevice, aHidd_PCIDevice_Driver, (APTR)&driver);
 793
 794         unit->rhineu_cardname = CardName;
 795         unit->rhineu_chipcapabilities = CardCapabilities;
 796         unit->rhineu_device     = VIARHINEDeviceBase;
 797         unit->rhineu_DeviceID   = DeviceID;
 798         unit->rhineu_mtu        = ETH_MTU;
 799         unit->rhineu_PCIDevice  = pciDevice;
 800         unit->rhineu_PCIDriver  = driver;
 801                 unit->rhineu_UnitNum = VIARHINEDeviceBase->rhineb_UnitCount++;
 802
 803                 int unitname_len = 12 + ((unit->rhineu_UnitNum/10)+1);
 804
 805                 unit->rhineu_name = AllocVec(unitname_len, MEMF_CLEAR|MEMF_PUBLIC);
 806 D(bug("[VIA-RHINE] CreateUnit: Allocated %d bytes for Unit %d's Name @ %x\n", unitname_len, unit->rhineu_UnitNum, unit->rhineu_name));
 807                 sprintf(unit->rhineu_name, "[VIARHINE.%d]", unit->rhineu_UnitNum);
 808
 809         InitSemaphore(&unit->rhineu_unit_lock);
 810         NEWLIST(&unit->rhineu_Openers);
 811         NEWLIST(&unit->rhineu_multicast_ranges);
 812         NEWLIST(&unit->rhineu_type_trackers);
 813
 814         OOP_GetAttr(pciDevice, aHidd_PCIDevice_INTLine, &unit->rhineu_IRQ);
 815         OOP_GetAttr(pciDevice, aHidd_PCIDevice_Base1,   &unit->rhineu_BaseIO);
 816         OOP_GetAttr(pciDevice, aHidd_PCIDevice_Base0,   &base);
 817         OOP_GetAttr(pciDevice, aHidd_PCIDevice_Size0,   &len);
 818
 819 D(bug("%s CreateUnit:   INT:%d, base1:%x, base0:%x, size0:%d\n", unit->rhineu_name,
 820                                                                                                                                                                                                            unit->rhineu_IRQ, unit->rhineu_BaseIO,
 821                                                                                                                                                                                                            base, len));
 822
 823         unit->rhineu_BaseMem = (IPTR)HIDD_PCIDriver_MapPCI(driver, (APTR)base, len);
 824         unit->rhineu_SizeMem = len;
 825
 826         if (unit->rhineu_BaseMem)
 827         {
 828             struct TagItem attrs[] = {
 829                 { aHidd_PCIDevice_isIO,     TRUE },
 830                 { aHidd_PCIDevice_isMEM,    TRUE },
 831                 { aHidd_PCIDevice_isMaster, TRUE },
 832                 { TAG_DONE,                 0    },
 833             };
 834             OOP_SetAttrs(pciDevice, (struct TagItem *)&attrs);
 835
 836 D(bug("%s CreateUnit:   PCI_BaseMem @ %x\n", unit->rhineu_name, unit->rhineu_BaseMem));
 837
 838             unit->rhineu_fe_priv =      HIDD_PCIDriver_AllocPCIMem(
 839                         unit->rhineu_PCIDriver,
 840                         sizeof(struct fe_priv));
 841
 842             viarhinenic_get_functions(unit);
 843
 844             if (unit->rhineu_fe_priv)
 845             {
 846 D(bug("%s CreateUnit:   NIC Private Data Area @ %x, start @ %x\n", unit->rhineu_name, unit->rhineu_fe_priv));
 847
 848                 unit->rhineu_fe_priv->pci_dev = unit;
 849                 InitSemaphore(&unit->rhineu_fe_priv->lock);
 850
 851                 unit->rhineu_irqhandler = AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_PUBLIC|MEMF_CLEAR);
 852                 unit->rhineu_touthandler = AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_PUBLIC|MEMF_CLEAR);
 853
 854                 if (unit->rhineu_irqhandler && unit->rhineu_touthandler)
 855                 {
 856                     struct Message *msg;
 857
 858                     unit->rhineu_irqhandler->h_Node.ln_Pri = 100;
 859                     unit->rhineu_irqhandler->h_Node.ln_Name = LIBBASE->rhineb_Device.dd_Library.lib_Node.ln_Name;
 860                     unit->rhineu_irqhandler->h_Code = VIARHINE_IntHandlerF;
 861                     unit->rhineu_irqhandler->h_Data = unit;
 862
 863                     unit->rhineu_touthandler->h_Node.ln_Pri = 100;
 864                     unit->rhineu_touthandler->h_Node.ln_Name = LIBBASE->rhineb_Device.dd_Library.lib_Node.ln_Name;
 865                     unit->rhineu_touthandler->h_Code = VIARHINE_TimeoutHandlerF;
 866                     unit->rhineu_touthandler->h_Data = unit;
 867
 868                     unit->rhineu_rx_int.is_Node.ln_Name = unit->rhineu_name;
 869                     unit->rhineu_rx_int.is_Code = VIARHINE_RX_IntF;
 870                     unit->rhineu_rx_int.is_Data = unit;
 871
 872                     unit->rhineu_tx_int.is_Node.ln_Name = unit->rhineu_name;
 873                     unit->rhineu_tx_int.is_Code = VIARHINE_TX_IntF;
 874                     unit->rhineu_tx_int.is_Data = unit;
 875
 876                     for (i=0; i < REQUEST_QUEUE_COUNT; i++)
 877                     {
 878                         struct MsgPort *port = AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC | MEMF_CLEAR);
 879                         unit->rhineu_request_ports[i] = port;
 880
 881                         if (port == NULL) success = FALSE;
 882
 883                         if (success)
 884                         {
 885                             NEWLIST(&port->mp_MsgList);
 886                             port->mp_Flags = PA_IGNORE;
 887                             port->mp_SigTask = &unit->rhineu_tx_int;
 888                         }
 889                     }
 890
 891                     unit->rhineu_request_ports[WRITE_QUEUE]->mp_Flags = PA_SOFTINT;
 892
 893                     if (success)
 894                     {
 895                         LIBBASE->rhineb_syncport = CreateMsgPort();
 896
 897                         unit->rhineu_Process = CreateNewProcTags(
 898                                                 NP_Entry, (IPTR)VIARHINE_Schedular,
 899                                                 NP_Name, VIARHINE_TASK_NAME,
 900                                                 NP_Priority, 0,
 901                                                 NP_UserData, (IPTR)unit,
 902                                                 NP_StackSize, 140960,
 903                                                 TAG_DONE);
 904
 905                         WaitPort(LIBBASE->rhineb_syncport);
 906                         msg = GetMsg(LIBBASE->rhineb_syncport);
 907                         ReplyMsg(msg);
 908                         DeleteMsgPort(LIBBASE->rhineb_syncport);
 909
 910 D(bug("[VIA-RHINE] Unit up and running\n"));
 911
 912                         return unit;
 913                     }
 914                     else
 915                     {
 916 D(bug("%s: ERRORS occured during Device setup - ABORTING\n", unit->rhineu_name));
 917                     }
 918                 }
 919             }
 920         }
 921         else
 922 D(bug("[VIA-RHINE] PANIC! Couldn't get MMIO area. Aborting\n"));
 923     }
 924     DeleteUnit(VIARHINEDeviceBase, unit);
 925     return NULL;
 926 }
 927
 928 /*
 929  * DeleteUnit - removes selected unit. Frees all resources and structures.
 930  *
 931  * The caller should be sure, that given unit is really ready to be freed.
 932  */
 933
 934 void DeleteUnit(struct VIARHINEBase *VIARHINEDeviceBase, struct VIARHINEUnit *Unit)
 935 {
 936     int i;
 937     if (Unit)
 938     {
 939         if (Unit->rhineu_Process)
 940         {
 941             Signal(&Unit->rhineu_Process->pr_Task, Unit->rhineu_signal_0);
 942         }
 943
 944         for (i=0; i < REQUEST_QUEUE_COUNT; i++)
 945         {
 946             if (Unit->rhineu_request_ports[i] != NULL)
 947                 FreeMem(Unit->rhineu_request_ports[i],  sizeof(struct MsgPort));
 948
 949             Unit->rhineu_request_ports[i] = NULL;
 950         }
 951
 952         if (Unit->rhineu_irqhandler)
 953         {
 954             FreeMem(Unit->rhineu_irqhandler, sizeof(HIDDT_IRQ_Handler));
 955             LIBBASE->rhineb_irq = NULL;
 956         }
 957
 958         if (Unit->rhineu_fe_priv)
 959         {
 960             FreeMem(Unit->rhineu_fe_priv, sizeof(struct fe_priv));
 961             Unit->rhineu_fe_priv = NULL;
 962         }
 963
 964         if (Unit->rhineu_BaseMem)
 965         {
 966             HIDD_PCIDriver_UnmapPCI(Unit->rhineu_PCIDriver,
 967                                     (APTR)Unit->rhineu_BaseMem,
 968                                     Unit->rhineu_SizeMem);
 969         }
 970
 971         FreeMem(Unit, sizeof(struct VIARHINEUnit));
 972     }
 973 }
 974
 975 static struct AddressRange *FindMulticastRange(LIBBASETYPEPTR LIBBASE, struct VIARHINEUnit *unit,
 976    ULONG lower_bound_left, UWORD lower_bound_right, ULONG upper_bound_left, UWORD upper_bound_right)
 977 {
 978     struct AddressRange *range, *tail;
 979     BOOL found = FALSE;
 980
 981     range = (APTR)unit->rhineu_multicast_ranges.mlh_Head;
 982     tail = (APTR)&unit->rhineu_multicast_ranges.mlh_Tail;
 983
 984     while((range != tail) && !found)
 985     {
 986         if((lower_bound_left == range->lower_bound_left) &&
 987             (lower_bound_right == range->lower_bound_right) &&
 988             (upper_bound_left == range->upper_bound_left) &&
 989             (upper_bound_right == range->upper_bound_right))
 990             found = TRUE;
 991         else
 992             range = (APTR)range->node.mln_Succ;
 993     }
 994
 995     if(!found)
 996         range = NULL;
 997
 998     return range;
 999 }
1000
1001 BOOL AddMulticastRange(LIBBASETYPEPTR LIBBASE, struct VIARHINEUnit *unit, const UBYTE *lower_bound,
1002    const UBYTE *upper_bound)
1003 {
1004     struct AddressRange *range;
1005     ULONG lower_bound_left, upper_bound_left;
1006     UWORD lower_bound_right, upper_bound_right;
1007
1008     lower_bound_left = AROS_BE2LONG(*((ULONG *)lower_bound));
1009     lower_bound_right = AROS_BE2WORD(*((UWORD *)(lower_bound + 4)));
1010     upper_bound_left = AROS_BE2LONG(*((ULONG *)upper_bound));
1011     upper_bound_right = AROS_BE2WORD(*((UWORD *)(upper_bound + 4)));
1012
1013     range = FindMulticastRange(LIBBASE, unit, lower_bound_left, lower_bound_right,
1014         upper_bound_left, upper_bound_right);
1015
1016     if(range != NULL)
1017         range->add_count++;
1018     else
1019     {
1020         range = AllocMem(sizeof(struct AddressRange), MEMF_PUBLIC);
1021         if(range != NULL)
1022         {
1023             range->lower_bound_left = lower_bound_left;
1024             range->lower_bound_right = lower_bound_right;
1025             range->upper_bound_left = upper_bound_left;
1026             range->upper_bound_right = upper_bound_right;
1027             range->add_count = 1;
1028
1029             Disable();
1030             AddTail((APTR)&unit->rhineu_multicast_ranges, (APTR)range);
1031             Enable();
1032
1033             if (unit->rhineu_range_count++ == 0)
1034             {
1035                 unit->rhineu_flags |= IFF_ALLMULTI;
1036                 unit->set_multicast(unit);
1037             }
1038         }
1039     }
1040
1041     return range != NULL;
1042 }
1043
1044 BOOL RemMulticastRange(LIBBASETYPEPTR LIBBASE, struct VIARHINEUnit *unit, const UBYTE *lower_bound, const UBYTE *upper_bound)
1045 {
1046     struct AddressRange *range;
1047     ULONG lower_bound_left, upper_bound_left;
1048     UWORD lower_bound_right, upper_bound_right;
1049
1050     lower_bound_left = AROS_BE2LONG(*((ULONG *)lower_bound));
1051     lower_bound_right = AROS_BE2WORD(*((UWORD *)(lower_bound + 4)));
1052     upper_bound_left = AROS_BE2LONG(*((ULONG *)upper_bound));
1053     upper_bound_right = AROS_BE2WORD(*((UWORD *)(upper_bound + 4)));
1054
1055     range = FindMulticastRange(LIBBASE, unit, lower_bound_left, lower_bound_right,
1056         upper_bound_left, upper_bound_right);
1057
1058     if(range != NULL)
1059     {
1060         if(--range->add_count == 0)
1061         {
1062             Disable();
1063             Remove((APTR)range);
1064             Enable();
1065             FreeMem(range, sizeof(struct AddressRange));
1066
1067             if (--unit->rhineu_range_count == 0)
1068             {
1069                 unit->rhineu_flags &= ~IFF_ALLMULTI;
1070                 unit->set_multicast(unit);
1071             }
1072         }
1073     }
1074     return range != NULL;
1075 }
1076