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     UWORD i;
 336
 337     /* Fill in the broadcast address as destination */
 338
 339     for(i = 0; i < ETH_ADDRESSSIZE; i++)
 340         request->ios2_DstAddr[i] = 0xff;
 341
 342     /* Queue the write as normal */
 343
 344     return CmdWrite(FECBase, request);
 345 }
 346
 347 static BOOL CmdTrackType(struct FECBase *FECBase, struct IOSana2Req *request)
 348 {
 349     struct FECUnit *unit;
 350     struct Opener *opener;
 351     ULONG packet_type, wire_error=0;
 352     struct TypeTracker *tracker;
 353     struct TypeStats *initial_stats;
 354     BYTE error = 0;
 355
 356     unit = (APTR)request->ios2_Req.io_Unit;
 357
 358     D(bug("[FEC] S2CmdTrackType(%d)\n", request->ios2_PacketType));
 359
 360     packet_type = request->ios2_PacketType;
 361
 362     /* Get global tracker */
 363     tracker = (struct TypeTracker *)
 364         FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 365
 366     if(tracker != NULL)
 367         tracker->user_count++;
 368     else
 369     {
 370         tracker =
 371             AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC|MEMF_CLEAR);
 372         if(tracker != NULL)
 373         {
 374             tracker->packet_type = packet_type;
 375             tracker->user_count = 1;
 376
 377             Disable();
 378             AddTail((APTR)&unit->feu_TypeTrackers, (APTR)tracker);
 379             Enable();
 380         }
 381    }
 382
 383     /* Store initial figures for this opener */
 384
 385     opener = request->ios2_BufferManagement;
 386     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 387     if(initial_stats != NULL)
 388     {
 389         error = S2ERR_BAD_STATE;
 390         wire_error = S2WERR_ALREADY_TRACKED;
 391     }
 392
 393     if(error == 0)
 394     {
 395         initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 396         if(initial_stats == NULL)
 397         {
 398             error = S2ERR_NO_RESOURCES;
 399             wire_error = S2WERR_GENERIC_ERROR;
 400         }
 401     }
 402
 403     if(error == 0)
 404     {
 405         CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 406         AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 407     }
 408
 409     /* Return */
 410
 411     request->ios2_Req.io_Error = error;
 412     request->ios2_WireError = wire_error;
 413     return TRUE;
 414 }
 415
 416 static BOOL CmdUntrackType(struct FECBase *FECBase, struct IOSana2Req *request)
 417 {
 418     struct FECUnit *unit;
 419     struct Opener *opener;
 420     ULONG packet_type;
 421     struct TypeTracker *tracker;
 422     struct TypeStats *initial_stats;
 423
 424     unit = (APTR)request->ios2_Req.io_Unit;
 425
 426     D(bug("[FEC] S2CmdUntrackType()\n"));
 427
 428     packet_type = request->ios2_PacketType;
 429
 430     /* Get global tracker and initial figures */
 431
 432     tracker = (struct TypeTracker *)
 433         FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 434     opener = request->ios2_BufferManagement;
 435     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 436
 437     /* Decrement tracker usage and free unused structures */
 438
 439     if(initial_stats != NULL)
 440     {
 441         if((--tracker->user_count) == 0)
 442         {
 443             Disable();
 444             Remove((APTR)tracker);
 445             Enable();
 446             FreeMem(tracker, sizeof(struct TypeTracker));
 447         }
 448
 449         Remove((APTR)initial_stats);
 450         FreeMem(initial_stats, sizeof(struct TypeStats));
 451     }
 452     else
 453     {
 454         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 455         request->ios2_WireError = S2WERR_NOT_TRACKED;
 456     }
 457
 458     /* Return */
 459
 460     return TRUE;
 461 }
 462
 463 static BOOL CmdGetTypeStats(struct FECBase *FECBase, struct IOSana2Req *request)
 464 {
 465     struct FECUnit *unit;
 466     struct Opener *opener;
 467     ULONG packet_type;
 468     struct TypeStats *initial_stats, *tracker;
 469     struct Sana2PacketTypeStats *stats;
 470
 471     unit = (APTR)request->ios2_Req.io_Unit;
 472
 473     D(bug("[FEC] S2CmdGetTypeStats()\n"));
 474
 475     packet_type = request->ios2_PacketType;
 476
 477     /* Get global tracker and initial figures */
 478
 479     tracker = FindTypeStats(FECBase, unit, &unit->feu_TypeTrackers, packet_type);
 480     opener = request->ios2_BufferManagement;
 481     initial_stats = FindTypeStats(FECBase, unit, &opener->initial_stats, packet_type);
 482
 483     /* Copy and adjust figures */
 484     if(initial_stats != NULL)
 485     {
 486         stats = request->ios2_StatData;
 487         CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 488         stats->PacketsSent -= initial_stats->stats.PacketsSent;
 489         stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 490         stats->BytesSent -= initial_stats->stats.BytesSent;
 491         stats->BytesReceived -= initial_stats->stats.BytesReceived;
 492         stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 493     }
 494     else
 495     {
 496         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 497         request->ios2_WireError = S2WERR_NOT_TRACKED;
 498     }
 499
 500     /* Return */
 501
 502     return TRUE;
 503 }
 504
 505 static BOOL CmdGetGlobalStats(struct FECBase *FECBase, struct IOSana2Req *request)
 506 {
 507     struct FECUnit *unit;
 508
 509     /* Update and copy stats */
 510
 511     unit = (APTR)request->ios2_Req.io_Unit;
 512
 513     D(bug("[FEC] S2CmdGetGlobalStats()\n"));
 514
 515     CopyMem(&unit->feu_Stats, request->ios2_StatData,
 516         sizeof(struct Sana2DeviceStats));
 517
 518     /* Return */
 519
 520     return TRUE;
 521 }
 522
 523 static BOOL CmdDeviceQuery(struct FECBase *FECBase, struct IOStdReq *request)
 524 {
 525     struct NSDeviceQueryResult *info;
 526
 527     /* Set structure size twice */
 528
 529     info = request->io_Data;
 530     request->io_Actual = info->SizeAvailable =
 531         offsetof(struct NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
 532
 533     /* Report device details */
 534
 535     info->DeviceType = NSDEVTYPE_SANA2;
 536     info->DeviceSubType = 0;
 537
 538     info->SupportedCommands = (APTR)supported_commands;
 539
 540     /* Return */
 541
 542     return TRUE;
 543 }
 544
 545 static BOOL CmdOnEvent(struct FECBase *FECBase, struct IOSana2Req *request)
 546 {
 547     struct FECUnit *unit;
 548     ULONG events, wanted_events;
 549     BOOL complete = FALSE;
 550
 551     /* Check if we understand the event types */
 552
 553     unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 554
 555     D(bug("[FEC] S2CmdOnEvent()\n"));
 556
 557     wanted_events = request->ios2_WireError;
 558     if((wanted_events & ~KNOWN_EVENTS) != 0)
 559     {
 560         request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 561         events = S2WERR_BAD_EVENT;
 562     }
 563     else
 564     {
 565         if((unit->feu_Flags & IFF_UP) != 0)
 566             events = S2EVENT_ONLINE;
 567         else
 568             events = S2EVENT_OFFLINE;
 569
 570         events &= wanted_events;
 571     }
 572
 573     /* Reply request if a wanted event has already occurred */
 574     if(events != 0)
 575     {
 576         request->ios2_WireError = events;
 577         complete = TRUE;
 578     }
 579     else
 580     {
 581         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 582         PutMsg(unit->feu_RequestPorts[EVENT_QUEUE], (APTR)request);
 583     }
 584
 585     /* Return */
 586
 587     return complete;
 588 }
 589
 590 static BOOL CmdReadOrphan(struct FECBase *FECBase, struct IOSana2Req *request)
 591 {
 592     struct FECUnit *unit;
 593     BYTE error = 0;
 594     ULONG wire_error;
 595     BOOL complete = FALSE;
 596
 597     /* Check request is valid */
 598
 599     unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 600
 601     D(bug("[FEC] S2CmdReadOrphan()\n"));
 602
 603     if((unit->feu_Flags & IFF_UP) == 0)
 604     {
 605         error = S2ERR_OUTOFSERVICE;
 606         wire_error = S2WERR_UNIT_OFFLINE;
 607     }
 608
 609     /* Queue request */
 610
 611     if(error == 0)
 612     {
 613         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 614         PutMsg(unit->feu_RequestPorts[ADOPT_QUEUE], (struct Message *)request);
 615     }
 616     else
 617     {
 618         request->ios2_Req.io_Error = error;
 619         request->ios2_WireError = wire_error;
 620         complete = TRUE;
 621     }
 622
 623     /* Return */
 624
 625     return complete;
 626 }
 627
 628 static BOOL CmdOnline(struct FECBase *FECBase, struct IOSana2Req *request)
 629 {
 630     struct FECUnit *unit = (struct FECUnit *)request->ios2_Req.io_Unit;
 631     BYTE error = 0;
 632     ULONG wire_error = 0;
 633     UWORD i;
 634
 635     D(bug("[FEC] S2CmdOnline()\n"));
 636
 637     /* Check request is valid */
 638     if((unit->feu_Flags & IFF_CONFIGURED) == 0)
 639     {
 640         error = S2ERR_BAD_STATE;
 641         wire_error = S2WERR_NOT_CONFIGURED;
 642     }
 643
 644     /* Clear global and special stats and put adapter back online */
 645
 646     if((error == 0) && ((unit->feu_Flags & IFF_UP) == 0))
 647     {
 648         unit->feu_Stats.PacketsReceived = 0;
 649         unit->feu_Stats.PacketsSent = 0;
 650         unit->feu_Stats.BadData = 0;
 651         unit->feu_Stats.Overruns = 0;
 652         unit->feu_Stats.UnknownTypesReceived = 0;
 653         unit->feu_Stats.Reconfigurations = 0;
 654
 655         for(i = 0; i < STAT_COUNT; i++)
 656             unit->feu_SpecialStats[i] = 0;
 657
 658         if (unit->start(unit)) {
 659             error = S2ERR_OUTOFSERVICE;
 660             wire_error = S2WERR_GENERIC_ERROR;
 661         }
 662     }
 663
 664     /* Return */
 665     request->ios2_Req.io_Error = error;
 666     request->ios2_WireError = wire_error;
 667     return TRUE;
 668 }
 669
 670 static BOOL CmdOffline(struct FECBase *FECBase, struct IOSana2Req *request)
 671 {
 672     struct FECUnit *unit;
 673
 674     /* Put adapter offline */
 675
 676     unit = (APTR)request->ios2_Req.io_Unit;
 677
 678     D(bug("[FEC] S2CmdOffline()\n"));
 679
 680     if((unit->feu_Flags & IFF_UP) != 0)
 681         unit->stop(unit);
 682
 683     /* Return */
 684     return TRUE;
 685 }
 686
 687 static BOOL CmdAddMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request)
 688 {
 689     struct FECUnit *unit;
 690     UBYTE *lower_bound, *upper_bound;
 691
 692     unit = (APTR)request->ios2_Req.io_Unit;
 693
 694     D(bug("[FEC] S2CmdAddMulticastAddresses()\n"));
 695
 696     lower_bound = request->ios2_SrcAddr;
 697     if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
 698         upper_bound = lower_bound;
 699     else
 700         upper_bound = request->ios2_DstAddr;
 701
 702     if(!AddMulticastRange(FECBase, unit, lower_bound, upper_bound))
 703     {
 704         request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 705         request->ios2_WireError = S2WERR_GENERIC_ERROR;
 706     }
 707
 708     /* Return */
 709
 710     return TRUE;
 711 }
 712
 713 static BOOL CmdDelMulticastAddresses(struct FECBase *FECBase, struct IOSana2Req *request)
 714 {
 715     struct FECUnit *unit;
 716     UBYTE *lower_bound, *upper_bound;
 717
 718     unit = (APTR)request->ios2_Req.io_Unit;
 719
 720     D(bug("[FEC] S2CmdDelMulticastAddresses()\n"));
 721
 722     lower_bound = request->ios2_SrcAddr;
 723     if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
 724         upper_bound = lower_bound;
 725     else
 726         upper_bound = request->ios2_DstAddr;
 727
 728     if(!RemMulticastRange(FECBase, unit, lower_bound, upper_bound))
 729     {
 730         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 731         request->ios2_WireError = S2WERR_BAD_MULTICAST;
 732     }
 733
 734     /* Return */
 735
 736     return TRUE;
 737 }
 738