workbench/devs/networks/fec/fec_handler.c

   1 /*
   2  * fec_handler.c
   3  *
   4  *  Created on: May 18, 2009
   5  *      Author: misc
   6  */
   7
   8 #define DEBUG 1
   9 #include <aros/debug.h>
  10 #include <aros/libcall.h>
  11 #include <aros/asmcall.h>
  12 #include <aros/symbolsets.h>
  13
  14 #include <exec/memory.h>
  15 #include <exec/errors.h>
  16
  17 #include <devices/newstyle.h>
  18 #include <devices/sana2.h>
  19 #include <devices/sana2specialstats.h>
  20
  21 #include <proto/openfirmware.h>
  22 #include <proto/exec.h>
  23 #include <proto/dos.h>
  24
  25 #include <inttypes.h>
  26
  27 #include "fec.h"
  28
  29 #define KNOWN_EVENTS \
  30     (S2EVENT_ERROR | S2EVENT_TX | S2EVENT_RX | S2EVENT_ONLINE \
  31     | S2EVENT_OFFLINE | S2EVENT_BUFF | S2EVENT_HARDWARE | S2EVENT_SOFTWARE)
  32
  33 static BOOL CmdInvalid(struct FECBase *FECBase, struct IOSana2Req *request);
  34 static BOOL CmdRead(struct FECBase *FECBase, struct IOSana2Req *request);
  35 static BOOL CmdWrite(struct FECBase *FECBase, struct IOSana2Req *request);
  36 static BOOL CmdFlush(struct FECBase *FECBase, struct IORequest *request);
  37 static BOOL CmdS2DeviceQuery(struct FECBase *FECBase, struct IOSana2Req *request);
  38 static BOOL CmdGetStationAddress(struct FECBase *FECBase, struct IOSana2Req *request);
  39 static BOOL CmdConfigInterface(struct FECBase *FECBase, struct IOSana2Req *request);
  40 static BOOL CmdBroadcast(struct FECBase *FECBase, struct IOSana2Req *request);
  41 static BOOL CmdTrackType(struct FECBase *FECBase, struct IOSana2Req *request);
  42 static BOOL CmdUntrackType(struct FECBase *FECBase, struct IOSana2Req *request);
  43 static BOOL CmdGetTypeStats(struct FECBase *FECBase, struct IOSana2Req *request);
  44 static BOOL CmdGetGlobalStats(struct FECBase *FECBase, struct IOSana2Req *request);
  45 static BOOL CmdDeviceQuery(struct FECBase *FECBase, struct IOStdReq *request);
  46 static BOOL CmdOnEvent(struct FECBase *FECBase, struct IOSana2Req *request);
  47 static BOOL CmdReadOrphan(struct FECBase *FECBase, struct IOSana2Req *request);
  48 static BOOL CmdOnline(struct FECBase *FECBase, struct IOSana2Req *request);
  49 static BOOL CmdOffline(struct FECBase *FECBase, struct IOSana2Req *request);
  50 static BOOL CmdAddMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request);
  51 static BOOL CmdDelMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request);
  52
  53 static const uint16_t supported_commands[] =
  54 {
  55     CMD_READ,
  56     CMD_WRITE,
  57     CMD_FLUSH,
  58     S2_DEVICEQUERY,
  59     S2_GETSTATIONADDRESS,
  60     S2_CONFIGINTERFACE,
  61     S2_ADDMULTICASTADDRESS,
  62     S2_DELMULTICASTADDRESS,
  63     S2_MULTICAST,
  64     S2_BROADCAST,
  65     S2_TRACKTYPE,
  66     S2_UNTRACKTYPE,
  67     S2_GETTYPESTATS,
  68 //    S2_GETSPECIALSTATS,
  69     S2_GETGLOBALSTATS,
  70     S2_ONEVENT,
  71     S2_READORPHAN,
  72     S2_ONLINE,
  73     S2_OFFLINE,
  74     NSCMD_DEVICEQUERY,
  75     S2_ADDMULTICASTADDRESSES,
  76     S2_DELMULTICASTADDRESSES,
  77     0
  78 };
  79
  80 void handle_request(struct FECBase *FECBase, struct IOSana2Req *request)
  81 {
  82         D(bug("[FEC] handle_request\n"));
  83
  84         BOOL complete;
  85
  86         switch(request->ios2_Req.io_Command)
  87         {
  88                 case CMD_READ:
  89                         complete = CmdRead(FECBase, request);
  90                         break;
  91
  92                 case CMD_WRITE:
  93                 case S2_MULTICAST:
  94                         complete = CmdWrite(FECBase, request);
  95                         break;
  96
  97         case CMD_FLUSH:
  98             complete = CmdFlush(FECBase, (struct IORequest *)request);
  99             break;
 100
 101         case S2_DEVICEQUERY:
 102             complete = CmdS2DeviceQuery(FECBase, request);
 103             break;
 104
 105         case S2_GETSTATIONADDRESS:
 106             complete = CmdGetStationAddress(FECBase, request);
 107             break;
 108
 109         case S2_CONFIGINTERFACE:
 110             complete = CmdConfigInterface(FECBase, request);
 111             break;
 112
 113         case S2_BROADCAST:
 114             complete = CmdBroadcast(FECBase, request);
 115             break;
 116
 117         case S2_TRACKTYPE:
 118             complete = CmdTrackType(FECBase, request);
 119             break;
 120
 121         case S2_UNTRACKTYPE:
 122             complete = CmdUntrackType(FECBase, request);
 123             break;
 124
 125         case S2_GETTYPESTATS:
 126             complete = CmdGetTypeStats(FECBase, request);
 127             break;
 128
 129         case S2_GETGLOBALSTATS:
 130                 complete = CmdGetGlobalStats(FECBase, request);
 131                 break;
 132
 133         case S2_ONEVENT:
 134                 complete = CmdOnEvent(FECBase, request);
 135                 break;
 136
 137         case S2_READORPHAN:
 138                 complete = CmdReadOrphan(FECBase, request);
 139                 break;
 140
 141         case S2_ONLINE:
 142                 complete = CmdOnline(FECBase, request);
 143                 break;
 144
 145         case S2_OFFLINE:
 146                 complete = CmdOffline(FECBase, request);
 147                 break;
 148
 149         case S2_ADDMULTICASTADDRESS:
 150         case S2_ADDMULTICASTADDRESSES:
 151                 complete = CmdAddMulticastAddresses(FECBase, request);
 152                 break;
 153
 154         case S2_DELMULTICASTADDRESS:
 155         case S2_DELMULTICASTADDRESSES:
 156                 complete = CmdDelMulticastAddresses(FECBase, request);
 157                 break;
 158
 159         case NSCMD_DEVICEQUERY:
 160                 complete = CmdDeviceQuery(FECBase, (struct IOStdReq *)request);
 161                 break;
 162
 163                 default:
 164                         complete = CmdInvalid(FECBase, request);
 165         }
 166
 167         if(complete && (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 168                 ReplyMsg((APTR)request);
 169
 170         ReleaseSemaphore(&((struct FECUnit *)request->ios2_Req.io_Unit)->feu_Lock);
 171 }
 172
 173
 174 static BOOL CmdInvalid(struct FECBase *FECBase, struct IOSana2Req *request)
 175 {
 176     request->ios2_Req.io_Error = IOERR_NOCMD;
 177     request->ios2_WireError = S2WERR_GENERIC_ERROR;
 178
 179     return TRUE;
 180 }
 181
 182 static BOOL CmdRead(struct FECBase *FECBase, struct IOSana2Req *request)
 183 {
 184     struct FECUnit *unit;
 185     struct Opener *opener;
 186     BOOL complete = FALSE;
 187
 188     unit = (APTR)request->ios2_Req.io_Unit;
 189
 190 D(bug("[FEC] S2CmdRead()\n"));
 191
 192     if((unit->feu_Flags & IFF_UP) != 0)
 193     {
 194         opener = request->ios2_BufferManagement;
 195         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 196         PutMsg(&opener->read_port, (struct Message *)request);
 197     }
 198     else
 199     {
 200         request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 201         request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 202         complete = TRUE;
 203     }
 204
 205     /* Return */
 206
 207     return complete;
 208 }
 209
 210 static BOOL CmdWrite(struct FECBase *FECBase, struct IOSana2Req *request)
 211 {
 212     struct FECUnit *unit;
 213     BYTE error = 0;
 214     ULONG wire_error = S2WERR_GENERIC_ERROR;
 215     BOOL complete = FALSE;
 216
 217     /* Check request is valid */
 218
 219     unit = (APTR)request->ios2_Req.io_Unit;
 220
 221     D(bug("[FEC] S2CmdWrite()\n"));
 222
 223     if((unit->feu_Flags & IFF_UP) == 0)
 224     {
 225         error = S2ERR_OUTOFSERVICE;
 226         wire_error = S2WERR_UNIT_OFFLINE;
 227     }
 228     else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 229             ((request->ios2_DstAddr[0] & 0x1) == 0))
 230     {
 231         error = S2ERR_BAD_ADDRESS;
 232         wire_error = S2WERR_BAD_MULTICAST;
 233     }
 234
 235     /* Queue request for sending */
 236
 237     if(error == 0) {
 238         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 239         PutMsg(unit->feu_RequestPorts[WRITE_QUEUE], (APTR)request);
 240     }
 241     else
 242     {
 243         request->ios2_Req.io_Error = error;
 244         request->ios2_WireError = wire_error;
 245         complete = TRUE;
 246     }
 247
 248     /* Return */
 249     return complete;
 250 }
 251
 252 static BOOL CmdFlush(struct FECBase *FECBase, struct IORequest *request)
 253 {
 254 #warning TODO: Implement CmdFlush!!!!!!!!!
 255     //    FlushUnit(LIBBASE, (APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED);
 256     return TRUE;
 257 }
 258
 259 static BOOL CmdS2DeviceQuery(struct FECBase *FECBase, struct IOSana2Req *request)
 260 {
 261     struct FECUnit *unit = (APTR)request->ios2_Req.io_Unit;
 262     //struct fe_priv *np = unit->pcnu_fe_priv;
 263     struct Sana2DeviceQuery *info;
 264     ULONG size_available, size;
 265
 266 D(bug("[FEC] S2CmdDeviceQuery()\n"));
 267
 268     /* Copy device info */
 269
 270     info = request->ios2_StatData;
 271     size = size_available = info->SizeAvailable;
 272     if(size > sizeof(struct Sana2DeviceQuery))
 273         size = sizeof(struct Sana2DeviceQuery);
 274
 275     CopyMem(&FECBase->feb_Sana2Info, info, size);
 276
 277     info->BPS = unit->feu_speed * 1000000;
 278     info->MTU = ETH_MTU;
 279     info->HardwareType = S2WireType_Ethernet;
 280     info->SizeAvailable = size_available;
 281     info->SizeSupplied = size;
 282
 283     /* Return */
 284
 285     return TRUE;
 286 }
 287
 288 static BOOL CmdGetStationAddress(struct FECBase *FECBase, struct IOSana2Req *request)
 289 {
 290     struct FECUnit *unit;
 291
 292     /* Copy addresses */
 293
 294     unit = (APTR)request->ios2_Req.io_Unit;
 295
 296 D(bug("[FEC] S2CmdGetStationAddress()\n"));
 297
 298     CopyMem(unit->feu_DevAddr, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 299     CopyMem(unit->feu_OrgAddr, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 300
 301     /* Return */
 302
 303     return TRUE;
 304 }
 305
 306 static BOOL CmdConfigInterface(struct FECBase *FECBase, struct IOSana2Req *request)
 307 {
 308     struct FECUnit *unit;
 309
 310     /* Configure adapter */
 311
 312     unit = (APTR)request->ios2_Req.io_Unit;
 313
 314 D(bug("[FEC] S2CmdConfigInterface()\n"));
 315
 316     if((unit->feu_Flags & IFF_CONFIGURED) == 0)
 317     {
 318         CopyMem(request->ios2_SrcAddr, unit->feu_DevAddr, ETH_ADDRESSSIZE);
 319         unit->set_mac_address(unit);
 320         unit->feu_Flags |= IFF_CONFIGURED;
 321     }
 322     else
 323     {
 324         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 325         request->ios2_WireError = S2WERR_IS_CONFIGURED;
 326     }
 327
 328     /* Return */
 329
 330     return TRUE;
 331 }
 332
 333 static BOOL CmdBroadcast(struct FECBase *FECBase, struct IOSana2Req *request)
 334 {
 335     /* Fill in the broadcast address as destination */
 336
 337     *((ULONG *)request->ios2_DstAddr) = 0xffffffff;
 338     *((UWORD *)(request->ios2_DstAddr + 4)) = 0xffff;
 339
 340     /* Queue the write as normal */
 341
 342     return CmdWrite(FECBase, request);
 343 }
 344
 345 static BOOL CmdTrackType(struct FECBase *FECBase, struct IOSana2Req *request)
 346 {
 347     struct FECUnit *unit;
 348     struct Opener *opener;
 349     ULONG packet_type, wire_error=0;
 350     struct TypeTracker *tracker;
 351     struct TypeStats *initial_stats;
 352     BYTE error = 0;
 353
 354     unit = (APTR)request->ios2_Req.io_Unit;
 355
 356     D(bug("[FEC] S2CmdTrackType(%d)\n", request->ios2_PacketType));
 357
 358     packet_type = request->ios2_PacketType;
 359
 360     /* Get global tracker */
 361     tracker = (struct TypeTracker *)
 362         FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 363
 364     if(tracker != NULL)
 365         tracker->user_count++;
 366     else
 367     {
 368         tracker =
 369             AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC|MEMF_CLEAR);
 370         if(tracker != NULL)
 371         {
 372             tracker->packet_type = packet_type;
 373             tracker->user_count = 1;
 374
 375             Disable();
 376             AddTail((APTR)&unit->feu_TypeTrackers, (APTR)tracker);
 377             Enable();
 378         }
 379    }
 380
 381     /* Store initial figures for this opener */
 382
 383     opener = request->ios2_BufferManagement;
 384     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 385     if(initial_stats != NULL)
 386     {
 387         error = S2ERR_BAD_STATE;
 388         wire_error = S2WERR_ALREADY_TRACKED;
 389     }
 390
 391     if(error == 0)
 392     {
 393         initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 394         if(initial_stats == NULL)
 395         {
 396             error = S2ERR_NO_RESOURCES;
 397             wire_error = S2WERR_GENERIC_ERROR;
 398         }
 399     }
 400
 401     if(error == 0)
 402     {
 403         CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 404         AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 405     }
 406
 407     /* Return */
 408
 409     request->ios2_Req.io_Error = error;
 410     request->ios2_WireError = wire_error;
 411     return TRUE;
 412 }
 413
 414 static BOOL CmdUntrackType(struct FECBase *FECBase, struct IOSana2Req *request)
 415 {
 416     struct FECUnit *unit;
 417     struct Opener *opener;
 418     ULONG packet_type;
 419     struct TypeTracker *tracker;
 420     struct TypeStats *initial_stats;
 421
 422     unit = (APTR)request->ios2_Req.io_Unit;
 423
 424     D(bug("[FEC] S2CmdUntrackType()\n"));
 425
 426     packet_type = request->ios2_PacketType;
 427
 428     /* Get global tracker and initial figures */
 429
 430     tracker = (struct TypeTracker *)
 431         FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 432     opener = request->ios2_BufferManagement;
 433     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 434
 435     /* Decrement tracker usage and free unused structures */
 436
 437     if(initial_stats != NULL)
 438     {
 439         if((--tracker->user_count) == 0)
 440         {
 441             Disable();
 442             Remove((APTR)tracker);
 443             Enable();
 444             FreeMem(tracker, sizeof(struct TypeTracker));
 445         }
 446
 447         Remove((APTR)initial_stats);
 448         FreeMem(initial_stats, sizeof(struct TypeStats));
 449     }
 450     else
 451     {
 452         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 453         request->ios2_WireError = S2WERR_NOT_TRACKED;
 454     }
 455
 456     /* Return */
 457
 458     return TRUE;
 459 }
 460
 461 static BOOL CmdGetTypeStats(struct FECBase *FECBase, struct IOSana2Req *request)
 462 {
 463     struct FECUnit *unit;
 464     struct Opener *opener;
 465     ULONG packet_type;
 466     struct TypeStats *initial_stats, *tracker;
 467     struct Sana2PacketTypeStats *stats;
 468
 469     unit = (APTR)request->ios2_Req.io_Unit;
 470
 471     D(bug("[FEC] S2CmdGetTypeStats()\n"));
 472
 473     packet_type = request->ios2_PacketType;
 474
 475     /* Get global tracker and initial figures */
 476
 477     tracker = FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 478     opener = request->ios2_BufferManagement;
 479     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 480
 481     /* Copy and adjust figures */
 482     if(initial_stats != NULL)
 483     {
 484         stats = request->ios2_StatData;
 485         CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 486         stats->PacketsSent -= initial_stats->stats.PacketsSent;
 487         stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 488         stats->BytesSent -= initial_stats->stats.BytesSent;
 489         stats->BytesReceived -= initial_stats->stats.BytesReceived;
 490         stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 491     }
 492     else
 493     {
 494         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 495         request->ios2_WireError = S2WERR_NOT_TRACKED;
 496     }
 497
 498     /* Return */
 499
 500     return TRUE;
 501 }
 502
 503 static BOOL CmdGetGlobalStats(struct FECBase *FECBase, struct IOSana2Req *request)
 504 {
 505     struct FECUnit *unit;
 506
 507     /* Update and copy stats */
 508
 509     unit = (APTR)request->ios2_Req.io_Unit;
 510
 511     D(bug("[FEC] S2CmdGetGlobalStats()\n"));
 512
 513     CopyMem(&unit->feu_Stats, request->ios2_StatData,
 514         sizeof(struct Sana2DeviceStats));
 515
 516     /* Return */
 517
 518     return TRUE;
 519 }
 520
 521 static BOOL CmdDeviceQuery(struct FECBase *FECBase, struct IOStdReq *request)
 522 {
 523     struct NSDeviceQueryResult *info;
 524
 525     /* Set structure size twice */
 526
 527     info = request->io_Data;
 528     request->io_Actual = info->SizeAvailable =
 529         offsetof(struct NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
 530
 531     /* Report device details */
 532
 533     info->DeviceType = NSDEVTYPE_SANA2;
 534     info->DeviceSubType = 0;
 535
 536     info->SupportedCommands = (APTR)supported_commands;
 537
 538     /* Return */
 539
 540     return TRUE;
 541 }
 542
 543 static BOOL CmdOnEvent(struct FECBase *FECBase, struct IOSana2Req *request)
 544 {
 545     struct FECUnit *unit;
 546     ULONG events, wanted_events;
 547     BOOL complete = FALSE;
 548
 549     /* Check if we understand the event types */
 550
 551     unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 552
 553     D(bug("[FEC] S2CmdOnEvent()\n"));
 554
 555     wanted_events = request->ios2_WireError;
 556     if((wanted_events & ~KNOWN_EVENTS) != 0)
 557     {
 558         request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 559         events = S2WERR_BAD_EVENT;
 560     }
 561     else
 562     {
 563         if((unit->feu_Flags & IFF_UP) != 0)
 564             events = S2EVENT_ONLINE;
 565         else
 566             events = S2EVENT_OFFLINE;
 567
 568         events &= wanted_events;
 569     }
 570
 571     /* Reply request if a wanted event has already occurred */
 572     if(events != 0)
 573     {
 574         request->ios2_WireError = events;
 575         complete = TRUE;
 576     }
 577     else
 578     {
 579         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 580         PutMsg(unit->feu_RequestPorts[EVENT_QUEUE], (APTR)request);
 581     }
 582
 583     /* Return */
 584
 585     return complete;
 586 }
 587
 588 static BOOL CmdReadOrphan(struct FECBase *FECBase, struct IOSana2Req *request)
 589 {
 590     struct FECUnit *unit;
 591     BYTE error = 0;
 592     ULONG wire_error;
 593     BOOL complete = FALSE;
 594
 595     /* Check request is valid */
 596
 597     unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 598
 599     D(bug("[FEC] S2CmdReadOrphan()\n"));
 600
 601     if((unit->feu_Flags & IFF_UP) == 0)
 602     {
 603         error = S2ERR_OUTOFSERVICE;
 604         wire_error = S2WERR_UNIT_OFFLINE;
 605     }
 606
 607     /* Queue request */
 608
 609     if(error == 0)
 610     {
 611         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 612         PutMsg(unit->feu_RequestPorts[ADOPT_QUEUE], (struct Message *)request);
 613     }
 614     else
 615     {
 616         request->ios2_Req.io_Error = error;
 617         request->ios2_WireError = wire_error;
 618         complete = TRUE;
 619     }
 620
 621     /* Return */
 622
 623     return complete;
 624 }
 625
 626 static BOOL CmdOnline(struct FECBase *FECBase, struct IOSana2Req *request)
 627 {
 628     struct FECUnit *unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 629     BYTE error = 0;
 630     ULONG wire_error = 0;
 631     UWORD i;
 632
 633     D(bug("[FEC] S2CmdOnline()\n"));
 634
 635     /* Check request is valid */
 636     if((unit->feu_Flags & IFF_CONFIGURED) == 0)
 637     {
 638         error = S2ERR_BAD_STATE;
 639         wire_error = S2WERR_NOT_CONFIGURED;
 640     }
 641
 642     /* Clear global and special stats and put adapter back online */
 643
 644     if((error == 0) && ((unit->feu_Flags & IFF_UP) == 0))
 645     {
 646         unit->feu_Stats.PacketsReceived = 0;
 647         unit->feu_Stats.PacketsSent = 0;
 648         unit->feu_Stats.BadData = 0;
 649         unit->feu_Stats.Overruns = 0;
 650         unit->feu_Stats.UnknownTypesReceived = 0;
 651         unit->feu_Stats.Reconfigurations = 0;
 652
 653         for(i = 0; i < STAT_COUNT; i++)
 654             unit->feu_SpecialStats[i] = 0;
 655
 656         if (unit->start(unit)) {
 657             error = S2ERR_OUTOFSERVICE;
 658             wire_error = S2WERR_GENERIC_ERROR;
 659         }
 660     }
 661
 662     /* Return */
 663     request->ios2_Req.io_Error = error;
 664     request->ios2_WireError = wire_error;
 665     return TRUE;
 666 }
 667
 668 static BOOL CmdOffline(struct FECBase *FECBase, struct IOSana2Req *request)
 669 {
 670     struct FECUnit *unit;
 671
 672     /* Put adapter offline */
 673
 674     unit = (APTR)request->ios2_Req.io_Unit;
 675
 676     D(bug("[FEC] S2CmdOffline()\n"));
 677
 678     if((unit->feu_Flags & IFF_UP) != 0)
 679         unit->stop(unit);
 680
 681     /* Return */
 682     return TRUE;
 683 }
 684
 685 static BOOL CmdAddMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request)
 686 {
 687     struct FECUnit *unit;
 688     UBYTE *lower_bound, *upper_bound;
 689
 690     unit = (APTR)request->ios2_Req.io_Unit;
 691
 692     D(bug("[FEC] S2CmdAddMulticastAddresses()\n"));
 693
 694     lower_bound = request->ios2_SrcAddr;
 695     if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
 696         upper_bound = lower_bound;
 697     else
 698         upper_bound = request->ios2_DstAddr;
 699
 700     if(!AddMulticastRange(FECBase, unit, lower_bound, upper_bound))
 701     {
 702         request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 703         request->ios2_WireError = S2WERR_GENERIC_ERROR;
 704     }
 705
 706     /* Return */
 707
 708     return TRUE;
 709 }
 710
 711 static BOOL CmdDelMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request)
 712 {
 713     struct FECUnit *unit;
 714     UBYTE *lower_bound, *upper_bound;
 715
 716     unit = (APTR)request->ios2_Req.io_Unit;
 717
 718     D(bug("[FEC] S2CmdDelMulticastAddresses()\n"));
 719
 720     lower_bound = request->ios2_SrcAddr;
 721     if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
 722         upper_bound = lower_bound;
 723     else
 724         upper_bound = request->ios2_DstAddr;
 725
 726     if(!RemMulticastRange(FECBase, unit, lower_bound, upper_bound))
 727     {
 728         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 729         request->ios2_WireError = S2WERR_BAD_MULTICAST;
 730     }
 731
 732     /* Return */
 733
 734     return TRUE;
 735 }
 736